In realtà non ispirato né da Atbash Self Palindromes né dal calcolatore generalizzato Gematria .

Data una stringa s di lunghezza n , genera la sequenza Revu'a , che è il primo carattere di s , i primi due caratteri di s , ... i primi n -2 caratteri di s , i primi n -1 caratteri di s , l'intero s .

La stringa sarà composta solo da caratteri Unicode (qualsiasi codifica desiderata) che hanno una forte direzionalità e si trovano nell'intervallo compreso tra 0x0000 e 0xFFFF. Tuttavia, non si verificheranno caratteri di controllo della direzionalità. Tutti i caratteri di una determinata stringa avranno la stessa direzionalità.

È possibile restituire in notazione di matrice ["t","te","tes","test"], come una stringa separata da spazio "t te tes test", come testo a più righe
t
te
tes
test
, una matrice preformattata

t
TE
TES
test

L'ingresso da destra a sinistra deve generare l'uscita da destra a sinistra nell'ordine corretto:
Ingresso: "נחמן"
Uscita: "נ נח נחמ נחמן"o

נ
נח
נחמ
נחמן

Dyalog APL, 2 byte

,\

Riduzione cumulativa del concatenato. Provalo qui .

La formattazione dell'output è più piacevole quando si antepone a⍕ , ma mostra chiaramente l'ordine corretto senza.

JavaScript (ES6), 27 26 25 byte

Salvato un byte grazie a @nicael e @ MartinBüttner, uno grazie a @Neil

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

Sfrutta alcune funzionalità integrate della .replacefunzione di JS . Nello specifico, nella sostituzione, $`diventa tutto ciò che precede il personaggio abbinato. L'uso di regex /.?/ganziché /./gsignifica che corrisponde anche alla stringa vuota alla fine.

Japt, 10 4 byte

Non mi ero reso conto che una riduzione cumulativa sarebbe stata così utile in questo caso. :-)

UŒ+

Output come array, separati da virgola per impostazione predefinita. Se ciò non è consentito, utilizzare invece questo codice a 6 byte:

U¬å+ ·

Provalo online!

Come funziona

      // 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 byte

La mia console non supporta i personaggi da destra a sinistra, ma non credo che funzionerà: 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 byte

.
 $`$0

L'output è separato dallo spazio, con uno spazio iniziale e un avanzamento riga finale.

Provalo online!

Python, 35

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

Impossibile trovare un modo per utilizzare and/orper semplificare la ricorsione perché []è falsa.

Soluzione ricorsiva, restituisce un elenco di stringhe.

Provalo online

Prolog (SWI), 60 49 byte

Codice:

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

Ha spiegato:

atom_prefix con X impostato su input e S come variabile fornisce 1 prefisso dell'atomo X a partire dall'atomo vuoto.

findall ottiene tutte le soluzioni e le inserisce in un elenco.

[_ | R] butta via la testa (l'atomo vuoto) e memorizza la coda in R

Esempi:

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

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

Provalo online qui

Modifica: salva 11 byte memorizzando solo la coda in R .

Pyth, 3

._z

Il prefisso incorporato fa il trucco.

Test Suite

GNU Sed, 21

Score includes +1 for -E option to sed:

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

Works for LTR, but not RTL - I missed that bit.. Actually it does work, the RTL was just not rendering correctly in my terminal. It works fine with IO viewed in a sensible text editor (e.g. emacs). It also works in Ideone:

Try it online.

Brachylog, 5 bytes (Non-competing)

@[@w\

Try it online!

Explanation

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

Le stringhe da destra a sinistra sembrano funzionare correttamente, anche se non le ho mai considerate.

CJam, 9 byte

l{N2$@+}*

L'output è separato dall'alimentazione di linea.

Provalo qui.

Spiegazione

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 byte

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("נחמן")
)

Il principio è mappare e produrre la sezione di stringa dal primo carattere a ogni carattere della parola. Sorprendentemente, questo funziona perfettamente anche per le stringhe RTL, nessuna ottimizzazione necessaria.

La mia console non supporta i personaggi da destra a sinistra, ma non credo che funzionerà: c

C, 74 byte (2a voce)

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

La mia console non supporta i personaggi da destra a sinistra, ma non credo che funzionerà: c

C, 105 byte (3a voce)

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 byte

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

Tecnicamente non valido: TI-BASIC non supporta Unicode.

Nomina questo prgmAe inserisci usandoAns .

La ricorsione del programma sarebbe più breve, ma non ci sarebbe modo di inizializzare le variabili. Pertanto, visualizziamo una sottostringa dell'input ad ogni iterazione. L'input non viene mai sovrascritto, poiché Disp non restituisce un valore.

Alla fine, il programma termina con un errore dopo aver stampato l'intera stringa.

Python, 54 byte

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

Java 7, 95 92 byte

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

Risposta precedente ( 95 byte ):

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

Ho provato un approccio ricorsivo, ma non riuscivo davvero a farlo funzionare. Forse qualcun altro lo farà (più corto di questo for-loop).

Casi non testati e test:

Provalo qui.

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("נחמן"));
  }
}

Produzione:

t
te
tes
test

נ
נח
נחמ
נחמן

Dip , 1 byte (non competitivo)

E

Spiegazione:

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

MATL , 8 byte

Utilizza la versione corrente (8.0.0) di lingua / compilatore

jtn1X"YR

Esempio

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

Spiegazione

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 byte

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

TODO: spiegazione

𝔼𝕊𝕄𝕚𝕟, 7 caratteri / 16 byte

ᴉⓜᵖ ᵴ˖$

Try it here (Firefox only).

There's probably a builtin for this somewhere - I just haven't found it.

Explanation

ᴉⓜᵖ ᵴ˖$ // 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)

This ain't winning anything, but it's a simple solution.

Pyth, 11 Bytes

Vlz=k+k@zNk

Try It Out

Explanation

(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

Recursive function that outputs a space-separated string with a leading space.

A 34-byte program (Python 2):

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

V, 5 bytes (non-competing)

òÄ$xh

Try it online!

This language is newer than the challenge, making this answer non-competing. Explanation:

ò       " 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 bytes

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

Takes input $args[0], casts it as a char-array, pipes the characters into a loop |%{...}. Each iteration, we accumulate onto $o via += the current character $_. That expression is encapsulated in parens so a copy is placed on the pipeline. At end of execution, the pipeline is flushed via Write-Output which puts a newline between elements.

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

Unwanted, Unnecessary, Opportunistic, 9 bytes

E<+S0;*P