Pirâmide de cordas quebradas

10

Dada uma sequência n, crie uma pirâmide da sequência dividida em partes em relação à linha atual.

A primeira linha contém a sequência não modificada.

A segunda linha contém a cadeia separada em metades por um tubo.

A terceira linha separa por terços ...

E assim por diante. O comprimento de cada substring, em que l é o comprimento da string n é igual a

piso (l / n)

Os caracteres restantes são colocados em sua própria substring. A última linha usada é a primeira em que as substrings têm 2 de comprimento.

Casos de teste:

Entrada: Olá, mundo.

Resultado:

Hello, world.

Hello,| world|.

Hell|o, w|orld|.

Hel|lo,| wo|rld|.

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

Entrada: abcdefghij

Resultado: 

abcdefghij

abcde|fghij

abc|def|ghi|j

ab|cd|ef|gh|ij

Entrada: 01234567890abcdef

Resultado: 

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

Regras extras:

  • Você pode escrever um programa ou uma função completa, o que usar menos código.

  • A entrada sempre terá pelo menos 4 caracteres.

  • Você DEVE usar quebras de linha se o seu idioma as suportar. Se não for possível, substitua as quebras de linha por:

  • A entrada será sempre ASCII imprimível.

  • Menos 100% se o seu programa resolver P vs. NP.

Entre os melhores:

Mostrar snippet de código

code-golf string Julian Lachniet
fonte
0 bytes:return: false
Gabriel Benamy
3
Bom primeiro desafio! Algumas perguntas de esclarecimento - a entrada é apenas ASCII imprimível (eu sugiro fortemente "sim")? O que significa "quebras de linha são necessárias quando possível"?
AdmBorkBork
3
É uma piada. P vs NP é um problema não resolvido na computação. A piada é que, se você puder resolvê-lo, deixarei de me preocupar com o fato de o seu programa não resolver o desafio.
Julian Lachniet
3
O problema não resolvido real na computação é "tabs ou espaços" ...
FlipTack
3
Não, o verdadeiro problema é o Internet Explorer.
Julian Lachniet

Respostas:

0

JavaScript (ES6), 103 101 91 84 bytes

Corrigido para respeitar os requisitos de desafio

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

Lambda fque recebe a string de entrada como primeiro parâmetro se imprime recursivamente para consolar a string de divisão. Bem simples: contanto que o comprimento da substring,, pesteja acima de 1, imprima a string dividida por um '|' todos os pcaracteres, em seguida, acrescente o seguinte nível. Este, em seguida, chama a função novamente com o pque está sendo t / npavimentado, onde té o comprimento da corda original e nser um divisor incrementado.

XavCo7
fonte
Não acho que dividir npor 2 cada vez seja correto.
Neil
@ Neil você está correto, erro da minha parte. Corrigi o problema e salvei 2 bytes no processo.
XavCo7
@ETHproductions Pensei nisso, mas não sei se isso contaria como STDOUT ... Acho que precisaria fazer alert(f(s))logo depois, certo?
XavCo7
4

Perl, 46 + 1 = 47 bytes

Corra com a -nbandeira

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

Experimente online!

Repartição do código

-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
Isso não parece funcionar para entradas mais longas.
Neil
2

Pitão, 16 bytes

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

tente aqui

Cajado
fonte
11
Isso pode funcionar para os casos de teste, mas não acho que funcione para entradas mais longas.
Neil
2

C, 145 131 128 125 bytes

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);}

Esta é uma função que recebe uma string como argumento e imprime a saída em 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);}
Maçaneta da porta
fonte
Como isso funciona uma vez i*i>l? Parece que ele começará a repetir seções.
Neil
@ Neil Eu não tenho certeza do que você quer dizer. Você poderia dar um exemplo?
Maçaneta
@ Neil Ah, não importa, eu vejo o que você está dizendo. Isso parece ser um buraco na especificação, que afirma explicitamente que o comprimento de cada substring é floor(l/n); Não sei ao certo qual é o comportamento pretendido para entradas mais longas ou se o OP antecipou isso.
Maçaneta
1

Pitão, 17 bytes

jmj\|cQ/lQdSh/lQ3

Explicação

     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

fonte
1

Javascript, 98 bytes

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

Função x(a). Ligue usando

console.log(x("ABCDEF"))

Julian Lachniet
fonte
0

Ruby 60 + 1 = 61 bytes

+1 byte para -nsinalizador.

z= ~/$/
(z/3+1).times{|n|puts $_.scan(/.{1,#{z/(n+1)}}/)*?|}

Veja no Ideone: http://ideone.com/RtoReG

Jordânia
fonte
0

Python 3, 123 bytes

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

Em seqüências mais longas, algumas partes serão repetidas, como é a fórmula para o comprimento da substring floor(l/n). Por exemplo, com uma string de 13 caracteres, a string dividida em 5 seria igual à string dividida em 6's como floor(13/5)==floor(13/6). Não tenho certeza se o OP esperava isso ou se foi uma supervisão.

Cormac
fonte