Eigentlich nicht weder von inspiriert Atbash Selbst Palindrome noch von Generalized Gematria Calculator .

Bei einem String s der Länge n wird die Revu'a-Sequenz ausgegeben , bei der es sich um das erste Zeichen von s , die ersten beiden Zeichen von s , ... die ersten n –2 Zeichen von s und die ersten n –1 Zeichen von s handelt das ganze s .

Die Zeichenfolge besteht nur aus Unicode-Zeichen (beliebige Codierung), die eine starke Richtungsabhängigkeit aufweisen und im Bereich von 0x0000 bis 0xFFFF liegen. Es werden jedoch keine Richtungssteuerzeichen angezeigt. Alle Zeichen in einer bestimmten Zeichenfolge haben dieselbe Richtung.

Sie können in Array - Schreibweise zurückzukehren ["t","te","tes","test"], als ein Leerzeichen getrennte Zeichenfolge "t te tes test", wie mehrzeiligen Text
t
te
tes
test
, einem vorformatierten Array

t
te
tes
Prüfung

Bei der Eingabe von rechts nach links muss die Ausgabe von rechts nach links in der richtigen Reihenfolge erfolgen:
Eingabe: "נחמן"
Ausgabe: "נ נח נחמ נחמן"oder

נ
נח
נחמ
נחמנח

Dyalog APL, 2 Bytes

,\

Kumulativ durch Verketten reduzieren. Probieren Sie es hier aus .

Die Formatierung der Ausgabe ist besser, wenn Sie ein Präfix voranstellen⍕ , zeigt aber deutlich die richtige Reihenfolge ohne.

JavaScript (ES6), 27 26 25 Byte

Dank @nicael und @ MartinBüttner ein Byte gespart, dank @Neil ein Byte

x=>x.replace(/.?/g,"$` ")

Nutzt einige integrierte Funktionen von JS .replace. Insbesondere wird in der Ersetzung $`alles vor dem übereinstimmenden Zeichen. Wenn Sie den regulären Ausdruck verwenden, bedeutet dies /.?/gnicht, /./gdass er auch mit der leeren Zeichenfolge am Ende übereinstimmt.

Japt, 10 4 Bytes

Ich wusste nicht, dass eine kumulative Reduzierung in diesem Fall so nützlich wäre. :-)

UŒ+

Ausgaben als Array, standardmäßig durch Kommas getrennt. Wenn dies nicht zulässig ist, verwenden Sie stattdessen diesen 6-Byte-Code:

U¬å+ ·

Probieren Sie es online!

Wie es funktioniert

      // Implicit: U = input string
U¬    // Split U into chars.
  å+  // Cumulative reduce: loop through each item in the array, concatenating it to the total.
      // ["t","e","s","t"] => ["t","te","tes","test"].
      // Implicit: output last expression

Brainfuck, 40 Bytes

Meine Konsole unterstützt keine Zeichen von rechts nach links, aber ich denke nicht, dass es funktionieren wird: c

++++++++++>,[>,]<[<]>[[<+>-]<[<]>[.>]>]

Ungolfed:

++++++++++> # Store 10 (Newline)
,[>,]       # Store input
<[<]>       # Goto first character
[           # While next character
  [<+>-]    # Copy character to the left
  <[<]>     # Goto first character
  [.>]      # Print all charaters
  >         # Go to next character
]

Retina, 11 7 Bytes

.
 $`$0

Die Ausgabe ist durch Leerzeichen getrennt, mit einem führenden Leerzeichen und einem nachfolgenden Zeilenvorschub.

Probieren Sie es online!

Python, 35

f=lambda s:f(s[:-1])+[s]if s else[]

Es konnte keine Möglichkeit gefunden werden, and/ordie Rekursion zu vereinfachen, da dies []falsch ist.

Bei einer rekursiven Lösung wird eine Liste von Zeichenfolgen zurückgegeben.

Probieren Sie es online aus

Prolog (SWI), 60 49 Bytes

Code:

p(X):-findall(S,atom_prefix(X,S),[_|R]),write(R).

Erklärt:

atom_prefix mit X als Eingabe und S als Variable gibt 1 Präfix des Atoms X beginnend mit dem leeren Atom an.

findall holt alle Lösungen und listet sie auf.

[_ | R] wirft den Kopf (das leere Atom) weg und speichert den Schwanz in R

Beispiele:

p('נחמן').
[נ, נח, נחמ, נחמן]

p('test').
[t, te, tes, test]

Probieren Sie es hier online aus

Bearbeiten: 11 Bytes gespart, indem nur der Schwanz in R gespeichert wird .

Pyth, 3

._z

Prefix Builtin macht den Trick.

Test Suite

GNU Sed, 21

Die Punktzahl enthält +1 für die -EOption zu sed:

:
s/^(\S+)\S/\1 &/
t

Funktioniert für LTR, aber nicht für RTL - das habe ich verpasst. . Eigentlich ist es tut Arbeit wurde die RTL - Rendering einfach nicht richtig in meinem Terminal. Es funktioniert gut mit IO in einem vernünftigen Texteditor (z. B. Emacs) angezeigt. Es funktioniert auch in Ideone:

Probieren Sie es online aus.

Brachylog , 5 Bytes (nicht konkurrierend)

@[@w\

Probieren Sie es online!

Erläuterung

@[       Take a prefix of the input
  @w     Write this prefix to STDOUT followed by a linebreak
    \    False: try another prefix

Von rechts nach links verlaufende Zeichenfolgen scheinen einwandfrei zu funktionieren, obwohl ich sie nie in Betracht gezogen habe.

CJam, 9 Bytes

l{N2$@+}*

Der Ausgang ist zeilenweise getrennt.

Teste es hier.

Erläuterung

l     e# Read input.
{     e# Fold this block over the input, which is effectively a foreach-loop which skips
      e# the first character...
  N   e#   Push a linefeed.
  2$  e#   Copy the previous string.
  @   e#   Pull up the current character.
  +   e#   Concatenate.
}*

JavaScript, 36 Bytes

x=>[...x].map((c,i)=>x.slice(0,i+1))

Demo:

a=x=>[...x].map((c,i)=>x.slice(0,i+1));
document.write(
  a("test")+"<br>"+
  a("נחמן")
)

Das Prinzip besteht darin, die Zeichenfolge vom ersten Zeichen bis zu jedem Zeichen im Wort abzubilden und auszugeben. Überraschenderweise funktioniert dies auch für die RTL-Strings perfekt, es ist keine Optimierung erforderlich.

Meine Konsole unterstützt keine Zeichen von rechts nach links, aber ich denke nicht, dass es funktionieren wird: c

C, 74 Bytes (2. Eintrag)

char m[2<<9];i;main(){do{m[i]=getchar();printf("%s ",m);}while(m[i++]>0);}

Ungolfed:

#include <stdio.h>

// char, because `printf("%s", str);` expects a array of characters.
char str[2<<9];
int  str_len = 0;
int main(void) {
    do {
        str[str_len]=getchar();
        printf("%s ", str);
    } while(m[i++]>0);
    return 0;
}

Meine Konsole unterstützt keine Zeichen von rechts nach links, aber ich denke nicht, dass es funktionieren wird: c

C, 105 Bytes (3. Eintrag)

m[2<<9];i;j;k;main(){while((m[i++]=getchar())<0);for(;j<i;j++,putchar(10))for(k=0;k<j;k++)putchar(m[k]);}

Ungolfed:

#include <stdio.h>

int str[2<<9];
int str_len = 0;
int main(void) {
    do {
        str[str_len] = getchar();
    } while(str[str_len++] != EOF);
    int i;
    for(i=0; i<str_len; i++) {
        int j;
        for(j=0; j<i; j++) {
          putchar(str[j]);
        }
        putchar(10);
    }
}

TI-BASIC, 18 Bytes

For(X,1,10^(9
Disp sub(Ans,1,X
End

Nicht technisch gültig: TI-BASIC unterstützt Unicode nicht.

Benennen Sie dies prgmAund geben Sie es mit ein Ans.

Die Programmrekursion wäre kürzer, die Variablen könnten jedoch nicht initialisiert werden. Daher zeigen wir bei jeder Iteration eine Teilzeichenfolge der Eingabe an. Die Eingabe wird nie überschrieben, da Disp keinen Wert zurückgibt.

Schließlich wird das Programm mit einem Fehler beendet, nachdem der gesamte String gedruckt wurde.

Python, 54 Bytes

b='';y=input()
for a in range(len(y)):b+=y[a];print(b)

Java 7, 95 92 Bytes

String d(String a){for(int i=a.length();i-->0;a=a.substring(0,i)+(i>0?"\n":"")+a);return a;}

Vorherige Antwort ( 95 Bytes ):

String c(String s){String r="";for(int i=0;++i<=s.length();r+=s.substring(0,i)+"\n");return r;}

Ich habe einen rekursiven Ansatz versucht, aber ich konnte ihn nicht wirklich zum Laufen bringen. Vielleicht wird jemand anderes (kürzer als diese for-Schleife).

Ungolfed & Testfälle:

Probieren Sie es hier aus.

class M{
  static String d(String a){
    for(int i = a.length(); i-- > 0; a = a.substring(0, i) + (i > 0 ? "\n" : "") + a);
    return a;
  }

  public static void main(String[] a){
    System.out.println(c("test"));
    System.out.println();
    System.out.println(c("נחמן"));
  }
}

Ausgabe:

t
te
tes
test

נ
נח
נחמ
נחמן

Dip , 1 Byte (nicht konkurrierend)

E

Erläuterung:

.   # Implicit input
 E  # Get prefixes
  . # Implicit print

MATL , 8 Bytes

Verwendet die aktuelle Version (8.0.0) von Sprache / Compiler

jtn1X"YR

Beispiel

>> matl
 > jtn1X"YR
 >
> test
t
te
tes
test

Erläuterung

j           % input string
tn          % duplicate and get length, say "N"
1X"         % repeat string N times vertically. Gives a char matrix
YR          % lower triangular part of matrix. Implicitly print

Mathematica, 29 Bytes

#<>#2&~FoldList~Characters@#&

TODO: Erklärung

𝔼𝕊𝕄𝕚𝕟, 7 Zeichen / 16 Bytes

ᴉⓜᵖ ᵴ˖$

Try it here (Firefox only).

Es gibt wahrscheinlich irgendwo eine eingebaute Lösung dafür - ich habe sie einfach nicht gefunden.

Erläuterung

ᴉⓜᵖ ᵴ˖$ // implicit: ᴉ=split input, ᵴ=empty string
ᴉⓜ      // map over ᴉ
   ᵖ ᵴ˖$ // push ᵴ+=(mapped item char)
         // implicit stack output, separated by newlines

Javascript ES6, 29 Bytes

(a,b='')=>[...a].map(x=>b+=x)

Das ist nichts zu gewinnen, aber es ist eine einfache Lösung.

Pyth, 11 Bytes

Vlz=k+k@zNk

Versuch es

Erläuterung

(z=input)
(k="")
V        for N in Range(
lz       length of z):
=k+k@zN     k=k+z[N]
k           print(k)

Python, 32 Bytes

f=lambda s:s and f(s[:-1])+" "+s

Rekursive Funktion, die eine durch Leerzeichen getrennte Zeichenfolge mit einem führenden Leerzeichen ausgibt.

Ein 34-Byte-Programm (Python 2):

s=""
for c in input():s+=c;print s

V , 5 Bytes (nicht konkurrierend)

òÄ$xh

Probieren Sie es online!

Diese Sprache ist neuer als die Herausforderung und macht diese Antwort nicht konkurrierend. Erläuterung:

ò       " Recursively:
 Ä      "   Duplicate this line
  $     "   Move to the end of this line
   x    "   Delete one character
    h   "   Move one character to the right, which will throw an error when the line is one character long

PowerShell v2 +, 28 Byte

[char[]]$args[0]|%{($o+=$_)}

Nimmt Eingaben auf $args[0], charwandelt sie als -array um und leitet die Zeichen in eine Schleife |%{...}. Jede Iteration wird $oüber +=das aktuelle Zeichen akkumuliert $_. Dieser Ausdruck ist in Parens eingekapselt, sodass eine Kopie in die Pipeline eingefügt wird. Am Ende der Ausführung wird die Pipeline Write-Outputgeleert, wodurch eine neue Zeile zwischen den Elementen eingefügt wird.

PS C:\Tools\Scripts\golfing> .\spell-out-the-revua "נחמן"
נ
נח
נחמ
נחמן

PS C:\Tools\Scripts\golfing> .\spell-out-the-revua "PPCG"
P
PP
PPC
PPCG

PHP, 59 Bytes

for(;$i++<mb_strlen($argn);)echo"\n".mb_substr($argn,0,$i);

Online Version

Unerwünscht, unnötig, opportunistisch , 9 Bytes

E<+S0;*P