Na verdade, não é inspirado nem pelos auto-palindromes de Atbash nem pela Calculadora Gematria Generalizada .

Dada uma sequência s de comprimento n , imprima a sequência Revu'a , que é o primeiro caractere de s , os dois primeiros caracteres de s , ... os primeiros n –2 caracteres de s , os primeiros n –1 caracteres de s , todo o s .

A cadeia de caracteres consistirá apenas em caracteres Unicode (qualquer codificação que você desejar) que tenham forte direcionalidade e sejam encontrados no intervalo de 0x0000 a 0xFFFF. No entanto, nenhum caractere de controle de direcionalidade ocorrerá. Todos os caracteres em qualquer sequência de caracteres terão a mesma direcionalidade.

Você pode retornar em notação de matriz ["t","te","tes","test"], como uma sequência separada por espaço "t te tes test", como texto de várias linhas
t
te
tes
test
, uma matriz pré-formatada

t
te
tes
teste

A entrada da direita para a esquerda deve resultar na saída da direita para a esquerda na ordem correta:
Entrada: "נחמן"
Saída: "נ נח נחמ נחמן"ou

נ
נח
נחמ
נחמן

Dyalog APL, 2 bytes

,\

Redução cumulativa concatenada. Experimente aqui .

A formatação da saída é melhor quando você prefixa a⍕ , mas mostra claramente a ordem correta sem.

JavaScript (ES6), 27 26 25 bytes

Salvo um byte graças a @nicael e @ MartinBüttner, um graças a @Neil

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

Aproveita alguns recursos internos da .replacefunção do JS . Especificamente, na substituição, $`torna-se tudo o que precede o caractere correspondente. Usar a regex em /.?/gvez de /./gsignifica que ela também corresponde à sequência vazia no final.

Japt, 10 4 bytes

Não percebi que uma redução cumulativa seria tão útil nesse caso. :-)

UŒ+

Saídas como uma matriz, separadas por vírgula por padrão. Se isso não for permitido, use este código de 6 bytes:

U¬å+ ·

Experimente online!

Como 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

Meu console não suporta caracteres da direita para a esquerda, mas não acho que funcione: 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

A saída é separada por espaço, com um espaço à esquerda e um avanço de linha à direita.

Experimente online!

Python, 35

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

Não foi possível encontrar uma maneira and/orde simplificar a recursão porque[] é falso.

Solução recursiva, retorna uma lista de seqüências de caracteres.

Experimente online

Prolog (SWI), 60 49 bytes

Código:

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

Explicado:

atom_prefix com X definido para entrada e S como uma variável fornece 1 prefixo do átomo X começando com o átomo vazio.

findall obtém todas as soluções e as coloca em uma lista.

[_ | R] joga fora a cabeça (o átomo vazio) e armazena a cauda em R

Exemplos:

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

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

Experimente online aqui

Edit: salvo 11 bytes de apenas armazenar a cauda em R .

Pitão, 3

._z

O prefixo interno faz o truque.

Suíte de teste

GNU Sed, 21

A pontuação inclui +1 para a -Eopção sed:

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

Funciona para LTR, mas não RTL - eu perdi esse pedaço. . Na verdade ele faz o trabalho, a RTL não estava prestando corretamente no meu terminal. Funciona bem com IO visualizado em um editor de texto sensato (por exemplo, emacs). Também funciona em Ideone:

Experimente online.

Braquilog , 5 bytes (Não concorrente)

@[@w\

Experimente online!

Explicação

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

As cordas da direita para a esquerda parecem funcionar corretamente, mesmo que eu nunca as tenha considerado.

CJam, 9 bytes

l{N2$@+}*

A saída é separada por avanço de linha.

Teste aqui.

Explicação

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

O princípio é mapear e gerar a fatia de string do primeiro caractere para cada caractere na palavra. Surpreendentemente, isso também funciona perfeitamente para as strings RTL, sem a necessidade de otimização.

Meu console não suporta caracteres da direita para a esquerda, mas não acho que funcione: c

C, 74 bytes (segunda entrada)

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

Meu console não suporta caracteres da direita para a esquerda, mas não acho que funcione: c

C, 105 bytes (terceira 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]);}

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

Não é tecnicamente válido: o TI-BASIC não suporta Unicode.

Nomeie isso prgmAe insira usando Ans.

A recursão do programa seria mais curta, mas não havia como inicializar as variáveis. Portanto, exibimos uma substring da entrada em cada iteração. A entrada nunca é substituída, pois Disp não retorna um valor.

Eventualmente, o programa termina com um erro após a impressão de toda a string.

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

Resposta anterior ( 95 bytes ):

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

Tentei uma abordagem recursiva, mas não consegui fazê-la funcionar. Talvez alguém o faça (mais curto que esse loop for).

Casos não testados e de teste:

Experimente aqui.

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

Resultado:

t
te
tes
test

נ
נח
נחמ
נחמן

Imersão , 1 byte (não concorrente)

E

Explicação:

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

MATL , 8 bytes

Usa a versão atual (8.0.0) do idioma / compilador

jtn1X"YR

Exemplo

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

Explicação

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: explicação

, 7 caracteres / 16 bytes

ᴉⓜᵖ ᵴ˖$

Try it here (Firefox only).

Provavelmente há um embutido para isso em algum lugar - simplesmente não o encontrei.

Explicação

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

Isso não está ganhando nada, mas é uma solução simples.

Pyth, 11 bytes

Vlz=k+k@zNk

Experimente

Explicação

(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

Função recursiva que gera uma cadeia de caracteres separada por espaço com um espaço à esquerda.

Um programa de 34 bytes (Python 2):

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

V , 5 bytes (não concorrente)

òÄ$xh

Experimente online!

Esse idioma é mais novo que o desafio, tornando essa resposta não competitiva. Explicação:

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

Recebe entrada $args[0], lança como um chararray, canaliza os caracteres em um loop |%{...}. Cada iteração, acumulamos $oatravés +=do caractere atual $_. Essa expressão é encapsulada em parênteses, para que uma cópia seja colocada no pipeline. No final da execução, o pipeline é liberado através do Write-Outputqual coloca uma nova linha entre os 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);

Versão Online

Indesejável, desnecessário, oportunista , 9 bytes

E<+S0;*P