# Create an ASCII art unjumble!

Given a string of ASCII art like such (This isn't ASCII art but it will do for the example):

abc
d e
fgh


Jumble it as if it was being displayed on a screen with one character per line, like so:

a
b
c
d

e
f
g
h


Print the result, wait one second, ±0.5 seconds before clearing the terminal and the print the same thing, but with 2 characters displayed per line instead of 1. Basically, the width of the display turns from 1 to 2.

ab
c
d
e
fg
h


Note the space after the d. Repeat waiting, then printing with an additional character per line until the inputted text is outputted.

If you hit the end of a line when trying to print characters, then you insert a newline and print the rest of them following this rule. For example the input:

abcdefg
ab


Would print the following when the display length is 4.

abcd
efg
ab


You can find the effect of the terminal resize here: https://repl.it/GoeU/1. Run the program, then drag the thing separating the terminal from the text editor back and forth.

Clarification:

Once a line appears exactly how it was inputted, you can leave that line alone for future larger character counts per line.

abc
ab


should print

ab
c
ab


when the sentence length = 2.

This is , so least amount of bytes wins!

Rules:

• Must print to STDOUT as the only output.
• Must clear the terminal, or create the illusion of clearing the terminal by adding 150 or so empty lines.
• Can take input through the standard methods.
• Default loopholes apply.
• Trailing stuff with the text is NOT OKAY.

This idea came to me when I was resizing a terminal with ASCII art on it. It looked interesting, so I decided to make a challenge out of it.

Test cases:

Since it would be too much work to show each step for each test case individually, I will review each answer to make sure it is valid. Make sure the answer can handle the test cases.

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

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


# Bash (with GNU coreutils), 69 bytes

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


Saves input in temporary file x, then counts the longest line (GNU coreutils' wc has -L flag for this) and iterates for each console width from 1 to the longest line length. fold, sleep and clear does the rest of the magic.

# Python 3.6, 124 bytes

Loops over length of input string like officialaimm's solution

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 to only go to width of longest line a al Frxstrem's Bash answer

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)


Uses "re.split((.{1,i+1}))" to break the string into groups of characters. Because '.' doesn't match '\n', the groups don't wrap around from one line to the next. If the regex uses a capturing group, then re.split() returns a list with the matched groups at the odd indexes. These are retrieved with [1::2].

Uses python 3.6 f-string to make the re pattern depend on group width i.

The * in front of re.split() uses python 3.6 unpacking to turn the list into arguments to the print statement. Similarly, *'\n'*75, turns into 75 '\n' arguments to the print statement. With the print keyword argument sep='\n', the result is printing about 150 blank lines to clear the screen, followed by each group of characters on a separate line.

• This ones way better and shorter than mine. Great job! (y) – officialaimm Apr 2 '17 at 2:55

# Python 3.5 (238233229225223 222 bytes)

### - The string passed should be marked by \n for newlines eg: '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)

• Saved 5 bytes: removed unwanted whitespaces
• Saved 4 bytes: shorthand for len(s)
• Saved 4 bytes: Thanks to sparklepony (shorthand for print)
• saved 2 bytes: Thanks to sparklepony (shorthand for range as r and r(0,i) as range(i))
• saved 1 byte: Thanks to steve (0.5 as just .5)
• Cool! I think you could shave off some bytes by using the code z=print at the top, and then changing all other instances of print() to z(). – Comrade SparklePony Apr 1 '17 at 13:09
• I think you cold do the same thing you did with print with range, and instead of range(0,3) use range(3). – Comrade SparklePony Apr 1 '17 at 17:05
• sleep(0.5) can be rewritten as merely sleep(.5) – steve Apr 1 '17 at 21:36