Pirámide de cuerdas rotas

10

Dada una cadena n, cree una pirámide de la cadena dividida en piezas en relación con la fila actual.

La primera fila contiene la cadena sin modificar.

La segunda fila contiene la cadena separada en mitades por una tubería.

La tercera fila lo separa en tercios ...

Y así. La longitud de cada subcadena, donde l es la longitud de la cadena n es igual a

piso (l / n)

Los personajes sobrantes se colocan en su propia subcadena. La última fila utilizada es la primera donde las subcadenas tienen 2 de longitud.

Casos de prueba:

Entrada: Hola, mundo.

Salida:

Hello, world.

Hello,| world|.

Hell|o, w|orld|.

Hel|lo,| wo|rld|.

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

Entrada: abcdefghij

Salida: 

abcdefghij

abcde|fghij

abc|def|ghi|j

ab|cd|ef|gh|ij

Entrada: 01234567890abcdef

Salida: 

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

Reglas extra:

  • Puede escribir un programa completo o una función, lo que use menos código.

  • La entrada siempre tendrá al menos 4 caracteres de longitud.

  • DEBE usar saltos de línea si su idioma los admite. Si no es posible, reemplace los saltos de línea con:

  • La entrada siempre será ASCII imprimible.

  • Menos del 100% si su programa resuelve P vs. NP.

Tabla de clasificación:

Mostrar fragmento de código

code-golf string Julian Lachniet
fuente
0 bytes:return: false
Gabriel Benamy
3
¡Buen primer desafío! Algunas preguntas de aclaración: ¿la entrada es solo ASCII imprimible (sugiero fuertemente "sí")? ¿Qué significa "saltos de línea necesarios cuando sea posible"?
AdmBorkBork
3
Es una broma. P vs NP es un problema no resuelto en informática. La broma es que si puedes resolverlo, dejaré de preocuparme por el hecho de que tu programa no resuelva el desafío.
Julian Lachniet
3
El verdadero problema no resuelto en informática es "pestañas o espacios" ...
FlipTack
3
No, el verdadero problema es Internet Explorer.
Julian Lachniet

Respuestas:

0

JavaScript (ES6), 103 101 91 84 bytes

Se corrigió para respetar los requisitos de desafío

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

Lambda fque toma la cadena de entrada como primer parámetro se imprime recursivamente para consolar la cadena dividida. Bastante sencillo: siempre que la longitud de la subcadena psea ​​superior a 1, imprima la cadena dividida por un '|' cada ppersonaje, luego proceda con la adición del siguiente nivel. Esto luego llama a la función nuevamente con pun t / npiso, donde testá la longitud de la cadena original y nes un divisor incrementado.

XavCo7
fuente
No creo que dividir nentre 2 cada vez sea correcto.
Neil
@Neil tienes razón, error de mi parte. Solucioné el problema y guardé 2 bytes en el proceso.
XavCo7
@ETHproductions Pensé en eso, pero no sé si eso contaría como STDOUT ... Supongo que tendría que hacerlo alert(f(s))justo después, ¿verdad?
XavCo7
4

Perl, 46 + 1 = 47 bytes

Corre con la -nbandera

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

Pruébalo en línea!

Desglose de 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
fuente
Esto no parece funcionar para entradas más largas.
Neil
2

Pyth, 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

Intenta aquí

varilla
fuente
1
Esto podría funcionar para los casos de prueba, pero no creo que funcione para entradas más largas.
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 es una función que toma una cadena como argumento e imprime la salida en 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);}
Pomo de la puerta
fuente
¿Cómo funciona esto una vez i*i>l? Parece que comenzará a repetir secciones.
Neil
@Neil, no estoy seguro de lo que quieres decir. ¿Podrías dar un ejemplo?
Pomo de la puerta
@Neil Ah, no importa, veo lo que estás diciendo. Eso parece ser un agujero en la especificación, que establece explícitamente que la longitud de cada subcadena es floor(l/n); No estoy seguro de cuál es el comportamiento previsto para entradas más largas o si el OP lo anticipó.
Pomo de la puerta
1

Pyth, 17 bytes

jmj\|cQ/lQdSh/lQ3

Explicación

     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

fuente
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++}

Función x(a). Llamar usando

console.log(x("ABCDEF"))

Julian Lachniet
fuente
0

Ruby 60 + 1 = 61 bytes

+1 byte para -nbandera.

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

Véalo en Ideone: http://ideone.com/RtoReG

Jordán
fuente
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')

En cadenas más largas, se repetirán algunas partes, como lo es la fórmula para la longitud de la subcadena floor(l/n). Por ejemplo, con una cadena de 13 caracteres de longitud, la cadena dividida en 5 sería la misma que la cadena dividida en 6 como floor(13/5)==floor(13/6). No estoy seguro de si el OP esperaba esto o si fue un descuido.

Cormac
fuente