En realidad, no está inspirado ni por Atbash Self Palindromes ni por la Calculadora de Gematria generalizada .

Dada una cadena s de longitud n , genera la secuencia Revu'a , que es el primer carácter de s , los dos primeros caracteres de s , ... los primeros n –2 caracteres de s , los primeros n –1 caracteres de s , todo el s .

La cadena solo constará de caracteres Unicode (cualquier codificación que desee) que tengan una fuerte direccionalidad y se encuentren en el rango de 0x0000 a 0xFFFF. Sin embargo, no se producirán caracteres de control de direccionalidad. Todos los caracteres en cualquier cadena dada tendrán la misma direccionalidad.

Puede regresar en notación de matriz ["t","te","tes","test"], como una cadena separada por espacios "t te tes test", como texto de varias líneas
t
te
tes
test
, una matriz preformateada

t
te
tes
prueba

La entrada de derecha a izquierda debe dar como resultado una salida de derecha a izquierda en el orden correcto:
Entrada: "נחמן"
Salida: "נ נח נחמ נחמן"o

נ
נח
נחמ
נחמן

Dyalog APL, 2 bytes

,\

Reducción acumulativa por concatenar. Probarlo aquí .

El formato de la salida es más agradable cuando prefijas a⍕ , pero claramente muestra el orden correcto sin él.

JavaScript (ES6), 27 26 25 bytes

Guardado un byte gracias a @nicael y @ MartinBüttner, uno gracias a @Neil

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

Aprovecha algunas características integradas de la .replacefunción de JS . Específicamente, en el reemplazo, se $`convierte en todo lo que precede al carácter coincidente. Usar la expresión regular en /.?/glugar de /./gsignifica que también coincide con la cadena vacía al final.

Japt, 10 4 bytes

No me di cuenta de que una reducción acumulativa sería tan útil en este caso. :-)

UŒ+

Salidas como una matriz, separadas por comas por defecto. Si esto no está permitido, use este código de 6 bytes en su lugar:

U¬å+ ·

Pruébalo en línea!

Cómo funciona

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

Mi consola no admite caracteres de derecha a izquierda, pero no creo que funcione: c

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

Sin golf:

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

La salida está separada por espacios, con un espacio inicial y un avance de línea final.

Pruébalo en línea!

Python, 35

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

No se pudo encontrar una manera and/orde simplificar la recursión porque []es falsa.

Solución recursiva, devuelve una lista de cadenas.

Pruébalo en línea

Prólogo (SWI), 60 49 bytes

Código:

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

Explicado:

atom_prefix con X configurado como input y S como variable da 1 prefijo del átomo X que comienza con el átomo vacío.

Findall obtiene todas las soluciones y las coloca en una lista.

[_ | R] tira la cabeza (el átomo vacío) y almacena la cola en R

Ejemplos:

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

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

Pruébalo en línea aquí

Editar: salvó 11 bytes sólo almacenar la cola en R .

Pyth, 3

._z

El prefijo incorporado hace el truco.

Banco de pruebas

GNU Sed, 21

La puntuación incluye +1 para la -Eopción de sed:

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

Funciona para LTR, pero no para RTL: me perdí ese bit. . En realidad se hace el trabajo, la RTL fue simplemente no prestando correctamente en mi terminal. Funciona bien con IO visto en un editor de texto sensible (por ejemplo, emacs). También funciona en Ideone:

Pruébalo en línea.

Brachylog , 5 bytes (no competidor)

@[@w\

Pruébalo en línea!

Explicación

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

Las cadenas de derecha a izquierda parecen funcionar correctamente, aunque nunca las consideré.

CJam, 9 bytes

l{N2$@+}*

La salida está separada por salto de línea.

Pruébalo aquí.

Explicación

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

Manifestación:

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

El principio es asignar y generar la porción de cadena desde el primer carácter a cada carácter de la palabra. Sorprendentemente, esto también funciona perfectamente para las cadenas RTL, no se necesita optimización.

Mi consola no admite caracteres de derecha a izquierda, pero no creo que funcione: c

C, 74 bytes (2da entrada)

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

Sin golf:

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

Mi consola no admite caracteres de derecha a izquierda, pero no creo que funcione: c

C, 105 bytes (3ª entrada)

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

Sin golf:

#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

No es técnicamente válido: TI-BASIC no es compatible con Unicode.

Nombra esto prgmAy escribe usando Ans.

La recursividad del programa sería más corta, pero no habría forma de inicializar las variables. Por lo tanto, mostramos una subcadena de la entrada en cada iteración. La entrada nunca se sobrescribe, ya que Disp no devuelve un valor.

Finalmente, el programa termina con un error después de imprimir la cadena completa.

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

Respuesta anterior ( 95 bytes ):

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

Intenté un enfoque recursivo, pero realmente no pude hacerlo funcionar. Quizás alguien más lo hará (más corto que este for-loop).

Sin golf y casos de prueba:

Pruébalo aquí

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

Salida:

t
te
tes
test

נ
נח
נחמ
נחמן

Dip , 1 byte (no competidor)

E

Explicación:

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

MATL , 8 bytes

Utiliza la versión actual (8.0.0) del lenguaje / compilador

jtn1X"YR

Ejemplo

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

Explicación

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: explicación

𝔼𝕊𝕄𝕚𝕟, 7 caracteres / 16 bytes

ᴉⓜᵖ ᵴ˖$

Try it here (Firefox only).

Probablemente hay un lugar para esto en alguna parte, simplemente no lo he encontrado.

Explicación

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

Esto no gana nada, pero es una solución simple.

Pyth, 11 bytes

Vlz=k+k@zNk

Pruébalo

Explicación

(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

Función recursiva que genera una cadena separada por espacios con un espacio inicial.

Un programa de 34 bytes (Python 2):

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

V , 5 bytes (no competitivos)

òÄ$xh

Pruébalo en línea!

Este lenguaje es más nuevo que el desafío, lo que hace que esta respuesta no sea competitiva. Explicación:

ò       " 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+=$_)}

Toma datos $args[0], los charconvierte como una matriz, canaliza los caracteres en un bucle |%{...}. Cada iteración, acumulamos a $otravés +=del personaje actual $_. Esa expresión se encapsula en parens para que se coloque una copia en la tubería. Al final de la ejecución, la tubería se vacía mediante la Write-Outputcual se coloca una nueva línea entre los elementos.

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

Versión en línea

No deseado, innecesario, oportunista , 9 bytes

E<+S0;*P