Piramida zerwanych strun

10

Biorąc pod uwagę ciąg n, utwórz piramidę ciągu podzieloną na części względem bieżącego wiersza.

Pierwszy wiersz zawiera ciąg niezmodyfikowany.

Drugi rząd zawiera ciąg rozdzielony rurką na połówki.

Trzeci rząd dzieli go na trzecie ...

I tak dalej. Długość każdego podłańcucha, gdzie l jest długością łańcucha n jest równa

podłoga (l / n)

Pozostałe znaki są umieszczane we własnym podciągu. Ostatni użyty wiersz jest pierwszym, w którym podciągi mają długość 2.

Przypadki testowe:

Wkład: Witaj, świecie.

Wynik:

Hello, world.

Hello,| world|.

Hell|o, w|orld|.

Hel|lo,| wo|rld|.

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

Dane wejściowe: abcdefghij

Wynik: 

abcdefghij

abcde|fghij

abc|def|ghi|j

ab|cd|ef|gh|ij

Dane wejściowe: 01234567890abcdef

Wynik: 

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

Dodatkowe zasady:

  • Możesz napisać pełny program lub funkcję, w zależności od tego, który zużywa mniej kodu.

  • Dane wejściowe zawsze będą miały co najmniej 4 znaki.

  • MUSISZ używać podziałów linii, jeśli Twój język je obsługuje. Jeśli nie jest to możliwe, zamień podział linii na:

  • Dane wejściowe zawsze będą drukowane w formacie ASCII.

  • Minus 100%, jeśli twój program rozwiązuje P vs. NP.

Tabela liderów:

Pokaż fragment kodu

code-golf string Julian Lachniet
źródło
0 bajtów:return: false
Gabriel Benamy,
3
Ładne pierwsze wyzwanie! Kilka pytań wyjaśniających - czy dane wejściowe można wydrukować tylko w formacie ASCII (zdecydowanie sugeruję „tak”)? Co oznacza „podziały linii są konieczne, jeśli to możliwe”?
AdmBorkBork,
3
To żart. P vs NP to nierozwiązany problem w informatyce. Żart jest taki, że jeśli potrafisz go rozwiązać, przestanę się przejmować faktem, że twój program nie rozwiązuje problemu.
Julian Lachniet,
3
Prawdziwym nierozwiązanym problemem w informatyce są „tabulatory lub spacje” ...
FlipTack,
3
Nie, prawdziwym problemem jest Internet Explorer.
Julian Lachniet,

Odpowiedzi:

0

JavaScript (ES6), 103 101 91 84 bajtów

Naprawiono przestrzeganie wymagań wyzwania

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

Lambda, fktóra przyjmuje ciąg wejściowy jako pierwszy parametr si rekurencyjnie drukuje, aby konsolować podzielony ciąg. Całkiem proste: tak długo, jak długość podciągu p, jest powyżej 1, wydrukuj ciąg podzielony przez „|” wszystkie ppostacie, a następnie kontynuuj dołączanie następnego poziomu. To z kolei wywołuje funkcję ponownie pjest t / npowalony, gdzie tjest oryginalna długość łańcucha i nbycia inkrementowany dzielnik.

XavCo7
źródło
Nie sądzę, aby dzielenie nprzez 2 za każdym razem było poprawne.
Neil,
@Nie masz racji, pomyłka z mojej strony. Naprawiłem problem i zapisałem 2 bajty.
XavCo7
@ETHproductions Myślałem o tym, ale nie wiem, czy to by się liczyło jako STDOUT ... Chyba muszę to zrobić alert(f(s))zaraz po tym?
XavCo7
4

Perl, 46 + 1 = 47 bajtów

Uruchom z -nflagą

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

Wypróbuj online!

Podział kodu

-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
źródło
Wydaje się, że nie działa to przy dłuższych wejściach.
Neil
2

Pyth, 16 bajtów

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

spróbuj tutaj

Pręt
źródło
1
Może to działać w przypadkach testowych, ale nie sądzę, aby działało w przypadku dłuższych danych wejściowych.
Neil
2

C, 145 131 128 128 125 bajtów

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

Jest to funkcja, która pobiera ciąg znaków jako argument i wypisuje dane wyjściowe do 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);}
Klamka
źródło
Jak to działa raz i*i>l? Wygląda na to, że zacznie powtarzać sekcje.
Neil,
@ Neil Nie jestem pewien, co masz na myśli. Czy możesz podać przykład?
Klamka
@Neil Ah, nieważne, rozumiem co mówisz. To wydaje się być dziurą w specyfikacji, która wyraźnie stwierdza, że ​​długość każdego podciągu jestfloor(l/n) ; Nie jestem pewien, jakie jest zamierzone zachowanie w przypadku dłuższych danych wejściowych lub czy PO tego oczekiwało.
Klamka
1

Pyth, 17 bajtów

jmj\|cQ/lQdSh/lQ3

Wyjaśnienie

     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

źródło
1

JavaScript, 98 bajtów

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

Funkcja x(a). Zadzwoń za pomocą

console.log(x("ABCDEF"))

Julian Lachniet
źródło
0

Rubin 60 + 1 = 61 bajtów

+1 bajt dla -nflagi.

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

Zobacz na Ideone: http://ideone.com/RtoReG

Jordania
źródło
0

Python 3, 123 bajty

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

Przy dłuższych ciągach niektóre części będą powtarzane, podobnie jak wzór na długość podciągu floor(l/n). Na przykład przy łańcuchu o długości 13 znaków, łańcuch podzielony na 5 byłby taki sam jak łańcuch podzielony na 6 jako floor(13/5)==floor(13/6). Nie jestem pewien, czy PO tego się spodziewał, czy był to przeoczenie.

Cormac
źródło