Piramide di corde spezzate

10

Data una stringa n, crea una piramide della stringa divisa in pezzi rispetto alla riga corrente.

La prima riga contiene la stringa non modificata.

La seconda riga contiene la stringa separata a metà da una pipe.

La terza riga lo separa per terzi ...

E così via. La lunghezza di ogni sottostringa, dove l è la lunghezza della stringa n è uguale a

piano (l / n)

I personaggi rimasti vengono inseriti nella loro sottostringa. L'ultima riga utilizzata è la prima in cui le sottostringhe sono lunghe 2.

Casi test:

Input: Ciao, mondo.

Produzione:

Hello, world.

Hello,| world|.

Hell|o, w|orld|.

Hel|lo,| wo|rld|.

He|ll|o,| w|or|ld|.

Input: abcdefghij

Produzione: 

abcdefghij

abcde|fghij

abc|def|ghi|j

ab|cd|ef|gh|ij

Ingresso: 01234567890abcdef

Produzione: 

01234567890abcdef

01234567|890abcde|f

01234|56789|0abcd|ef

0123|4567|890a|bcde|f

012|345|678|90a|bcd|ef

01|23|45|67|89|0a|bc|de|f

Regole extra:

  • Puoi scrivere un programma completo o una funzione, a seconda di quale codice utilizzi meno codice.

  • L'input avrà sempre una lunghezza di almeno 4 caratteri.

  • DEVI utilizzare le interruzioni di riga se la tua lingua li supporta. Se non è possibile, sostituire le interruzioni di riga con:

  • L'input sarà sempre ASCII stampabile.

  • Meno 100% se il programma risolve P vs. NP.

Classifica:

Mostra snippet di codice

code-golf  string 
— Julian Lachniet
fonte
0 byte:return: false
— Gabriel Benamy,
3
Bella prima sfida! Alcune domande di chiarimento: l'ingresso è solo ASCII stampabile (consiglio vivamente "sì")? Che cosa significa "interruzioni di riga necessarie quando possibile"?
— AdmBorkBork,
3
È uno scherzo. P vs NP è un problema irrisolto nell'informatica. Lo scherzo è che se riesci a risolverlo, smetterò di preoccuparmi del fatto che il tuo programma non risolva la sfida.
— Julian Lachniet,
3
Il vero problema irrisolto
— nell'informatica
3
No, il vero problema è Internet Explorer.
— Julian Lachniet,

Risposte:

0

JavaScript (ES6), 103 101 91 84 byte

Risolto per rispettare i requisiti della sfida

f=(s,n=0,p=s.length/++n|0)=>p>1?s.match(eval('/.{1,'+p+'}/g')).join`|`+'\n'+f(s,n):''

Lambda fche accetta la stringa di input come primo parametro se stampa ricorsivamente per consolare la stringa divisa. Abbastanza semplice: fintanto che la lunghezza della sottostringa p, è superiore a 1, stampa la stringa divisa per un '|' tutti i ppersonaggi, quindi procedi con l'aggiunta del seguente livello. Questo quindi chiama di nuovo la funzione con pessere t / nfloored, dove si ttrova la lunghezza della stringa originale e nessendo un divisore incrementato.

— XavCo7
fonte
Non penso che dividere nper 2 ogni volta sia corretto.
— Neil,
@Neil hai ragione, errore da parte mia. Ho risolto il problema e salvato 2 byte nel processo.
— XavCo7,
@ETHproductions Ci ho pensato, ma non so se sarebbe contato come STDOUT ... Immagino che dovrei farlo alert(f(s))subito dopo?
— XavCo7,
4

Perl, 46 + 1 = 47 byte

Corri con la -nbandiera

say s/.{$=}(?=.)/$&|/gr while($==y///c/++$,)-2

Provalo online!

Analisi del codice

-n                                              #Reads input into the $_ variable
say s/.{$=}(?=.)/$&|/gr while($==y///c/++$,)-2
                                 y///c          #Transliteration.  Implicitly operates on $_, replacing every character with itself and counting replacements
                                                #y///c effectively returns the length of $_
                                      /++$,     #Increments $, (which starts off at 0) and divides the length of $_ by $,
                              $==               #Stores the result of this division into $=
                                                #$= forces its contents to be an integer, so it truncates any decimal
                             (             )-2  #Returns 0 if $= is equal to 2
                        while                   #Evaluates its RHS as the condition.  If truthy, evaluates its LHS.
    s/          /   /gr                         #Substitution.  Implicitly operates on $_.
                                                #Searches for its first argument and replaces it with its second argument, repeating until it's done, and returns the new string.  $_ is not modified.
      .{$=}                                     #Looks for a string of $= characters...
           (?=.)                                #...that is followed by at least one non-newline character, but does not include this character in the match...
                 $&|                            #...and replaces it with itself followed by a pipe character.
say                                             #Output the result of the substitution.
— Gabriel Benamy
fonte
Questo non sembra funzionare per input più lunghi.
— Neil,
2

Pyth, 16 byte

Vh/lQ3j\|cQ/lQhN

V                # For N in range(1, \/ )
 h/lQ3           # 1+lenght(input)/3
      j\|        # join with '|'
         cQ      # chop input in
           /lQhN # lenght(input)/(N+1) pieces

prova qui

— asta
fonte
1
Questo potrebbe funzionare per i casi di test ma non credo che funzioni per input più lunghi.
— Neil,
2

C, 145 131 128 125 byte

l,n,i=1,j;f(char*s){l=strlen(s);puts(s);do{n=l/++i;for(j=0;j<l;)j&&(j%n||putchar('|')),putchar(s[j++]);puts("");}while(n>2);}

Questa è una funzione che accetta una stringa come argomento e stampa l'output su STDOUT.

l,n,i=1,j;       // declare some variables
f(char*s){       // declare the function
l=strlen(s);     // get the length of the string
puts(s);         // output the initial version, with trailing newline
do{n=l/++i;      // n is the number of characters per "section",
                 //  and we'll do-while n>2 to stop at the right time
for(j=0;j<l;)    // loop through the characters of the string
j&&(             // if j != 0,
j%n||            // and j % n == 0,
putchar('|')),   // insert a | before this character
putchar(s[j++]); // print the character
puts("");        // print a newline after the loop
}while(n>2);}
— Maniglia
fonte
Come funziona una volta i*i>l? Sembra che inizierà a ripetere le sezioni.
— Neil,
@Neil non sono sicuro di cosa intendi. Potresti fare un esempio?
— Maniglia della porta
@Neil Ah, non importa, capisco cosa stai dicendo. Questo sembra essere un buco nella specifica, che afferma esplicitamente che la lunghezza di ogni sottostringa è floor(l/n); Non sono sicuro di quale sia il comportamento previsto per input più lunghi o se l'OP lo ha anticipato.
— Maniglia della porta
1

Pyth, 17 byte

jmj\|cQ/lQdSh/lQ3

Spiegazione

     cQ/lQ         Divide into equal pieces (with the last shorter)
  j\|              Join with pipes
 m        d        Map to each row index...
           Sh/lQ3  ... up to the first row with substrings of length 2
j                  Join with newlines
1

Javascript, 98 byte

a=>{for(b=1;2<=a.length/b;)eval("console.log(a.match(/.{1,"+(a.length/b|0)+"}/g).join('|'))"),b++}

Funzione x(a). Chiama usando

console.log(x("ABCDEF"))

— Julian Lachniet
fonte
0

Python 3, 123 byte

f=lambda s:print(*['|'.join(s[i:i+n]for i in range(0,len(s),n))for n in[len(s)//i for i in range(1,len(s)//2+1)]],sep='\n')

A stringhe più lunghe alcune parti verranno ripetute, come è la formula per la lunghezza della sottostringa floor(l/n). Ad esempio, con una stringa di 13 caratteri, la stringa divisa in 5 sarebbe la stessa della stringa divisa in 6 floor(13/5)==floor(13/6). Non sono sicuro se l'OP si aspettasse questo o se fosse una svista.

— Cormac
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.