Bei einer solchen Zeichenfolge von ASCII-Grafiken (Dies ist keine ASCII-Grafik, aber für das Beispiel ausreichend):

abc
d e
fgh

Durcheinander, als würde es auf einem Bildschirm mit einem Zeichen pro Zeile angezeigt, wie folgt:

a
b
c
d

e
f
g
h

Drucken Sie das Ergebnis aus, warten Sie eine Sekunde, ± 0,5 Sekunden, bevor Sie das Terminal löschen, und drucken Sie dasselbe, wobei jedoch 2 Zeichen pro Zeile anstelle von 1 angezeigt werden. Grundsätzlich ändert sich die Breite der Anzeige von 1 auf 2.

ab
c
d 
e
fg
h

Beachten Sie das Leerzeichen nach dem d . Wiederholen Sie das Warten und drucken Sie dann mit einem zusätzlichen Zeichen pro Zeile, bis der eingegebene Text ausgegeben wird.

Wenn Sie beim Drucken von Zeichen das Zeilenende erreichen, fügen Sie eine neue Zeile ein und drucken den Rest nach dieser Regel. Zum Beispiel die Eingabe:

abcdefg
ab

Würde Folgendes drucken, wenn die Anzeigelänge 4 beträgt.

abcd
efg
ab

Den Effekt der Größenänderung des Terminals finden Sie hier: https://repl.it/GoeU/1 . Führen Sie das Programm aus und ziehen Sie das Objekt, das das Terminal vom Texteditor trennt, hin und her.

Klärung:

Sobald eine Zeile genau so angezeigt wird, wie sie eingegeben wurde, können Sie diese Zeile für zukünftige größere Zeichenzahlen pro Zeile in Ruhe lassen.

abc
ab

sollte drucken

ab
c
ab

wenn die Satzlänge = 2 ist.

Dies ist Code-Golf , also gewinnt die geringste Anzahl von Bytes!

Regeln:

• Muss als einzige Ausgabe auf STDOUT gedruckt werden.
• Muss das Terminal löschen oder die Illusion erzeugen, das Terminal zu löschen, indem etwa 150 leere Zeilen hinzugefügt werden.
• Kann Eingaben über die Standardmethoden vornehmen.
• Es gelten Standardlücken.
• Nachlaufende Inhalte mit dem Text sind NICHT OK.

Diese Idee kam mir, als ich die Größe eines Terminals mit ASCII-Grafik änderte. Es sah interessant aus, also beschloss ich, eine Herausforderung daraus zu machen.

Testfälle:

Da es zu viel Arbeit wäre, jeden Schritt für jeden Testfall einzeln anzuzeigen, werde ich jede Antwort überprüfen, um sicherzustellen, dass sie gültig ist. Stellen Sie sicher, dass die Antwort die Testfälle verarbeiten kann.

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

Dieser Pastebin .

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

Bash (mit GNU-Coreutils), 69 Bytes

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

Speichert die Eingabe in einer temporären Datei x, zählt dann die längste Zeile (GNU coreutils wchat dafür ein -LFlag) und iteriert für jede Konsolenbreite von 1 bis zur längsten Zeilenlänge. fold, sleepUnd clearmacht den Rest der Magie.

Python 3.6, 124 Bytes

Schleifen über die Länge der Eingabezeichenfolge wie bei der offiziellen Lösung

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, um nur auf die Breite der längsten Zeile zu gehen, eine Antwort von al Frxstrem's Bash

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)

Verwendet "re.split ((. {1, i + 1}))", um die Zeichenfolge in Zeichengruppen aufzuteilen. Weil '.' stimmt nicht mit '\ n' überein, die Gruppen werden nicht von einer Zeile zur nächsten umgebrochen. Wenn der reguläre Ausdruck eine Erfassungsgruppe verwendet, gibt re.split () eine Liste mit den übereinstimmenden Gruppen an den ungeraden Indizes zurück. Diese werden mit [1 :: 2] abgerufen.

Verwendet Python 3.6 F-String, um das Muster von der Gruppenbreite i abhängig zu machen.

Das * vor re.split () verwendet das Entpacken von Python 3.6, um die Liste in Argumente für die print-Anweisung umzuwandeln. In ähnlicher Weise wird * '\ n' * 75 zu 75 '\ n' Argumenten für die print-Anweisung. Mit dem print-Schlüsselwortargument sep = '\ n' werden etwa 150 leere Zeilen gedruckt, um den Bildschirm zu löschen, gefolgt von jeder Zeichengruppe in einer separaten Zeile.

Python 3.5 ( 238 233 229 225 223 222 Bytes)

- Funktioniert gut im Windows-Terminal; Bei anderen Plattformen aufgrund des systemspezifischen Befehls os.system ("cls") nicht sicher.

- Die übergebene Zeichenfolge sollte für Zeilenumbrüche mit \ n markiert sein, z. B.: '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 gespeichert: unerwünschte Leerzeichen entfernt
• 4 Bytes gespeichert: Abkürzung für len (s)
• 4 Bytes gespeichert : Dank Sparklepony (Abkürzung für Print)
• 2 Bytes gespart: Dank Sparklepony (Abkürzung für Bereich als r und r (0, i) als Bereich (i))
• 1 Byte gespeichert: Dank Steve (0,5 als nur 0,5)