Geben Sie eine Textfolge als "Turm" aus.

Jedes Stück der Zeichenfolge (des Formulars 0:n) wird mehrmals wiederholt 5*n, sodass das erste Zeichen fünfmal, dann das erste und das zweite zehnmal usw. wiederholt wird.

Beispiele:

'hello' ->

['h']  
['h']  
['h']  
['h']  
['h']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  


'cat' ->

['c']  
['c']  
['c']  
['c']  
['c']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  

Regeln:

Sie können jede Ebene als Liste von Zeichen oder nur als Zeichenfolge ausgeben.

R , 48 Bytes

function(s)substring(s,1,rep(x<-1:nchar(s),x*5))

Probieren Sie es online!

Gibt eine Liste von Zeichenfolgen zurück.

05AB1E , 6 Bytes

ηā5*ÅΓ

Probieren Sie es online!

Gibt eine Liste mit Zeichenfolgen zurück.

Erläuterung

     ÅΓ # Run-length decode...
η       # ... the prefixes of the input
 ā5*и   # ... with the length range multiplied by 5 -- [5, 10, 15, 20, 25]

Haskell , 36 Bytes

f""=[]
f s=f(init s)++(s<$s<*[1..5])

Probieren Sie es online!

Stax , 8 Bytes

äï▄;♫├W^

Führen Sie es aus und debuggen Sie es

Ausgepackt, ungolfed und kommentiert sieht es so aus.

|[F for each prefix of the input
  i^5*  5*(i+1) where i is the iteration index
  DQ    that many times, peek and print to output

Führen Sie dieses aus

TI-Basic (TI-84 Plus CE), 29 Byte (27 Token)

For(A,1,length(Ans
For(B,1,5A
Disp sub(Ans,1,A
End
End

Erläuterung:

For(A,1,length(Ans # 9 bytes, 8 tokens: for A from 1 to the length of the string
For(B,1,5A         # 8 bytes, 8 tokens:  5*A times
Disp sub(Ans,1,A   # 9 bytes, 8 tokens:   Print the first A characters of the string 
End                # 2 bytes, 2 tokens:  end loop
End                # 1 byte,  1 token:  end loop

Retina , 15 Bytes

.
$.>`*5*$($>`¶

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

.

Entspricht jedem Zeichen in der Zeichenfolge.

$.>`*5*$($>`¶

$`ist das Präfix des Matches. Retina stellt dann zwei Modifikatoren zur Verfügung und >ändert sie so, dass sie zwischen aufeinanderfolgenden Übereinstimmungen im Kontext der Zeichenfolge steht, während sie .die Länge annimmt. Wir beginnen daher mit dem Präfix des Suffix, das der Übereinstimmung einschließlich des Präfixes entspricht. Dies spart 2 Bytes bei überlappenden Übereinstimmungen. Das $(verkettet dann das mit einer neuen Zeile, das 5*wiederholt es, und das $.>`wiederholt es ein weiteres Mal, das durch seine Länge gegeben wird.

Canvas , 6 Bytes

［³５×＊Ｐ

Probieren Sie es hier aus!

Erläuterung:

[      for each prefix
 ³5×     1-indexed counter * 5
    *    repeat the prefix vertically that many times
     P   and print that

Brachylog , 15 Bytes

a₀ᶠ⟨gj₎{l×₅}⟩ᵐc

Probieren Sie es online!

Das Finale ckann entfernt werden, wenn OP die Frage nach der Ausgabe von 2D-Arrays positiv beantwortet.

Cubix ,  44  40 Bytes

i.!?@UBqwW_#/>u...;B^...?qo;;q*n5;oN/./)

Probieren Sie es online!

Dies hat noch viele No-Ops, aber es ist ein bisschen besser als zuvor.

Als sehr kurze Beschreibung wird ein Zeichen aus der Eingabe genommen und auf EOI (-1) getestet. Ist dies der Fall, halten Sie an. Der Stapel wird dann umgekehrt. Ermitteln Sie die Anzahl der Elemente auf dem Stapel und multiplizieren Sie diese mit -5. Lass das auf den Boden des Stapels fallen und räum auf. Durchlaufen Sie den Stapel und drucken Sie, bis eine negative Zahl angezeigt wird. Drucken Sie eine neue Zeile, erhöhen Sie die Zahl, wenn 0 die Null senkt, kehren Sie den Stapel um und beginnen Sie erneut mit der Eingabe. Andernfalls durchlaufen Sie den Stapel, und drucken Sie, bis eine negative Zahl ... ad nauseum ist

Kubifiziert sieht es aus

      i . !
      ? @ U
      B q w
W _ # / > u . . . ; B ^
. . . ? q o ; ; q * n 5
; o N / . / ) . . . . .
      . . .
      . . .
      . . .

Schau es dir online an

Gelee , 8 Bytes

¹Ƥx'J×5Ɗ

Probieren Sie es online!

J×5x'@¹Ƥ

Probieren Sie es online!

¹Ƥx'Jx'5

Probieren Sie es online!

Das ist wahrscheinlich golfen.

JavaScript, 48 46 Bytes

(danke @redundancy)

Edit: Der Autor hat geklärt und diese Antwort ist jetzt nicht gültig, aber ich werde sie hier unverändert lassen.

Gibt ein Array von mehrzeiligen Zeichenfolgen zurück.

s=>[...s].map(c=>(q+=c).repeat(5*++i),i=q=`
`)

Versuch es

f = s=>[...s].map(c=>(q+=c).repeat(5*++i),i=q=`
`);

console.log( f("hello").join`` );

Mögliche Strategie:

Es hat mir nicht viel geholfen, aber vielleicht kann jemand das benutzen:

Die Anzahl der Zeichen in der (0-indizierten) Zeile iist floor(sqrt(2/5*i+1/4)+1/2), die in JavaScript als golfen wird(.4*i+.25)**.5+.5|0 .

Für eine Reihe von Längen ngibt es n*(n+1)*5/2Linien.

Vielleicht: s=>{for(i=0;(n=(.4*i+++.25)**.5+.5|0)<=s.length;)console.log(s.slice(0,n))}

Python 3 , 43 41 Bytes

Vielen Dank an ovs für das Speichern von 2 Bytes!

Code

f=lambda x:[*x]and f(x[:-1])+[x]*5*len(x)

Probieren Sie es online!

C (gcc) , 67 Bytes

i,j;f(char*s){for(i=0;s[i++];)for(j=5*i;j--;)printf("%.*s\n",i,s);}

Probieren Sie es online!

Schale , 8 Bytes

ΣzoR*5Nḣ

Probieren Sie es online!

Erläuterung

Σz(R*5)Nḣ  -- example input: "ab"
        ḣ  -- non-empty prefixes: ["a","ab"]
 z(   )N   -- zip with [1..]
    *5     -- | multiply by 5
   R       -- | replicate
           -- : [["a","a","a","a","a"],["ab","ab","ab","ab","ab","ab","ab","ab","ab","ab"]]
Σ          -- concat: ["a","a","a","a","a","ab","ab","ab","ab","ab","ab","ab","ab","ab","ab"]

Haskell, 46 43 42 Bytes

f s=do n<-[1..length s];take n s<$[1..n*5]

Probieren Sie es online!

Benötigt initsleider import Data.Listso

import Data.List
((<$)<*>(>>[1..5])=<<).inits

mit seinen 45 bytes ist es länger.

Edit: -1 Byte dank @BWO.

Holzkohle , 11 Bytes

Ｆ⊕ＬθＥ×⁵ι…θι

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Die Ausgabe enthält 0 Wiederholungen der Teilzeichenfolge mit der Länge Null. Erläuterung:

   θ          Input string
  Ｌ           Length
 ⊕            Incremented
Ｆ             Loop over implicit range
      ⁵       Literal 5
       ι      Current index
     ×        Multiply
    Ｅ         Map over implicit range
         θ    Input string
          ι   Current index
        …     Chop to length
              Implicitly print each string on its own line

Ruby , 46 42 Bytes

->s{(1..s.size).map{|i|puts [s[0,i]]*i*5}}

Probieren Sie es online!

MATL , 12 Bytes

f"G@:)@5*1X"

Probieren Sie es online!

f               % Get the indices of input i.e. range 1 to length(input)
 "              % For loop over that
   G            % Push input string
    @           % Push current loop index
     :          % Range 1 to that
      )         % Index at those positions (substring 1 to i)
       @5*      % Multiply loop index by 5
          1X"   % Repeat the substring that many times rowwise
                % Results collect on the stack and are 
                %  implicitly output at the end

V , 17 Bytes

òïç$îî/6Ä
Hl$xòxú

Erwartet Eingaben ohne Zeilenumbrüche und Ausgaben mit überflüssigen führenden Zeilenumbrüchen.

Ich kann diesen Eintrag entfernen, wenn die Eingabe / Ausgabe die Herausforderungsspezifikation verletzt.

Probieren Sie es online!

21 Bytes

òïç$îî/6Ä
Hl$xòxíîî/ò

Erwartet Eingaben ohne Zeilenumbrüche, aber Ausgaben mit nur einer führenden und nachfolgenden Zeile.

Erläuterung

Unterschiedliche Teilzeichenfolgen werden durch zwei aufeinanderfolgende Zeilenumbrüche getrennt, sodass die zeilenweise Duplizierung nur für Zeilen gilt, die mit dem regulären Ausdruck übereinstimmen $\n\n.

Wenn der Befehl duplication ( Ä) eine Zählung liefert, zB 6Ä(glaube ich), löscht er die aktuelle Zeile vor dem Einfügen von nZeiten und erscheint somit nur zum Anhängen von n - 1Kopien.

ò         | recursively...
 ï        | . append newline
  ç       | . globally search lines matching...
   $îî    | . . compressed version of $\n\n regex
      /6Ä | . . duplicate to create 6 copies
H         | . go to first line
 l        | . move cursor right 1 char
          | . . if current line is 1 char long, errors out of recursion
  $x      | . delete 1 char from end of current line
    ò     | ...end
     x    | delete extra 1-char substring
      ú   | sort so that newlines rise to top

Perl 5 , 29 Bytes

map{say}($x.=$_)x($y+=5)for@F

Probieren Sie es online!

Perl 6 , 25 Bytes

{(1..*X*5)RZxx[\~] .comb}

Probieren Sie es online!

Anonymer Codeblock, der eine Liste mit Zeichenfolgen zurückgibt.

Wenn Sie es als 1D-Array haben möchten, können Sie es wie folgt voranstellen flat:

{flat (1..*X*5)RZxx[\~] .comb}

Probieren Sie es online!

Erläuterung:

{                       }  # Anonymous code block
                   .comb   # Split the string into a list of characters
              [\~]         # Triangular reduce the list of characters with the concatenate operator
          RZxx             # Multiply each list by:
 (1..*X*5)                 # A sequence of 5,10,15 etc.

Alternative,

{($+=5)xx*RZxx[\~] .comb}

Probieren Sie es online!

Funktioniert auch für die gleiche Anzahl von Bytes.

Japt, 10 Bytes

Warten auf Bestätigung, ob das Ausgabeformat akzeptabel ist (+2 Byte, wenn nicht).

å+ £T±5 ÇX

Versuch es

Japt , 15 12 Bytes

-3 Bytes von @Shaggy

£¯°Y +R pY*5

Probieren Sie es online!

JavaScript, 76 Bytes

s=>{for(i=1;i<=s.length;i++)for(j=0;j<5*i;j++)console.log(s.substring(0,i))}

f=s=>{for(i=1;i<=s.length;i++)for(j=0;j<5*i;j++)console.log(s.substring(0,i))}

f("cat")

Viertens (viertens) , 48 Bytes

: f 1+ 1 do i 5 * 0 do dup j type cr loop loop ;

Probieren Sie es online!

Erläuterung

1. Schleife von 1 bis String-Länge
2. für jede Iteration:
   1. Schleifenzeiten (5 * Schleifenindex)
   2. Zeichenfolge vom Anfang bis zum äußeren Schleifenindex drucken

Code-Erklärung

: f                \ start a new word definiton
  1+ 1             \ set up to the loop paramers from 1 to str-length
  do               \ start a counted loop
    i 5 * 0 do     \ start a second counted loop from 0 to 5*index - 1
      dup j        \ duplicate the string address and set the length to the outer index
      type         \ print character from start of string to loop index
      cr           \ output a newline
    loop           \ end inner counted loop
  loop             \ end outer counted loop
;                  \ end word definition

Java 10, 120 92 90 89 Bytes

s->{for(int j=1,i=1;i<=s.length();i+=++j>i*5?j=1:0)System.out.println(s.substring(0,i));}

-28 Bytes dank @ OlivierGrégoire .
-1 Byte dank @ceilingcat .

Probieren Sie es online aus.

Erläuterung:

s->{                      // Method with String parameter and no return-type
  for(int j=1,            //  Repeat-integer, starting at 1
      i=1;i<=s.length()   //  Loop `i` in the range [1,length_input]
      ;                   //    After every iteration:
       i+=++j>i*5?        //     Increase `j` by 1 first with `++j`
                          //     If `j` is now larger than `i` multiplied by 5:
           j=1            //      Increase `i` by 1, and reset `j` to 1
          :               //     Else:
           0)             //      Leave `i` the same by increasing it with 0
    System.out.println(   //   Print with trailing newline:
      s.substring(0,i));} //    The prefix of size `i`

PowerShell , 40 bis 20 Byte

^{Score halbiert dank mazzy}

$args|%{,($s+=$_)*5}

Probieren Sie es online!

Übernimmt die Eingabe per Splatting. Erstellen Sie die Zeichenfolge, indem Sie das nächste Zeichen zu sich selbst hinzufügen, es in ein Array mit einem Element konvertieren und es dann fünfmal wiederholen.

Python 3 , 55 Bytes

lambda a:[a[:i]for i in range(len(a)+1)for j in' '*5*i]

Probieren Sie es online!

Sauber , 47 Bytes

import StdEnv
$s=[repeatn(5*i)c\\c<-s&i<-[1..]]

Probieren Sie es online!

Gelee , 9 Bytes

WẋL×5ƊƊƤẎ

Probieren Sie es online!

-2 Bytes dank Mr. Xcoder