Biorąc pod uwagę ciąg ASCII, wypisz jego rozbite przyrostki. Na przykład, jeśli ciąg był abcde, istnieje 5 sufiksów, uporządkowanych od najdłuższego do najkrótszego:

abcde
bcde
cde
de
e

Każdy sufiks jest następnie eksplodowany , co oznacza, że ​​każdy znak jest kopiowany tyle razy, ile jego indeks z jednym indeksem w tym sufiksie. Na przykład rozbijanie przyrostków abcde,

abcde
12345
abbcccddddeeeee

bcde
1234
bccdddeeee

cde
123
cddeee

de
12
dee

e
1
e

W sumie rozszyfrowane przyrostki abcdeto

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

Zasady

• To jest golf golfowy, więc wygrywa najkrótszy kod.
• Dane wejściowe będą składały się z drukowalnych znaków ASCII. (To wyklucza znaki nowej linii, ale obejmuje spacje).
• Dane wyjściowe będą miały każdy ciąg w osobnej linii.
• Końcowe spacje są dozwolone w każdej linii, a na końcu może znajdować się dodatkowa nowa linia.

Przypadki testowe

''

'a'
a

'bc'
bcc
c

'xyz'
xyyzzz
yzz
z

'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f

's p a c e'
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

Galaretka , 5 bajtów

ṫJxJY

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

ṫJxJY  Main link. Argument: s (string)

 J     Indices; yield I := [1, ..., len(s)].
ṫ      Tail; get the suffixes of s starting at indices [1, ..., len(s)].
   J   Indices; yield I again.
  x    Repeat. The atom 'x' vectorizes at depth 1 (1D arrays of numbers/characters)
       in its arguments. This way, each suffix t gets repeated I times, meaning
       that the first character of t is repeated once, the second twice, etc.
       If left and right argument have different lengths, the longer one is
       truncated, so I can safely be applied to all suffixes.
    Y  Join, separating by linefeeds.

J, 22 12 8 bajtów

Dzięki milom za zaoszczędzenie 14 bajtów!

(#~#\)\.

To naprawdę miłe rozwiązanie. Całkiem zwięzłe.

To jest hak #~#\zastosowany do sufiksów ( \.) wejścia. Hak, gdy zostanie wywołany na wejściu y, jest rozkładany w następujący sposób:

(#~#\) y
y #~ #\ y

Oto kilka wyników pośrednich:

   ]s =: 's p a c e'
s p a c e
   #\ s
1 2 3 4 5 6 7 8 9
   (quote) s
's p a c e'
   (quote;#)\ s
+-----------+-+
|'s'        |1|
+-----------+-+
|'s '       |2|
+-----------+-+
|'s p'      |3|
+-----------+-+
|'s p '     |4|
+-----------+-+
|'s p a'    |5|
+-----------+-+
|'s p a '   |6|
+-----------+-+
|'s p a c'  |7|
+-----------+-+
|'s p a c ' |8|
+-----------+-+
|'s p a c e'|9|
+-----------+-+
   1 2 3 # '123'
122333
   3 3 3 # '123'
111222333
   ]\. s
s p a c e
 p a c e
p a c e
 a c e
a c e
 c e
c e
 e
e
   quote\. s
's p a c e'
' p a c e'
'p a c e'
' a c e'
'a c e'
' c e'
'c e'
' e'
'e'
   (#~#\) s
s  ppp    aaaaa      ccccccc        eeeeeeeee
   (#~#\)\. s
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

Przypadki testowe

   f =: (#~#\)\.
   f
(#~ #\)\.
   f ''
   f 'a'
a
   f 'bc'
bcc
c
   f 'xyz'
xyyzzz
yzz
z
   f 'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f
   f 's p a c e'
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

   ]tc =: <;._1 '|' , '|a|bc|xyz|code-golf|s p a c e'
++-+--+---+---------+---------+
||a|bc|xyz|code-golf|s p a c e|
++-+--+---+---------+---------+
   ,. f &. > tc
+---------------------------------------------+
+---------------------------------------------+
|a                                            |
+---------------------------------------------+
|bcc                                          |
|c                                            |
+---------------------------------------------+
|xyyzzz                                       |
|yzz                                          |
|z                                            |
+---------------------------------------------+
|coodddeeee-----ggggggooooooollllllllfffffffff|
|oddeee----gggggoooooolllllllffffffff         |
|dee---ggggooooollllllfffffff                 |
|e--gggoooolllllffffff                        |
|-ggooollllfffff                              |
|goolllffff                                   |
|ollfff                                       |
|lff                                          |
|f                                            |
+---------------------------------------------+
|s  ppp    aaaaa      ccccccc        eeeeeeeee|
| pp   aaaa     cccccc       eeeeeeee         |
|p  aaa    ccccc      eeeeeee                 |
| aa   cccc     eeeeee                        |
|a  ccc    eeeee                              |
| cc   eeee                                   |
|c  eee                                       |
| ee                                          |
|e                                            |
+---------------------------------------------+

Python, 61 bajtów

f=lambda s,i=0:s[i:]and-~i*s[i]+f(s,i+1)or s and'\n'+f(s[1:])

Alternatywa 63:

f=lambda s,b=1:s and f(s[:-1],0)+s[-1]*len(s)+b*('\n'+f(s[1:]))

Python 3, 91 68 65 bajtów

def f(s):f(s[1:print(''.join(i*c for i,c in enumerate(s[0]+s)))])

Kończy się z błędem po wydrukowaniu żądanego wyjścia. Przetestuj na Ideone .

Jak to działa

Zanim f będzie mógł się nazwać rekurencyjnie, s[1:...]należy obliczyć wskaźniki

Pierwsze enumerate(s[0]+s)wydajności wszystkie pary (I, C) znaków C z S - z jego pierwszej postaci powielona - a odpowiednie wskaźniki I . Przygotowywanie s[0]służy tutaj dwóm celom.

• Pierwszy znak s należy powtórzyć raz, ale pierwszym indeksem jest 0 .

• Po przetworzeniu wszystkich znaków s[0]wywoła błąd IndexError , powodując, że f kończy się błędem, zamiast drukować nowe wiersze, aż do osiągnięcia limitu rekurencji.

''.join(i*c for i,c in ...)buduje płaski ciąg każdego c powtórzenia i razy, który printpowtarza echo do STDOUT.

Wreszcie, ponieważ printzwraca None i s[1:None]jest po prostu s[1:], wywołanie rekurencyjne f(s[1:...])powtarza powyższy proces dla s bez swojego pierwszego znaku.

Perl 6 , 38 bajtów

m:ex/.+$/.map:{put [~] .comb Zx 1..*}

37 bajtów + 1 dla -nprzełącznika wiersza poleceń

Przykład:

$ perl6 -ne 'm:ex/.+$/.map:{put [~] .comb Zx 1..*}' <<< 'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f

Rozszerzony:

# -n command line switch takes each input line and places it in ｢$_｣

# You can think of it as surrounding the whole program with a for loop
# like this:
for lines() {

  # match
  m
  :exhaustive # every possible way
  / .+ $/     # at least one character, followed by the end of the string

  .map:

  {
    put           # print with newline
      [~]         # reduce using string concatenation ( don't add spaces between elements )
        .comb     # split into individual chars
        Z[x]      # zip using string repetition operator
        1 .. *    # 1,2,3,4 ... Inf
  }

}

Brachylog , 17 bajtów

@]Elyk:Erz:jac@w\

Wypróbuj online!

Wyjaśnienie

@]E                 E is a suffix of the Input
   lyk              The list [0, ..., length(E) - 1]
      :Erz          The list [[0th char of E, 0], ..., [Last char of E, length(E) - 1]]
          :ja       For all elements of that list, concatenate the Ith char I times to itself
             c      Concatenate the list into a string
              @w    Write followed by a line break
                \   False: backtrack to another suffix of the Input

05AB1E , 13 bajtów

.sRvyvyN>×}J,

Wypróbuj online!

Wyjaśnienie

.s              # push list of suffixes of input
  R             # reverse the list
   vy           # for each string
     vy   }     # for each char in string
       N>×      # repeat it index+1 times
           J,   # join and print with newline

CJam , 14 bajtów

Sl+{_eee~n1>}h

Wypróbuj online!

Wyjaśnienie

Sl+   e# Read input and prepend a space.
{     e# While the string is non-empty...
  _   e#   Make a copy.
  ee  e#   Enumerate. Gives, e.g. [[0 ' ] [1 'a] [2 'b] [3 'c]].
  e~  e#   Run-length decode. Gives "abbccc".
  n   e#   Print with trailing linefeed.
  1>  e#   Discard first character.
}h

C #, 101 bajtów

f=s=>{var r="\n";for(int i=0;i<s.Length;)r+=new string(s[i],++i);return""==s?r:r+f(s.Substring(1));};

Rekurencyjna anonimowa funkcja, która drukuje również wiodącą nową linię. Jeśli wiodący nowy wiersz nie jest dozwolony, 3 dodatkowe bajty zamieniają go w końcowy nowy wiersz:

f=s=>{var r="";for(int i=0;i<s.Length;)r+=new string(s[i],++i);return""==s?r:r+"\n"+f(s.Substring(1));};

Pełny program z nieprzylepioną metodą i testami:

using System;

namespace ExplodedSuffixes
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string, string> f = null;
            f = s =>
            {
                var r = "\n";
                for (int i = 0; i < s.Length; )
                    r += new string(s[i], ++i);
                return "" == s ? r : r + f(s.Substring(1));
            };

            // test cases:
            string x = "abcde";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "a";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "bc";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "xyz";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "code-golf";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "s p a c e";
            Console.WriteLine("\'" + x + "\'" + f(x));
        }
    }
}

Haskell, 48 bajtów

e=map(concat.zipWith replicate[1..]).scanr(:)[] 

jest powiązany z dowolnym z

ghc exploded_suffixes.hs -e 'e"abcde"'
ghc exploded_suffixes.hs -e 'mapM_ putStrLn.e=<<getLine' <<<code-golf
ghc exploded_suffixes.hs -e 'Control.Monad.forever$putStr.unlines.e=<<getLine'

Perl, 36 + 1 ( -n) = 37 bajtów

/.+$(?{$.=say$&=~s%.%$&x$.++%rge})^/

Potrzebuje -ni -E(lub -M5.010) do uruchomienia:

perl -nE '/.+$(?{$.=say$&=~s%.%$&x$.++%rge})^/' <<< "code-golf"

Zauważ, że działa tylko na jednej instancji za każdym razem, gdy go uruchamiasz (ponieważ używa zmiennej, $.która jest zwiększana za każdym razem, gdy czytana jest linia, więc zachowuje 1tylko przy pierwszym czytaniu linii). (Ale nie ma problemu, po prostu ^Duruchom go ponownie!)

Retina , 31 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

M&!`.+

$.%`$*»
%+r`»($|.)
$1$1

Wypróbuj online!

Java, 150 127 bajtów

Edytować:

• -23 bajty wyłączone. Dzięki @Kevin Cruijssen

Snipet:

f->{String s[]=f.split(""),o="";int i=-1,j,l=s.length;for(;++i<l;)for(j=-2;++j<i;o+=s[i]);return l<1?"":o+"\n"+f.substring(1);}

Nie golfowany:

public static String explodeSuff(String suff){
  char [] s = suff.toCharArray();
  String out = "";
  if(s.length==0)return "";
  for(int i=-1;++i<s.length;){
    for(int j=-2;++j<i;){
      out+=s[i];
    }
  }
  return out+"\n"+suff.subString(1);
}

Rakieta 184 bajty

(let p((l(string->list s))(ol'()))(cond[(null? l)(display(list->string(flatten ol)))]
[else(p(cdr l)(append ol(list #\newline)(for/list((i l)(n(length l)))(for/list((j(+ 1 n)))i))))]))

Nie golfowany:

(define(f s)
 (let loop((l(string->list s))
             (outl '()))
    (cond
      [(null? l)
       (display
        (list->string
         (flatten outl)))]
      [else
       (loop
        (rest l)
        (append outl
                (list #\newline)
                (for/list ((i l)
                           (n (length l)))
                  (for/list ((j (add1 n)))
                    i
                    ))))]  )))


(f "abcde")
(f "xyz")

Wynik:

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

xyyzzz
yzz
z

JavaScript (ES6), 65 bajtów

f=s=>s?[s.replace(/./g,(c,i)=>c.repeat(i+1)),...f(s.slice(1))]:[]

<input oninput=o.textContent=f(this.value).join`\n`><pre id=o>

Poprzednie próby:

67: s=>[...s].map((_,i)=>s.slice(i).replace(/./g,(c,i)=>c.repeat(i+1)))
84: s=>s.replace(/./g,`$&$'
    `).match(/.+/g).map(s=>s.replace(/./g,(c,i)=>c.repeat(i+1)))
89: f=(s,t=s.replace(/./g,(c,i)=>c.repeat(i+1)))=>t?[]:[t,...f(s,t.replace(/(.)(?=\1)/g,''))]

PHP, 103 bajty (99 z krótkimi znacznikami)

<?php for($s=$argv[1];""!=$s[$i++];$o.="
")for($j=0;""!=$l=$s[$j+$i-1];)$o.=str_pad('',++$j,$l);echo$o;

Jestem pewien, że nie jest to najkrótsza możliwa odpowiedź.

MATL , 12 bajtów

&+gYRYs"G@Y"

Uwielbiam, kiedy łączą się znaki cudzysłowu!

Wypróbuj online!

Wyjaśnienie

Działa to poprzez zbudowanie macierzy, której kolumny są używane, jedna po drugiej, do dekodowania danych wejściowych przez całą długość. Na przykład 'abcde'macierz wejściowa to

1 0 0 0 0
2 1 0 0 0
3 2 1 0 0
4 3 2 1 0
5 4 3 2 1

Kod:

&+g    % Implicit input. NxN matrix of ones, where N is input size
YR     % Set entries above diagonal to zero
Ys     % Cumulative sum of each column. This gives the desired matrix 
"      % For each column
  G    %   Push input (for example 'abcde')
  @    %   Push current column (for example [0;0;1;2;3])
  Y"   %   Run-length decode (example output 'cddeee')
       % Implicit end
       % Implicit display

Python 3, 95 bajtów

def f(s):return'\n'.join(''.join(s[j:][i]*(i+1)for i in range(len(s)-j))for j in range(len(s)))

To było zaskakująco trudniejsze, niż się spodziewałem. Całą moją funkcję przerobiłem może 4 razy.

Java 7140 bajtów

void c(char[]a,int l,int j){if(l<1)return;c(a,--l,++j);for(int i=0,k;i<j;i++)for(k=0;k++<=i;)System.out.print(a[i+l]);System.out.println();}

Nie golfił

 void c(char[]a,int l,int j)
{
if (l < 1) 
return ;
c(a , --l , ++j) ;
for(int i = 0 , k; i < j ; i++)
for(k = 0 ; k++ <= i ;)
System.out.print(a[i+l]);
System.out.println();
}

Następujący wiersz sprawia mi bardzo ból. Nie wiem, jak mogę go zagrać w golfa (ponieważ istnieją dwie pętle, aby przełamać warunek do wypisania "\n"instrukcji).
System.out.println();

Pyke, 12 bajtów

VilS],A*s
}t

Wypróbuj tutaj!

Rubinowy, 51 bajtów

Używa -nflagi dla bajtu +1.

(k=0;puts$_.gsub(/./){$&*k+=1};$_[0]="")while$_>$/

R, 108 bajtów

Czytaj dane wejściowe ze standardowego wejścia i drukuje na standardowe wyjście

s=scan(,"");n=nchar(s);for(i in 1:n)cat(do.call("rep",list(strsplit(s,"")[[1]][i:n],1:(n-i+1))),"\n",sep="")

Czułem, że użycie do.calltutaj było odpowiednie. Zasadniczo wymaga dwóch danych wejściowych: 1. nazwa funkcji w postaci ciągu (rep tutaj) i listę argumentów oraz 2. iteracyjnie stosuje wywołuje funkcję przy użyciu argumentów z listy.

Na przykład:

• rep("c",3) produkuje wektor "c" "c" "c"
• do.call("rep",list(c("a","b","c"),1:3)) produkuje wektor "a" "b" "b" "c" "c" "c"
• co jest równoważne z kolejnymi wywołaniami rep("a",1), rep("b",2)orazrep("c",3)

Vim, 43 bajty

qqYlpx@qq@qqr0<C-H><C-V>{$:s/\v%V(.)\1*/&\1/g<CR>@rq@r

Pierwsze makro oddziela sufiksy, drugie makro „wybucha” je. Prawdopodobnie do pobicia. Przestrzenie są denerwujące.

C, 186 bajtów

#include <string.h>
#define S strlen
p(char* s){char *t=s;char u[999]="";for(int i=0;i<S(s);i++){for(int j=i+1;j>0;j--){sprintf(u+S(u),"%c",*t);}t++;}printf("%s\n",u);if(S(s)>1)p(s+1);}

Prawdopodobnie można to trochę skrócić, ale chciałem tylko spróbować. To moja druga próba gry w golfa, więc daj mi wszelkie wskazówki (* lol), jakie możesz. Bierze ciąg jako parametr i stamtąd eksploduje. u jest używany jako bufor, który przechowuje rozłożony ciąg.

Nie golfowany:

#include <string.h>
#define S strlen 
p(char* s){
    char *t=s;
    char u[999]="";
    for(int i=0;i<S(s);i++){
        for(int j=i+1;j>0;j--){
            sprintf(u+S(u),"%c",*t);
        }
        t++;
    }
    printf("%s\n",u);
    if(S(s)>1)p(s+1);
}

Acc !! , 150 bajtów

Oczekuje wejścia na standardowe wejście, zakończone znakiem tabulacji.

N
Count c while _/128^c-9 {
_+N*128^(c+1)
}
Count i while _-9 {
Count j while _/128^j-9 {
Count k while j+1-k {
Write _/128^j%128
}
}
Write 10
_/128
}

Wyjaśnienie

To jest całkiem niezłe zadanie dla Acc !! , ponieważ wymaga jedynie odczytu ciągu i iteracji nad nim za pomocą zagnieżdżonych pętli. Odczytujemy ciąg do akumulatora, traktując go jako sekwencję podstawowych cyfr 128, z pierwszym znakiem na końcu niskiego rzędu. Po Count cpętli otwierającej wartość akumulatora można skonfigurować w następujący sposób (wykorzystując xyzjako przykładowe dane wejściowe):

128^   3  2  1  0
     tab  z  y  x

(Rzeczywista wartość akumulatora w tym przykładzie wynosi 9*128^3 + 122*128^2 + 121*128 + 120= 20888824.)

Następnie możemy iterować ciąg, iterując zwiększanie mocy 128. I możemy iterować przyrostki, dzieląc akumulator przez 128 po każdej iteracji, odcinając znak.

Z wcięciem i komentarzami:

# Initialize the accumulator with the first input character
N
# Loop until most recent input was a tab (ASCII 9)
Count c while _/128^c - 9 {
    # Input another character and add it at the left end (next higher power of 128)
    _ + N * 128^(c+1)
}

# Loop over each suffix, until only the tab is left
Count i while _ - 9 {
    # Loop over powers of 128 until the tab
    Count j while _/128^j - 9 {
        # Loop (j+1) times
        Count k while j + 1 - k {
            # Output the j'th character
            Write _ / 128^j % 128
        }
    }
    # Output a newline
    Write 10
    # Remove a character
    _/128
}