Dada uma sequência de arte ASCII como essa (isso não é arte ASCII, mas servirá como exemplo):

abc
d e
fgh

Misture como se estivesse sendo exibido em uma tela com um caractere por linha, da seguinte maneira:

a
b
c
d

e
f
g
h

Imprima o resultado, aguarde um segundo, ± 0,5 segundos antes de limpar o terminal e imprima a mesma coisa, mas com 2 caracteres exibidos por linha em vez de 1. Basicamente, a largura da tela muda de 1 para 2.

ab
c
d 
e
fg
h

Observe o espaço após o d. Repita a espera e depois imprima com um caractere adicional por linha até que o texto inserido seja produzido.

Se você atingir o final de uma linha ao tentar imprimir caracteres, insira uma nova linha e imprime o restante seguindo esta regra. Por exemplo, a entrada:

abcdefg
ab

Imprimia o seguinte quando o comprimento da tela é 4.

abcd
efg
ab

Você pode encontrar o efeito do redimensionamento do terminal aqui: https://repl.it/GoeU/1 . Execute o programa e arraste a coisa que separa o terminal do editor de texto para frente e para trás.

Esclarecimento:

Quando uma linha aparecer exatamente como foi inserida, você poderá deixá-la em paz para futuras contagens maiores de caracteres por linha.

abc
ab

deve imprimir

ab
c
ab

quando o comprimento da sentença = 2.

Este é o código-golfe , pelo que ganha menos quantidade de bytes!

Regras:

• É necessário imprimir em STDOUT como a única saída.
• É necessário limpar o terminal ou criar a ilusão de limpar o terminal adicionando 150 linhas vazias.
• Pode receber informações através dos métodos padrão.
• Aplicam-se brechas padrão.
• Trailing material com o texto não está bem.

Essa ideia me ocorreu quando eu estava redimensionando um terminal com arte ASCII. Parecia interessante, então decidi fazer disso um desafio.

Casos de teste:

Como seria muito difícil mostrar cada etapa de cada caso de teste individualmente, revisarei cada resposta para garantir que seja válida. Verifique se a resposta pode lidar com os casos de teste.

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

Esta pasta .

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

Bash (com coreutils GNU), 69 bytes

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

Salva a entrada no arquivo temporário x, depois conta a linha mais longa (o GNU coreutils ' wcpossui -Lsinalizador para isso) e itera para cada largura de console de 1 ao comprimento de linha mais longo. fold, sleepE clearfaz o resto da magia.

Python 3.6, 124 bytes

Loops ao longo do comprimento da string de entrada, como a solução 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 apenas para a largura da linha mais longa - resposta do Bash de 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)

Usa "re.split ((. {1, i + 1}))" para dividir a sequência em grupos de caracteres. Porque '.' não corresponde a \ \ n, os grupos não se agrupam de uma linha para a seguinte. Se o regex usar um grupo de captura, re.split () retornará uma lista com os grupos correspondentes nos índices ímpares. Estes são recuperados com [1 :: 2].

Usa a string f python 3.6 para fazer com que o padrão re dependa da largura do grupo i.

O * na frente de re.split () usa a descompactação do python 3.6 para transformar a lista em argumentos para a instrução print. Da mesma forma, * '\ n' * 75, se transforma em argumentos de 75 '\ n' para a instrução print. Com o argumento de palavra-chave print sep = '\ n', o resultado é imprimir cerca de 150 linhas em branco para limpar a tela, seguidas por cada grupo de caracteres em uma linha separada.

Python 3.5 ( 238 233 229 225 223 222 bytes)

- Funciona bem no terminal do Windows; não tenho certeza sobre outras plataformas, devido ao comando os.system ("cls") específico do sistema.

- A cadeia passada deve ser marcada por \ n para novas linhas, por exemplo: '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 salvos: espaços em branco indesejados removidos
• 4 bytes salvos: abreviação de len (s)
• 4 bytes salvos: Graças a sparklepony (abreviação de impressão)
• salvou 2 bytes: Graças ao sparklepony (abreviação de range como re (0, i) como range (i))
• economizou 1 byte: Graças a steve (0,5 como apenas 0,5)