Pyramide de cordes cassées

10

Étant donné une chaîne n, créez une pyramide de la chaîne divisée en morceaux par rapport à la ligne actuelle.

La première ligne contient la chaîne non modifiée.

La deuxième ligne contient la chaîne séparée en deux par un tuyau.

La troisième rangée la sépare par tiers ...

Etc. La longueur de chaque sous-chaîne, où l est la longueur de la chaîne n est égale à

étage (l / n)

Les caractères restants sont placés dans leur propre sous-chaîne. La dernière ligne utilisée est la première où les sous-chaînes ont une longueur de 2.

Cas de test:

Entrée: Bonjour, monde.

Production:

Hello, world.

Hello,| world|.

Hell|o, w|orld|.

Hel|lo,| wo|rld|.

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

Entrée: abcdefghij

Production: 

abcdefghij

abcde|fghij

abc|def|ghi|j

ab|cd|ef|gh|ij

Entrée: 01234567890abcdef

Production: 

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

Règles supplémentaires:

  • Vous pouvez écrire un programme complet ou une fonction, selon celle qui utilise le moins de code.

  • L'entrée comportera toujours au moins 4 caractères.

  • Vous DEVEZ utiliser des sauts de ligne si votre langue les prend en charge. Si ce n'est pas possible, remplacez les sauts de ligne par:

  • L'entrée sera toujours ASCII imprimable.

  • Moins 100% si votre programme résout P vs NP.

Classement:

Afficher l'extrait de code

code-golf string Julian Lachniet
la source
0 octets:return: false
Gabriel Benamy
3
Joli premier défi! Quelques questions de clarification - l'entrée est-elle uniquement imprimable en ASCII (je suggère fortement "oui")? Que signifie «les sauts de ligne sont nécessaires lorsque cela est possible»?
AdmBorkBork
3
C'est une blague. P vs NP est un problème non résolu en informatique. La plaisanterie est que si vous pouvez le résoudre, je cesserai de me soucier du fait que votre programme ne résout pas le défi.
Julian Lachniet
3
Le vrai problème non résolu dans l'informatique est "les tabulations ou les espaces" ...
FlipTack
3
Non, le vrai problème est Internet Explorer.
Julian Lachniet

Réponses:

0

JavaScript (ES6), 103 101 91 84 octets

Correction pour respecter les exigences du défi

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

Lambda fqui prend la chaîne d'entrée comme premier paramètre set imprime récursivement pour consoler la chaîne divisée. Assez simple: tant que la longueur de la sous-chaîne p, est supérieure à 1, imprimez la chaîne divisée par un "|" tous les pcaractères, puis procédez à l'ajout du niveau suivant. Cela appelle alors la fonction d' pêtre t / nterrassé, où test la longueur de chaîne d' origine et nêtre un diviseur incrémentée.

XavCo7
la source
Je ne pense pas que la division npar 2 à chaque fois soit correcte.
Neil
@Neil tu as raison, erreur de ma part. J'ai résolu le problème et enregistré 2 octets dans le processus.
XavCo7
@ETHproductions J'y ai pensé, mais je ne sais pas si cela compterait comme STDOUT ... Je suppose que je devrais le faire alert(f(s))juste après, non?
XavCo7
4

Perl, 46 + 1 = 47 octets

Courez avec le -ndrapeau

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

Essayez-le en ligne!

Répartition du code

-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
la source
Cela ne semble pas fonctionner pour des entrées plus longues.
Neil
2

Pyth, 16 octets

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

essayez ici

Barre
la source
1
Cela pourrait fonctionner pour les cas de test, mais je ne pense pas que cela fonctionne pour des entrées plus longues.
Neil
2

C, 145 131 128 128 125 octets

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

Il s'agit d'une fonction qui prend une chaîne comme argument et imprime la sortie dans 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);}
Poignée de porte
la source
Comment ça marche une fois i*i>l? Il semble que cela va commencer à répéter des sections.
Neil
@Neil Je ne sais pas trop ce que tu veux dire. Pouvez-vous donner un exemple?
Poignée de porte
@Neil Ah, tant pis, je vois ce que tu dis. Cela semble être un trou dans la spécification, qui indique explicitement que la longueur de chaque sous-chaîne est floor(l/n); Je ne sais pas quel est le comportement prévu pour les entrées plus longues ou si l'OP l'avait prévu.
Poignée de porte
1

Pyth, 17 octets

jmj\|cQ/lQdSh/lQ3

Explication

     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

la source
1

Javascript, 98 octets

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

Fonction x(a). Appeler en utilisant

console.log(x("ABCDEF"))

Julian Lachniet
la source
0

Ruby 60 + 1 = 61 octets

+1 octet pour le -ndrapeau.

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

Voir sur Ideone: http://ideone.com/RtoReG

Jordan
la source
0

Python 3, 123 octets

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

Pour les chaînes plus longues, certaines parties seront répétées, comme la formule de la longueur de la sous-chaîne est floor(l/n). Par exemple, avec une chaîne de 13 caractères, la chaîne divisée en 5 serait la même que la chaîne divisée en 6 comme floor(13/5)==floor(13/6). Je ne sais pas si le PO s'y attendait ou s'il s'agissait d'une erreur.

Cormac
la source