Geben Sie bei einer gegebenen ASCII-Zeichenfolge die aufgelösten Suffixe aus. Wenn die Zeichenfolge beispielsweise war abcde, gibt es 5 Suffixe, die am längsten bis am kürzesten geordnet sind:

abcde
bcde
cde
de
e

Jedes Suffix wird dann explodiert , jedes Zeichen der Bedeutung so oft wie seine eine indizierte Position in diesem Suffix kopiert wird. Zum Beispiel das Auflösen der Suffixe von abcde,

abcde
12345
abbcccddddeeeee

bcde
1234
bccdddeeee

cde
123
cddeee

de
12
dee

e
1
e

Insgesamt sind die Explosions Suffixe abcdesind

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

Regeln

• Das ist Code-Golf, also gewinnt der kürzeste Code.
• Die Eingabe besteht aus den druckbaren ASCII-Zeichen. (Dies schließt Zeilenumbrüche aus, schließt jedoch Leerzeichen ein.)
• Die Ausgabe hat jede Zeichenfolge in einer separaten Zeile.
• Nachgestellte Leerzeichen sind in jeder Zeile zulässig, und am Ende befindet sich möglicherweise ein zusätzlicher Zeilenumbruch.

Testfälle

''

'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

Gelee , 5 Bytes

ṫJxJY

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Vielen Dank an Meilen für die Einsparung von 14 Bytes!

(#~#\)\.

Das ist eine wirklich schöne Lösung. Auch ziemlich prägnant.

Dies ist der Haken #~#\, der auf die Suffixe ( \.) der Eingabe angewendet wird . Wenn der Hook bei der Eingabe aufgerufen wird y, wird er folgendermaßen zerlegt:

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

Hier sind einige Zwischenergebnisse:

   ]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

Testfälle

   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 Bytes

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

Alternative 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 Bytes

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

Beendet mit einem Fehler nach dem Drucken der gewünschten Ausgabe. Teste es auf Ideone .

Wie es funktioniert

Bevor f sich rekursiv aufrufen kann, müssen die Indizes von s[1:...]berechnet werden.

First enumerate(s[0]+s)liefert alle Paare (i, c) der Zeichen c von s - wobei das erste Zeichen dupliziert wird - und die entsprechenden Indizes i . Das Voranstellen s[0]dient hier zwei Zwecken.

• Das erste Zeichen von s muss einmal wiederholt werden, aber der erste Index ist 0 .

• Sobald alle Zeichen verarbeitet wurden, s[0]wird ein IndexError ausgelöst , wodurch f mit einem Fehler beendet wird, anstatt Zeilenumbrüche zu drucken, bis das Rekursionslimit erreicht ist.

''.join(i*c for i,c in ...)Erstellt eine flache Zeichenfolge aus jedem c , die i- mal wiederholt wird und printzu STDOUT zurückkehrt.

Schließlich wiederholt der rekursive Aufruf den obigen Prozess für s ohne sein erstes Zeichen , da Noneprint zurückgibt und einfach ist .s[1:None]s[1:]f(s[1:...])

Perl 6 , 38 Bytes

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

37 Bytes + 1 für die -nBefehlszeilenumschaltung

Beispiel:

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

Erweitert:

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

@]Elyk:Erz:jac@w\

Probieren Sie es online!

Erläuterung

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

.sRvyvyN>×}J,

Probieren Sie es online!

Erläuterung

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

Sl+{_eee~n1>}h

Probieren Sie es online!

Erläuterung

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 Bytes

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

Rekursive anonyme Funktion, die auch eine führende Newline druckt. Wenn die führende Zeile nicht zulässig ist, wird sie durch 3 zusätzliche Bytes in eine nachfolgende Zeile umgewandelt:

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

Volles Programm mit ungolfed Methode und Testfällen:

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 Bytes

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

wird durch eine der Schnittstellen

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 Bytes

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

Bedarf -nund -E(oder -M5.010) Ausführung:

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

Beachten Sie, dass es bei jeder Ausführung nur auf einer Instanz funktioniert (da es die Variable verwendet, $.die bei jedem Lesen einer Zeile inkrementiert wird, sodass sie 1nur beim ersten Lesen einer Zeile beibehalten wird). (Aber kein Problem hier, einfach ^Dund erneut ausführen!)

Retina , 31 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

M&!`.+

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

Probieren Sie es online!

Java, 150 127 Bytes

Bearbeiten:

• -23 Bytes aus. Vielen Dank an 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);}

Ungolfed:

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

Schläger 184 Bytes

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

Ungolfed:

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

Ausgabe:

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

xyyzzz
yzz
z

JavaScript (ES6), 65 Byte

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>

Bisherige Versuche:

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 Bytes (99 mit kurzen Tags)

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

Ich bin mir ziemlich sicher, dass dies nicht die kürzestmögliche Antwort ist.

MATL , 12 Bytes

&+gYRYs"G@Y"

Ich liebe es, wenn Anführungszeichen zusammenkommen!

Probieren Sie es online!

Erläuterung

Dies funktioniert, indem eine Matrix erstellt wird, deren Spalten einzeln zur Lauflängendekodierung der Eingabe verwendet werden. Als Beispiel für die Eingabe ist 'abcde'die Matrix

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 Bytes

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

Das war überraschend schwieriger als ich erwartet hatte. Ich habe meine gesamte Funktion vielleicht viermal neu eingestellt.

Java 7.140 Bytes

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

Ungolfed

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

Das Befolgen der Zeile bereitet mir große Schmerzen. Ich weiß nicht, wie ich es spielen kann (weil es zwei Schleifen gibt, um die Bedingung zu brechen, die in die Druckanweisung eingefügt werden soll "\n").
System.out.println();

Pyke, 12 Bytes

VilS],A*s
}t

Probieren Sie es hier aus!

Ruby, 51 Bytes

Verwendet das -nFlag für +1 Byte.

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

R, 108 Bytes

Liest die Eingabe von stdin und druckt nach 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="")

Ich fand die Verwendung von do.callhier angemessen. Grundsätzlich werden zwei Eingaben benötigt: 1. Ein Funktionsname in Form einer Zeichenfolge ( rephier) und eine Liste von Argumenten und 2. Durch iteratives Anwenden wird die Funktion unter Verwendung der Argumente in der Liste aufgerufen.

Z.B:

• rep("c",3) erzeugt den Vektor "c" "c" "c"
• do.call("rep",list(c("a","b","c"),1:3)) erzeugt den Vektor "a" "b" "b" "c" "c" "c"
• was gleichbedeutend mit aufeinanderfolgendem Aufrufen ist rep("a",1), rep("b",2)undrep("c",3)

Vim, 43 Bytes

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

Das erste Makro trennt die Suffixe, das zweite Makro "explodiert" sie. Wahrscheinlich schlagbar. Leerzeichen sind ärgerlich.

C 186 Bytes

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

Dies kann wahrscheinlich einiges gekürzt werden, aber ich wollte es nur versuchen. Es ist mein zweiter Versuch beim Golf, also gib mir alle Hinweise (* lol), die du kannst. Es nimmt einen String als Parameter und führt die Explosion von dort aus. u wird als Puffer verwendet, in dem die aufgelöste Zeichenfolge gespeichert wird.

Ungolfed:

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

Erwartet eine Eingabe in stdin, die mit einem Tabulatorzeichen abgeschlossen wird.

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
}

Erläuterung

Dies ist eigentlich eine ziemlich gute Aufgabe für Acc !! , da es nur erforderlich ist, einen String zu lesen und ihn mit einigen verschachtelten Schleifen zu durchlaufen. Wir lesen den String in den Akkumulator ein und behandeln ihn als eine Folge von 128-stelligen Basen, wobei das erste Zeichen am Ende niedriger Ordnung steht. Nach der Eröffnungsschleife Count ckann der Akkumulatorwert wie folgt definiert werden ( xyzals Beispieleingabe):

128^   3  2  1  0
     tab  z  y  x

(Der tatsächliche Akkumulatorwert für dieses Beispiel ist 9*128^3 + 122*128^2 + 121*128 + 120= 20888824.)

Wir können dann über den String iterieren, indem wir über die zunehmenden Potenzen von 128 iterieren. Und wir können die Suffixe iterieren, indem wir den Akkumulator nach jeder Iteration durch 128 dividieren und ein Zeichen abhacken.

Mit Einrückung und Kommentaren:

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