Pyramide gebrochener Saiten

10

Erstellen Sie mit einer Zeichenfolge n eine Pyramide der Zeichenfolge, die relativ zur aktuellen Zeile in Teile geteilt ist.

Die erste Zeile enthält die Zeichenfolge unverändert.

Die zweite Zeile enthält die Zeichenfolge, die durch ein Rohr in zwei Hälften getrennt ist.

Die dritte Reihe trennt es durch Drittel ...

Und so weiter. Die Länge jedes Teilstrings, wobei l die Länge des Strings n ist, ist gleich

Boden (l / n)

Übrig gebliebene Zeichen werden in ihre eigene Teilzeichenfolge eingefügt. Die letzte verwendete Zeile ist die erste, in der Teilzeichenfolgen 2 lang sind.

Testfälle:

Eingabe: Hallo Welt.

Ausgabe:

Hello, world.

Hello,| world|.

Hell|o, w|orld|.

Hel|lo,| wo|rld|.

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

Eingabe: abcdefghij

Ausgabe: 

abcdefghij

abcde|fghij

abc|def|ghi|j

ab|cd|ef|gh|ij

Eingabe: 01234567890abcdef

Ausgabe: 

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

Zusätzliche Regeln:

  • Sie können ein vollständiges Programm oder eine Funktion schreiben, je nachdem, welcher Code weniger verwendet.

  • Die Eingabe ist immer mindestens 4 Zeichen lang.

  • Sie MÜSSEN Zeilenumbrüche verwenden, wenn Ihre Sprache diese unterstützt. Wenn nicht möglich, ersetzen Sie Zeilenumbrüche durch:

  • Die Eingabe ist immer ASCII-druckbar.

  • Minus 100%, wenn Ihr Programm P vs. NP löst.

Bestenliste:

Code-Snippet anzeigen

code-golf string Julian Lachniet
quelle
0 Bytes:return: false
Gabriel Benamy
3
Schöne erste Herausforderung! Ein paar Fragen zur Klärung - ist die Eingabe nur druckbares ASCII (ich empfehle dringend "Ja")? Was bedeutet "Zeilenumbrüche sind nach Möglichkeit erforderlich"?
AdmBorkBork
3
Es ist ein Witz. P vs NP ist ein ungelöstes Problem beim Rechnen. Der Witz ist, wenn Sie es lösen können, werde ich aufhören, mich um die Tatsache zu kümmern, dass Ihr Programm die Herausforderung nicht löst.
Julian Lachniet
3
Das eigentliche ungelöste Problem beim Rechnen sind "Tabulatoren oder Leerzeichen" ...
FlipTack
3
Nein, das eigentliche Problem ist der Internet Explorer.
Julian Lachniet

Antworten:

0

JavaScript (ES6), 103 101 91 84 Byte

Behoben, um die Herausforderungsanforderungen zu respektieren

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

Lambda f, das die Eingabezeichenfolge als ersten Parameter verwendet sund rekursiv druckt, um die geteilte Zeichenfolge zu trösten. Ziemlich einfach: Solange die Teilzeichenfolgenlänge püber 1 liegt, drucken Sie die durch ein '|' geteilte Zeichenfolge. Fahren Sie pdann mit dem Anhängen der folgenden Ebene fort. Dies ruft die Funktion dann erneut auf, pindem sie t / nbodenständig ist, wobei tdie ursprüngliche Zeichenfolgenlänge ist und nein inkrementierter Teiler ist.

XavCo7
quelle
Ich denke nicht, dass nes richtig ist, jedes Mal durch 2 zu teilen .
Neil
@Neil du bist richtig, Fehler meinerseits. Ich habe das Problem behoben und dabei 2 Bytes gespeichert.
XavCo7
@ETHproductions Ich habe darüber nachgedacht, aber ich weiß nicht, ob das als STDOUT gelten würde ... Ich denke, ich müsste es alert(f(s))gleich danach tun, oder?
XavCo7
4

Perl, 46 + 1 = 47 Bytes

Lauf mit der -nFlagge

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

Probieren Sie es online aus!

Code-Aufschlüsselung

-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
quelle
Dies scheint bei längeren Eingaben nicht zu funktionieren.
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

Versuch es hier

Stange
quelle
1
Dies könnte für die Testfälle funktionieren, aber ich denke nicht, dass es für längere Eingaben funktioniert.
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);}

Dies ist eine Funktion, die eine Zeichenfolge als Argument verwendet und die Ausgabe an STDOUT druckt.

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);}
Türknauf
quelle
Wie funktioniert das einmal i*i>l? Es sieht so aus, als würde es beginnen, Abschnitte zu wiederholen.
Neil
@Neil Ich bin nicht sicher, was du meinst. Könnten Sie ein Beispiel geben?
Türknauf
@Neil Ah, egal, ich verstehe was du sagst. Dies scheint ein Loch in der Spezifikation zu sein, in dem ausdrücklich angegeben ist, dass die Länge jedes Teilstrings gleich ist floor(l/n). Ich bin mir nicht sicher, was das beabsichtigte Verhalten für längere Eingaben ist oder ob das OP dies erwartet hat.
Türknauf
1

Pyth, 17 Bytes

jmj\|cQ/lQdSh/lQ3

Erläuterung

     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

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

Funktion x(a). Rufen Sie mit an

console.log(x("ABCDEF"))

Julian Lachniet
quelle
0

Ruby 60 + 1 = 61 Bytes

+1 Byte für -nFlag.

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

Sehen Sie es auf Ideone: http://ideone.com/RtoReG

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

Bei längeren Saiten werden einige Teile wiederholt, da die Formel für die Länge des Teilstrings lautet floor(l/n). Beispiel: Bei einer Zeichenfolge mit einer Länge von 13 Zeichen entspricht die in 5 aufgeteilte Zeichenfolge der Zeichenfolge, die in 6 Zeichen aufgeteilt ist floor(13/5)==floor(13/6). Ich bin mir nicht sicher, ob das OP dies erwartet hat oder ob es ein Versehen war.

Cormac
quelle