Étant donné une chaîne ASCII, sortez les suffixes éclatés de celle-ci. Par exemple, si la chaîne était abcde, il y a 5 suffixes, classés du plus long au plus court:

abcde
bcde
cde
de
e

Chaque suffixe est ensuite éclaté , ce qui signifie que chaque caractère est copié autant de fois que son emplacement à un index dans ce suffixe. Par exemple, exploser les suffixes de abcde,

abcde
12345
abbcccddddeeeee

bcde
1234
bccdddeeee

cde
123
cddeee

de
12
dee

e
1
e

Au total, les suffixes éclatés de abcdesont

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

Règles

• C'est le code-golf donc le code le plus court l'emporte.
• L'entrée sera constituée des caractères ASCII imprimables. (Cela exclut les nouvelles lignes mais inclut les espaces.)
• La sortie aura chaque chaîne sur une ligne distincte.
• Les espaces de fin sont autorisés sur chaque ligne et il peut y avoir une nouvelle ligne supplémentaire à la fin.

Cas de test

''

'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

Gelée , 5 octets

ṫJxJY

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

ṫ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 octets

Merci aux miles pour avoir économisé 14 octets!

(#~#\)\.

Maintenant, c'est une très bonne solution. Assez succinct aussi.

Il s'agit du hook #~#\appliqué aux suffixes ( \.) de l'entrée. Le crochet, lorsqu'il est appelé en entrée y, se décompose ainsi:

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

Voici quelques résultats intermédiaires:

   ]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

Cas de test

   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 octets

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

Variante 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 octets

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

Se termine avec une erreur après l'impression de la sortie souhaitée. Testez-le sur Ideone .

Comment ça fonctionne

Avant que f puisse s'appeler récursivement, les indices de s[1:...]doivent être calculés.

La première enumerate(s[0]+s)donne toutes les paires (i, c) de caractères c de s - avec son premier caractère dupliqué - et les indices correspondants i . La prépension s[0]sert ici à deux fins.

• Le premier caractère de s doit être répété une fois, mais le premier index est 0 .

• Une fois que tous les caractères ont été traités, déclenches[0] une IndexError , provoquant la fin de f avec une erreur plutôt que l'impression de nouvelles lignes jusqu'à ce que la limite de récursivité soit atteinte.

''.join(i*c for i,c in ...)construit une chaîne plate de chaque c répété i fois, qui printfait écho à STDOUT.

Enfin, puisque printrenvoie None et s[1:None]est simplement s[1:], l'appel récursif f(s[1:...])répète le processus ci-dessus pour s sans son premier caractère.

Perl 6 , 38 octets

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

37 octets + 1 pour le -ncommutateur de ligne de commande

Exemple:

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

Étendu:

# -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 octets

@]Elyk:Erz:jac@w\

Essayez-le en ligne!

Explication

@]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 octets

.sRvyvyN>×}J,

Essayez-le en ligne!

Explication

.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 octets

Sl+{_eee~n1>}h

Essayez-le en ligne!

Explication

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 octets

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

Fonction anonyme récursive, qui imprime également une nouvelle ligne de tête. Si la nouvelle ligne de tête n'est pas autorisée, 3 octets supplémentaires la transforment en une nouvelle ligne de fin:

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

Programme complet avec méthode non golfée et cas de test:

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 octets

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

est interfacé par l'un des

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 octets

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

Besoins -net -E(ou -M5.010) pour fonctionner:

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

Notez qu'il ne fonctionne que sur une seule instance chaque fois que vous l'exécutez (car il utilise la variable $.qui est incrémentée chaque fois qu'une ligne est lue, donc il 1ne tient que la première fois qu'une ligne est lue). (Mais pas de problème ici, juste ^Det relancez-le!)

Rétine , 31 octets

Le nombre d'octets suppose un codage ISO 8859-1.

M&!`.+

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

Essayez-le en ligne!

Java, 150 127 octets

Éditer:

• -23 octets éteints. Merci à @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);}

Non golfé:

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

Raquette 184 octets

(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))))]))

Non golfé:

(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")

Production:

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

xyyzzz
yzz
z

JavaScript (ES6), 65 octets

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>

Tentatives précédentes:

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 octets (99 avec des balises courtes)

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

Je suis assez certain que ce n'est pas la réponse la plus courte possible.

MATL , 12 octets

&+gYRYs"G@Y"

J'adore quand les guillemets se rejoignent!

Essayez-le en ligne!

Explication

Cela fonctionne en construisant une matrice dont les colonnes sont utilisées, une par une, pour décoder en entrée la longueur. Par exemple, pour la saisie, 'abcde'la matrice est

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

Code:

&+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 octets

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

C'était étonnamment plus difficile que ce à quoi je m'attendais. J'ai refait toute ma fonction peut-être 4 fois.

Java 7,140 octets

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

Non golfé

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

La ligne suivante me fait très mal, je ne sais pas comment je peux y jouer (car il y a deux boucles pour briser la condition à mettre "\n"en impression).
System.out.println();

Pyke, 12 octets

VilS],A*s
}t

Essayez-le ici!

Rubis, 51 octets

Utilise l' -nindicateur pour +1 octet.

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

R, 108 octets

Lire l'entrée depuis stdin et l'imprimer vers stdout

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="")

J'ai pensé que l'utilisation de do.callétait appropriée ici. Il prend essentiellement deux entrées: 1. un nom de fonction sous la forme d'une chaîne ( repici) et une liste d'arguments et 2. applique de manière itérative les appels à la fonction en utilisant les arguments de la liste.

Par exemple:

• rep("c",3) produit le vecteur "c" "c" "c"
• do.call("rep",list(c("a","b","c"),1:3)) produit le vecteur "a" "b" "b" "c" "c" "c"
• ce qui équivaut à appeler consécutivement rep("a",1), rep("b",2)etrep("c",3)

Vim, 43 octets

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

La première macro sépare les suffixes, la deuxième macro les "explose". Probablement battable. Les espaces sont ennuyeux.

C, 186 octets

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

Cela peut probablement être raccourci un peu, mais je voulais juste l'essayer. C'est mon deuxième essai au golf, alors donnez-moi tous les conseils (* lol) que vous pouvez. Il prend une chaîne comme paramètre et explose à partir de là. u est utilisé comme tampon qui stocke la chaîne éclatée.

Non golfé:

#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 octets

Attend une entrée sur stdin, terminée par un caractère de tabulation.

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
}

Explication

C'est en fait une assez bonne tâche pour Acc !! , car il suffit de lire une chaîne et de l'itérer avec des boucles imbriquées. Nous lisons la chaîne dans l'accumulateur, la traitant comme une séquence de chiffres de base 128, avec le premier caractère à l'extrémité inférieure. Après la Count cboucle d' ouverture , la valeur de l'accumulateur peut être conceptualisée comme ceci (en utilisant xyzcomme exemple d'entrée):

128^   3  2  1  0
     tab  z  y  x

(La valeur réelle de l'accumulateur pour cet exemple est 9*128^3 + 122*128^2 + 121*128 + 120= 20888824.)

Nous pouvons ensuite parcourir la chaîne en itérant sur des puissances croissantes de 128. Et nous pouvons parcourir les suffixes en divisant l'accumulateur par 128 après chaque itération, en coupant un caractère.

Avec retrait et commentaires:

# 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
}