Data una stringa di arte ASCII come tale (Questa non è arte ASCII ma lo farà per l'esempio):

abc
d e
fgh

Mischialo come se fosse visualizzato su uno schermo con un carattere per riga, in questo modo:

a
b
c
d

e
f
g
h

Stampa il risultato, attendi un secondo, ± 0,5 secondi prima di cancellare il terminale e stampa la stessa cosa, ma con 2 caratteri visualizzati per riga anziché 1. In pratica, la larghezza del display passa da 1 a 2.

ab
c
d 
e
fg
h

Nota lo spazio dopo il d. Ripetere l'attesa, quindi stampare con un carattere aggiuntivo per riga fino a quando non viene emesso il testo immesso.

Se si tocca la fine di una riga quando si tenta di stampare caratteri, si inserisce una nuova riga e si stampa il resto di loro seguendo questa regola. Ad esempio l'input:

abcdefg
ab

Stampa quanto segue quando la lunghezza del display è 4.

abcd
efg
ab

Puoi trovare l'effetto del ridimensionamento del terminale qui: https://repl.it/GoeU/1 . Esegui il programma, quindi trascina avanti e indietro l'elemento che separa il terminale dall'editor di testo.

Una precisazione:

Una volta che una linea appare esattamente come è stata immessa, puoi lasciarla sola per conteggi di caratteri futuri più grandi per linea.

abc
ab

dovrebbe stampare

ab
c
ab

quando la lunghezza della frase = 2.

Questo è code-golf , quindi vince la quantità minima di byte!

Regole:

• È necessario stampare su STDOUT come unico output.
• Deve cancellare il terminale o creare l'illusione di cancellare il terminale aggiungendo circa 150 righe vuote.
• Può ricevere input attraverso i metodi standard.
• Si applicano scappatoie predefinite.
• Trascinare roba con il testo NON È OK.

Questa idea mi è venuta in mente quando stavo ridimensionando un terminale con arte ASCII su di esso. Sembrava interessante, quindi ho deciso di farne una sfida.

Casi test:

Dal momento che sarebbe troppo lavoro per mostrare ogni passaggio per ogni singolo test, esaminerò ogni risposta per assicurarmi che sia valido. Assicurati che la risposta sia in grado di gestire i casi di test.

 ______   ______     __     __   __     ______      __    __     ______    
/\  == \ /\  == \   /\ \   /\ "-.\ \   /\__  _\    /\ "-./  \   /\  ___\   
\ \  _-/ \ \  __<   \ \ \  \ \ \-.  \  \/_/\ \/    \ \ \-./\ \  \ \  __\   
 \ \_\    \ \_\ \_\  \ \_\  \ \_\\"\_\    \ \_\     \ \_\ \ \_\  \ \_____\ 
  \/_/     \/_/ /_/   \/_/   \/_/ \/_/     \/_/      \/_/  \/_/   \/_____/ 

Questo pastebin .

                        __/\__
                        \    /
                  __/\__/    \__/\__
                  \                /
                  /_              _\
                    \            /
      __/\__      __/            \__      __/\__
      \    /      \                /      \    /
__/\__/    \__/\__/                \__/\__/    \__/\__

Bash (con coreutils GNU), 69 byte

n=`tee x|wc -L`;for i in `seq 1 $n`;do fold -w$i x;sleep 1;clear;done

Salva l'input nel file temporaneo x, quindi conta la linea più lunga (GNU coreutils ' wcha un -Lflag per questo) e scorre per ogni larghezza della console da 1 alla lunghezza della linea più lunga. fold, sleepE clearfa il resto della magia.

Python 3.6, 124 byte

Passa oltre la lunghezza della stringa di input come la soluzione di officialaimm

import re,time
def d(s):
 for i in range(len(s)):print(*'\n'*75,*re.split(f'(.{{1,{i+1}}})',s)[1::2],sep='\n');time.sleep(1)

143 byte per andare solo alla larghezza della linea più lunga una risposta di Bash di al Frxstrem

import re,time
def d(s):
 for i in range(max(map(len,s.split()))):print(*'\n'*75,*re.split(f'(.{{1,{i+1}}})', s)[1::2],sep='\n');time.sleep(.5)

Utilizza "re.split ((. {1, i + 1}))" per suddividere la stringa in gruppi di caratteri. Perché '.' non corrisponde a "\ n", i gruppi non si spostano da una riga all'altra. Se regex utilizza un gruppo di acquisizione, re.split () restituisce un elenco con i gruppi corrispondenti sugli indici dispari. Questi vengono recuperati con [1 :: 2].

Usa la f-stringa di python 3.6 per fare in modo che il modello re dipenda dalla larghezza del gruppo i.

* Davanti a re.split () usa la decompressione di Python 3.6 per trasformare l'elenco in argomenti per l'istruzione print. Allo stesso modo, * '\ n' * 75, si trasforma in 75 '\ n' argomenti per l'istruzione print. Con l'argomento della parola chiave print sep = '\ n', il risultato è la stampa di circa 150 righe vuote per cancellare lo schermo, seguite da ciascun gruppo di caratteri su una riga separata.

Python 3.5 ( 238 233 229 225 223 222 byte)

- Funziona bene nel terminale di Windows; non sono sicuro di altre piattaforme, a causa del comando os.system ("cls") specifico del sistema.

- La stringa passata deve essere contrassegnata da \ n per i newline, ad esempio: 'abc \ nd efgh \ n'

import os,time 
def b(s):
 p=len(s);z=print;r=range
 for i in r(1,p):
  os.system("cls");l=0
  for j in r(p):
   z(s[j],end="");l+=1
   if(s[j]=='\n'):l=0
   if(j+1<p and l==i and s[j+1]!='\n'):z();l=0
  z();time.sleep(.5)

• Salvati 5 byte: rimossi spazi bianchi indesiderati
• 4 byte salvati: stenografia per len (s)
• Salvati 4 byte: grazie a sparklepony (stenografia per la stampa)
• salvato 2 byte: grazie a sparklepony (scorciatoia per intervallo come r (r, 0) come intervallo (i))
• salvato 1 byte: grazie a steve (0,5 come solo 0,5)