Dada una cadena de arte ASCII como tal (Esto no es arte ASCII pero servirá para el ejemplo):

abc
d e
fgh

Agítelo como si se mostrara en una pantalla con un carácter por línea, así:

a
b
c
d

e
f
g
h

Imprima el resultado, espere un segundo, ± 0.5 segundos antes de limpiar el terminal y la impresión de la misma manera, pero con 2 caracteres mostrados por línea en lugar de 1. Básicamente, el ancho de la pantalla cambia de 1 a 2.

ab
c
d 
e
fg
h

Tenga en cuenta el espacio después de d. Repita la espera, luego imprima con un carácter adicional por línea hasta que salga el texto ingresado.

Si toca el final de una línea cuando intenta imprimir caracteres, inserte una nueva línea e imprima el resto siguiendo esta regla. Por ejemplo la entrada:

abcdefg
ab

Imprimiría lo siguiente cuando la longitud de la pantalla sea 4.

abcd
efg
ab

Puede encontrar el efecto del cambio de tamaño del terminal aquí: https://repl.it/GoeU/1 . Ejecute el programa, luego arrastre la cosa que separa el terminal del editor de texto de un lado a otro.

Aclaración:

Una vez que una línea aparece exactamente como se ingresó, puede dejar esa línea sola para futuros recuentos de caracteres más grandes por línea.

abc
ab

debería imprimir

ab
c
ab

cuando la longitud de la oración = 2.

Este es el código de golf , por lo que gana la menor cantidad de bytes.

Reglas:

• Debe imprimir en STDOUT como la única salida.
• Debe borrar el terminal o crear la ilusión de borrar el terminal agregando aproximadamente 150 líneas vacías.
• Puede recibir información a través de los métodos estándar.
• Se aplican las lagunas predeterminadas.
• El seguimiento de cosas con el texto NO ESTÁ BIEN.

Esta idea se me ocurrió cuando estaba cambiando el tamaño de un terminal con arte ASCII. Parecía interesante, así que decidí hacer un desafío.

Casos de prueba:

Dado que sería demasiado trabajo mostrar cada paso para cada caso de prueba individualmente, revisaré cada respuesta para asegurarme de que sea válida. Asegúrese de que la respuesta pueda manejar los casos de prueba.

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

Este pastebin .

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

Bash (con GNU coreutils), 69 bytes

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

Guarda la entrada en el archivo temporal x, luego cuenta la línea más larga (GNU coreutils ' wctiene una -Lmarca para esto) e itera para cada ancho de consola desde 1 hasta la longitud de línea más larga. fold, sleepy clearhace el resto de la magia.

Python 3.6, 124 bytes

Recorre la longitud de la cadena de entrada como la solución de 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 bytes para ir solo al ancho de la línea más larga a la respuesta Bash de 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)

Utiliza "re.split ((. {1, i + 1}))" para dividir la cadena en grupos de caracteres. Porque '.' no coincide con '\ n', los grupos no se envuelven de una línea a la siguiente. Si la expresión regular utiliza un grupo de captura, entonces re.split () devuelve una lista con los grupos coincidentes en los índices impares. Estos se recuperan con [1 :: 2].

Utiliza python 3.6 f-string para hacer que el patrón re dependa del ancho del grupo i.

El * delante de re.split () usa el desempaquetado de python 3.6 para convertir la lista en argumentos para la declaración de impresión. Del mismo modo, * '\ n' * 75, se convierte en argumentos de 75 '\ n' para la declaración de impresión. Con el argumento de la palabra clave print sep = '\ n', el resultado es imprimir unas 150 líneas en blanco para borrar la pantalla, seguido de cada grupo de caracteres en una línea separada.

Python 3.5 ( 238 233 229 225 223 222 bytes)

- Funciona bien en la terminal de Windows; no estoy seguro acerca de otras plataformas, debido al comando os.system ("cls") específico del sistema.

- La cadena pasada debe marcarse con \ n para líneas nuevas, por ejemplo: '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)

• 5 bytes guardados: espacios en blanco no deseados eliminados
• Guardado 4 bytes: taquigrafía para len (s)
• Guardado 4 bytes: Gracias a sparklepony (abreviatura para imprimir)
• 2 bytes guardados: Gracias a sparklepony (abreviatura de rango como r y r (0, i) como rango (i))
• guardado 1 byte: Gracias a Steve (0.5 como solo .5)