Data una stringa di testo, lo emette come una "torre".

Ogni sezione della stringa (del modulo 0:n) viene ripetuta5*n volte, quindi il primo carattere viene ripetuto 5 volte, quindi la prima e la seconda 10 volte, ecc.

Esempi:

'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']

Regole:

Puoi generare ogni livello come un elenco di caratteri o solo una stringa di essi uniti.

code-golf string number

— Whalalalalalala CHen
fonte

benvenuto in PPCG! Bella sfida.

— Giuseppe,

Ho provato a ripulire la formattazione e spiegare meglio la sfida. Ho capito bene la sfida?

— Rɪᴋᴇʀ

2

Possiamo prendere l'input come un elenco di caratteri?

— JayCe,

5

Possiamo produrre una matrice 2D di stringhe in questo modo [["c","c","c","c","c"],["ca","ca","ca","ca","ca","ca","ca","ca","ca","ca"],...]:?

— Shaggy,

3

Sono accettabili output con newline iniziali o finali? Possiamo supporre che gli input non contengano newline?

— ridondanza il

12

R , 48 byte

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

Provalo online!

Restituisce un elenco di stringhe.

— Giuseppe
fonte

Avevo perso l'ovvio golf qui! bella soluzione Ho provato approcci diversi ma finora tutti sono molto più lunghi di così.

— JayCe,

8

05AB1E , 6 byte

ηā5*ÅΓ

Provalo online!

Restituisce un elenco di stringhe.

Spiegazione

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

— Kaldo
fonte

@KevinCruijssen Grazie per averlo notato! Prima non dovrei giocare a golf senza un caffè :-(

— Kaldo

1

L'uso della decodifica della lunghezza della corsa consente di risparmiare 3 byte:ηā5*ÅΓ

— Adnan,

@Adnan Brilliant, grazie! Penso che meriti la sua risposta, hai ridotto il conteggio dei byte del 33% ... Tornerò alla mia soluzione originale se decidi di pubblicarlo da solo.

— Kaldo

Bello, l'ho avuto ηvyg5*Fy=per 8.

— Magic Octopus Urn il

7

Haskell , 36 byte

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

Provalo online!

— XNOR
fonte

6

Stax , 8 byte

äï▄;♫├W^

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

|[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

Esegui questo

— ricorsivo
fonte

6

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

Spiegazione:

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

— pizzapants184
fonte

6

Retina , 15 byte

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

Provalo online! Il link include casi di test. Spiegazione:

Abbina ogni carattere nella stringa.

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

$`è il prefisso della partita. Retina fornisce quindi due modificatori, lo >modifica per essere nel contesto della stringa tra corrispondenze successive, mentre .prende la lunghezza. Iniziamo quindi con il prefisso del suffisso, che è equivalente alla corrispondenza incluso il suo prefisso. Ciò consente di risparmiare 2 byte utilizzando corrispondenze sovrapposte. Le $(concatena quindi che con una nuova riga, le 5*ripetizioni e quindi le $.>`ripete un ulteriore numero di tempi indicati dalla sua lunghezza.

— Neil
fonte

6

Tela , 6 byte

［³５×＊Ｐ

Provalo qui!

Spiegazione:

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

— dzaima
fonte

6

Brachylog , 15 byte

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

Provalo online!

Il finale cpuò essere rimosso se OP risponde positivamente alla domanda sull'output di array 2D.

— Sundar - Ripristina Monica
fonte

6

Cubix , 44 40 byte

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

Provalo online!

Questo ha ancora molte no-op, ma è un po 'meglio di prima.

Come descrizione molto breve, un personaggio viene catturato dall'input e testato per EOI (-1), fermandosi se lo è. Lo stack viene quindi invertito. Ottieni il numero di oggetti in pila e multipli di -5. Rilascialo sul fondo della pila e pulisci. Passa attraverso la pila, stampando, fino a un numero negativo. Stampa newline, incrementa il numero, se 0 rilascia lo zero, inverti la pila e ricomincia da input, altrimenti passa in rassegna la pila, stampa, fino a un numero negativo ... fino alla nausea

Sembra cubificato

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

Guardalo online

— MickyT
fonte

5

Gelatina , 8 byte

¹Ƥx'J×5Ɗ

Provalo online!

J×5x'@¹Ƥ

Provalo online!

¹Ƥx'Jx'5

Provalo online!

Questo è probabilmente golfabile.

— Mr. Xcoder
fonte

Un 8 leggermente diverso è+\ẋ"Jx5Ẏ

— Jonathan Allan,

5

JavaScript, 48 46 byte

(grazie @redundancy)

Modifica: l'autore ha chiarito e questa risposta ora non è valida, ma la lascerò qui invariata.

Restituisce una matrice di stringhe multilinea.

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

Provalo

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

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

Espandi frammento

Potenziale strategia:

Non mi è stato di grande aiuto, ma forse qualcuno può usare questo:

Il numero di caratteri sulla riga (0-indicizzata) iè floor(sqrt(2/5*i+1/4)+1/2), che è giocato a golf in JavaScript come (.4*i+.25)**.5+.5|0.

Per una stringa di lunghezza n, ci sono n*(n+1)*5/2linee.

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

— Matth
fonte

1

Supponendo che il tuo formato di output sia valido in base alla sfida, puoi salvare 2 byte come dimostrato qui: provalo online!

— ridondanza il

4

Python 3 , 43 41 byte

Grazie a ovs per aver salvato 2 byte!

Codice

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

Provalo online!

— Adnan
fonte

3

C (gcc) , 67 byte

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

Provalo online!

— ErikF
fonte

3

Buccia , 8 byte

ΣzoR*5Nḣ

Provalo online!

Spiegazione

Σ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"]

— ბიმო
fonte

3

Haskell, 46 43 42 byte

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

Provalo online!

Purtroppo initsrichiede import Data.List, quindi

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

con i suoi 45 byte è più lungo.

Modifica: -1 byte grazie a @BWO.

— Nome del modello
fonte

3

Carbone , 11 byte

Ｆ⊕ＬθＥ×⁵ι…θι

Provalo online! Il collegamento è alla versione dettagliata del codice. L'output include 0 ripetizioni della sottostringa di lunghezza zero. Spiegazione:

   θ          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

— Neil
fonte

3

Rubino , 46 42 byte

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

Provalo online!

— Ripristina Monica - notmaynard
fonte

3

PowerShell , 40 20 25 byte

^{Punteggio tagliato a metà grazie a}
^{+5 byte sontuosi grazie ad AdmBorkBork che indica le specifiche}

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

Provalo online!

Accetta input tramite splatting. Funziona costruendo la stringa aggiungendo il carattere successivo a se stesso, lo converte in un array di un elemento e quindi lo ripete 5*ivolte.

— Veskah
fonte

1

paramè molto costoso. Cerca di evitarlo

— mazzy il

@mazzy Dang, cercare di salvare l'indice invece del carattere stesso mi ha portato fuori strada. Grazie.

— Veskah

@AdmBorkBork Ah ah, whoops. Dovrebbe essere risolto ora

— Veskah il

2

MATL , 12 byte

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

Provalo 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

— Sundar - Ripristina Monica
fonte

2

V , 17 byte

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

Prevede input senza newline e output con newline leader superflue.

Posso rimuovere questa voce se l'input / output viola le specifiche della sfida.

Provalo online!

21 byte

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

Prevede input senza newline, ma output con un solo newline iniziale e finale.

Spiegazione

Le sottostringhe diverse sono separate con due newline consecutive in modo tale che la duplicazione a livello di linea si applichi solo alle linee corrispondenti alla regex $\n\n .

Quando al comando di duplicazione ( Ä) viene fornito un conteggio, ad esempio 6Ä(penso), elimina la riga corrente prima di incollare i ntempi, quindi appare solo per aggiungere n - 1copie.

ò         | 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

— ridondanza
fonte

1

Perl 5 , 29 byte

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

Provalo online!

— Dom Hastings
fonte

1

Perl 6 , 25 byte

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

Provalo online!

Blocco di codice anonimo che restituisce un elenco di elenco di stringhe.

Se lo vuoi come un array 1D, puoi aggiungere flatin questo modo:

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

Provalo online!

Spiegazione:

{                       }  # 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.

In alternativa,

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

Provalo online!

Funziona anche con la stessa quantità di byte.

— Jo King
fonte

1

Japt, 10 byte

In attesa di conferma sull'accettabilità del formato di output (+2 byte in caso contrario).

å+ £T±5 ÇX

Provalo

— ispido
fonte

L'output mi sembra ragionevole, ben fatto.

— Nit

1

Japt , 15 12 byte

-3 byte da @Shaggy

£¯°Y +R pY*5

Provalo online!

— Luis Felipe De Jesus Munoz
fonte

12 byte (inclusa una piccola correzione)

— Shaggy

1

JavaScript, 76 byte

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")

Espandi frammento

— Medude
fonte

Ciao e benvenuto in PPCG.

— Jonathan Frech,

i=1;i<=s.length;i++può essere i=0;++i<=s.length;.

— Jonathan Frech,

1

Forth (gforth) , 48 byte

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

Provalo online!

Spiegazione

Passa da 1 a lunghezza stringa
per ogni iterazione:
1. Tempi di loop (indice 5 * loop)
2. Stampa la stringa dall'inizio all'indice del ciclo esterno

Spiegazione del codice

: 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

— reffu
fonte

1

Java 10, 120 92 90 89 byte

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 byte grazie a @ OlivierGrégoire .
-1 byte grazie a @ceilingcat .

Provalo online.

Spiegazione:

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`

— Kevin Cruijssen
fonte

1

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

— Olivier Grégoire,

@ OlivierGrégoire Grazie! E sono stato in grado di giocare a golf 2 byte in più cambiando usando >=e ?j=1:0invece di <e ?0:+(j=1).

— Kevin Cruijssen,

Buona! Stavo cercando di liberarmene, ma continuavo ad avere problemi di compilazione. Non ho pensato di ripristinare la condizione. Molto bene! ;)

— Olivier Grégoire il

@ceilingcat Grazie

— Kevin Cruijssen il

1

Brainfuck , 40 byte

++++++++++>,[>>+++++[<<[<]>[.>]>>+<-]<,]

Provalo online!

[Tape: 10 (newline), [characters], 0, rowcounter]

++++++++++> 10 (newline)
,[          for each input character
  >>+++++     add 5 to number of rows
  [           for each row
    <<[<]       go to start
    >[.>]       print newline and all previous characters
    >>+         add 1 to next rowcounter cell
    <-          decrement current rowcounter cell
  ]
  <,          input next character
]

— Dorian
fonte

1

APL (Dyalog Unicode) , ^{SBCS da} 14 byte

{↑(5×⍳≢⍵)/,\⍵}

Provalo online!

Il mio primo post apl quindi per favore fatemi sapere se avete suggerimenti

Come funziona:

{↑(5×⍳≢⍵)/,\⍵}
          ,\⍵  - Prefixes of the input
         /      - Repeated
     ⍳≢⍵        - By a list of indices the same length as the input
   5×           - Times 5
 ↑              - Separate into rows

— Franco
fonte

↑non è realmente separato in righe ma piuttosto Combina [elenco di elenchi] in righe [di una matrice] , o più tecnicamente Aumenta il rango a spese della profondità .

— Adám

1

Rubino , 37 byte

f=->s{s[0]?f[s.chop]+[s]*s.size*5:[]}

Provalo online!

— GB
fonte

Torre di archi

Esempi:

Regole:

R , 48 byte

05AB1E , 6 byte

Haskell , 36 byte

Stax , 8 byte

TI-Basic (TI-84 Plus CE), 29 byte (27 token)

Retina , 15 byte

Tela , 6 byte

Brachylog , 15 byte

Cubix , 44 40 byte

Gelatina , 8 byte

JavaScript, 48 46 byte

Provalo

Potenziale strategia:

Python 3 , 43 41 byte

Codice

C (gcc) , 67 byte

Buccia , 8 byte

Spiegazione

Haskell, 46 43 42 byte

Carbone , 11 byte

Rubino , 46 42 byte

PowerShell , 40 20 25 byte

MATL , 12 byte

V , 17 byte

21 byte

Spiegazione

Perl 5 , 29 byte

Perl 6 , 25 byte

Spiegazione:

Japt, 10 byte

Japt , 15 12 byte

JavaScript, 76 byte

Forth (gforth) , 48 byte

Spiegazione

Spiegazione del codice

Java 10, 120 92 90 89 byte

Brainfuck , 40 byte

APL (Dyalog Unicode) , SBCS da 14 byte

Come funziona:

Rubino , 37 byte

APL (Dyalog Unicode) , ^{SBCS da} 14 byte