Étant donné une chaîne d'art ASCII comme celle-ci (ce n'est pas de l'art ASCII mais cela fera pour l'exemple):

abc
d e
fgh

Mélangez-le comme s'il était affiché sur un écran avec un caractère par ligne, comme ceci:

a
b
c
d

e
f
g
h

Imprimez le résultat, attendez une seconde, ± 0,5 seconde avant d'effacer le terminal et imprimez la même chose, mais avec 2 caractères affichés par ligne au lieu de 1. Fondamentalement, la largeur de l'affichage passe de 1 à 2.

ab
c
d 
e
fg
h

Notez l'espace après le d. Répétez l'attente, puis imprimez avec un caractère supplémentaire par ligne jusqu'à ce que le texte saisi soit sorti.

Si vous appuyez sur la fin d'une ligne lorsque vous essayez d'imprimer des caractères, vous insérez une nouvelle ligne et imprimez les autres en suivant cette règle. Par exemple, l'entrée:

abcdefg
ab

Imprime ce qui suit lorsque la longueur d'affichage est de 4.

abcd
efg
ab

Vous pouvez trouver l'effet du redimensionnement du terminal ici: https://repl.it/GoeU/1 . Exécutez le programme, puis faites glisser la chose séparant le terminal de l'éditeur de texte d'avant en arrière.

Clarification:

Une fois qu'une ligne apparaît exactement comme elle a été entrée, vous pouvez laisser cette ligne seule pour les futurs nombres de caractères plus importants par ligne.

abc
ab

devrait imprimer

ab
c
ab

lorsque la durée de la phrase = 2.

Il s'agit de code-golf , donc le moins d'octets gagne!

Règles:

• Doit imprimer sur STDOUT comme seule sortie.
• Doit vider le terminal, ou créer l'illusion de vider le terminal en ajoutant environ 150 lignes vides.
• Peut prendre des informations via les méthodes standard.
• Les failles par défaut s'appliquent.
• Trailer des trucs avec le texte n'est PAS OK.

Cette idée m'est venue lorsque je redimensionnais un terminal avec de l'art ASCII dessus. Cela avait l'air intéressant, alors j'ai décidé d'en faire un défi.

Cas de test:

Comme ce serait trop de travail de montrer chaque étape pour chaque cas de test individuellement, je vais examiner chaque réponse pour m'assurer qu'elle est valide. Assurez-vous que la réponse peut gérer les cas de test.

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

Cette boîte à pâte .

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

Bash (avec GNU coreutils), 69 octets

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

Enregistre l'entrée dans un fichier temporaire x, puis compte la ligne la plus longue (GNU coreutils wca un -Lindicateur pour cela) et itère pour chaque largeur de console de 1 à la longueur de ligne la plus longue. fold, sleepet clearfait le reste de la magie.

Python 3.6, 124 octets

Boucles sur la longueur de la chaîne d'entrée comme la solution 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 octets pour aller uniquement à la largeur de la ligne la plus longue d'une réponse Bash d'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)

Utilise "re.split ((. {1, i + 1}))" "pour diviser la chaîne en groupes de caractères. Parce que '.' ne correspond pas à '\ n', les groupes ne passent pas d'une ligne à l'autre. Si l'expression régulière utilise un groupe de capture, alors re.split () renvoie une liste avec les groupes correspondants aux index impairs. Ceux-ci sont récupérés avec [1 :: 2].

Utilise la chaîne f de python 3.6 pour faire dépendre le motif re de la largeur du groupe i.

Le * devant re.split () utilise le déballage de python 3.6 pour transformer la liste en arguments de l'instruction print. De même, * '\ n' * 75, se transforme en 75 '\ n' arguments pour l'instruction print. Avec l'argument mot clé d'impression sep = '\ n', le résultat est d'imprimer environ 150 lignes vides pour effacer l'écran, suivies de chaque groupe de caractères sur une ligne distincte.

Python 3.5 ( 238 233 229 225 223 222 octets)

- Fonctionne bien dans le terminal Windows; pas sûr des autres plates-formes, en raison de la commande os.system ("cls") spécifique au système.

- La chaîne transmise doit être marquée par \ n pour les sauts de ligne, par exemple: '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 octets enregistrés: suppression des espaces blancs indésirables
• 4 octets enregistrés: raccourci pour len (s)
• 4 octets enregistrés: Merci à sparklepony (raccourci pour l'impression)
• sauvé 2 octets: Merci à sparklepony (raccourci pour plage comme r et r (0, i) comme plage (i))
• sauvé 1 octet: Merci à Steve (0,5 comme seulement 0,5)