En fait, il n'est inspiré ni par Atbash Self Palindromes ni par Generalized Gematria Calculator .

Étant donné une chaîne s de longueur n , affichez la séquence Revu'a , qui est le premier caractère de s , les deux premiers caractères de s , ... les premiers n –2 caractères de s , les premiers n –1 caractères de s , l'ensemble de l' art .

La chaîne sera uniquement composée de caractères Unicode (tout encodage que vous souhaitez) qui ont une forte directivité et se trouvent dans la plage 0x0000 à 0xFFFF. Cependant, aucun caractère de contrôle de directionnalité ne se produira. Tous les caractères d'une chaîne donnée auront la même directionnalité.

Vous pouvez retourner en notation de tableau ["t","te","tes","test"], sous forme de chaîne séparée par des espaces "t te tes test", sous forme de texte sur plusieurs lignes
t
te
tes
test
, un tableau pré-formaté

t
te
tes
tester

L'entrée de droite à gauche doit entraîner une sortie de droite à gauche dans le bon ordre:
Entrée: "נחמן"
Sortie: "נ נח נחמ נחמן"ou

נ
נח
נחמ
נחמן

Dyalog APL, 2 octets

,\

Réduction cumulative par concaténation. Essayez-le ici .

Le formatage de la sortie est plus agréable lorsque vous préfixez a⍕ , mais il montre clairement le bon ordre sans.

JavaScript (ES6), 27 26 25 octets

Un octet enregistré grâce à @nicael et @ MartinBüttner, un grâce à @Neil

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

Profite de certaines fonctionnalités intégrées de la fonction de JS .replace. Plus précisément, dans le remplacement, $`devient tout ce qui précède le caractère correspondant. Utiliser l'expression régulière /.?/gplutôt que /./gsignifie qu'il correspond également à la chaîne vide à la fin.

Japt, 10 4 octets

Je ne savais pas qu'une réduction cumulative serait si utile dans ce cas. :-)

UŒ+

Sorties sous forme de tableau, séparées par des virgules par défaut. Si cela n'est pas autorisé, utilisez plutôt ce code à 6 octets:

U¬å+ ·

Essayez-le en ligne!

Comment ça fonctionne

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

Ma console ne prend pas en charge les caractères de droite à gauche, mais je ne pense pas que cela fonctionnera: c

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

Non 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
]

Rétine, 11 7 octets

.
 $`$0

La sortie est séparée par des espaces, avec un espace de début et un saut de ligne de fin.

Essayez-le en ligne!

Python, 35

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

Impossible de trouver un moyen d'utiliser and/orpour simplifier la récursivité car[] c'est une fausse.

Solution récursive, retourne une liste de chaînes.

Essayez-le en ligne

Prolog (SWI), 60 49 octets

Code:

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

Expliqué:

atom_prefix avec X réglé sur input et S comme variable donne 1 préfixe de l'atome X commençant par l'atome vide.

findall obtient toutes les solutions et les met dans une liste.

[_ | R] jette la tête (l'atome vide) et stocke la queue dans R

Exemples:

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

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

Essayez-le en ligne ici

Edit: enregistré seulement 11 octets par le stockage de la queue dans R .

Pyth, 3

._z

Le préfixe intégré fait l'affaire.

Suite de tests

GNU Sed, 21 ans

Le score inclut +1 pour l' -Eoption de séduction:

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

Fonctionne pour LTR, mais pas RTL - j'ai raté ce bit. . En fait , il fait le travail, le RTL était tout simplement pas le rendu correctement dans mon terminal. Cela fonctionne très bien avec IO vu dans un éditeur de texte sensible (par exemple emacs). Il fonctionne également dans Ideone:

Essayez-le en ligne.

Brachylog , 5 octets (non concurrent)

@[@w\

Essayez-le en ligne!

Explication

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

Les chaînes de droite à gauche semblent fonctionner correctement, même si je ne les ai même pas considérées.

CJam, 9 octets

l{N2$@+}*

La sortie est séparée par un saut de ligne.

Testez-le ici.

Explication

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 octets

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

Démo:

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

Le principe est de mapper et de sortir la tranche de chaîne du premier caractère à chaque caractère du mot. Étonnamment, cela fonctionne également parfaitement pour les chaînes RTL, aucune optimisation n'est nécessaire.

Ma console ne prend pas en charge les caractères de droite à gauche, mais je ne pense pas que cela fonctionnera: c

C, 74 octets (2e entrée)

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

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

Ma console ne prend pas en charge les caractères de droite à gauche, mais je ne pense pas que cela fonctionnera: c

C, 105 octets (3ème entrée)

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

Non 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 octets

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

Non valide sur le plan technique: TI-BASIC ne prend pas en charge Unicode.

Nommez ceci prgmAet saisissez en utilisant Ans.

La récursivité du programme serait plus courte, mais il n'y aurait aucun moyen d'initialiser les variables. Par conséquent, nous affichons une sous-chaîne de l'entrée à chaque itération. L'entrée n'est jamais écrasée, car Disp ne renvoie pas de valeur.

Finalement, le programme se termine avec une erreur après avoir imprimé la chaîne entière.

Python, 54 octets

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

Java 7, 95 92 octets

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

Réponse précédente ( 95 octets ):

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

J'ai essayé une approche récursive, mais je n'ai pas vraiment réussi à la faire fonctionner. Peut-être que quelqu'un d'autre le fera (plus court que cette boucle for).

Cas non testés et testés:

Essayez-le ici.

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

Production:

t
te
tes
test

נ
נח
נחמ
נחמן

Dip , 1 octet (non concurrent)

E

Explication:

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

MATL , 8 octets

Utilise la version actuelle (8.0.0) du langage / compilateur

jtn1X"YR

Exemple

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

Explication

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 octets

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

TODO: explication

𝔼𝕊𝕄𝕚𝕟, 7 caractères / 16 octets

ᴉⓜᵖ ᵴ˖$

Try it here (Firefox only).

Il y a probablement une fonction intégrée quelque part - je ne l'ai tout simplement pas trouvée.

Explication

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

Javascript ES6, 29 octets

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

Cela ne gagne rien, mais c'est une solution simple.

Pyth, 11 octets

Vlz=k+k@zNk

Essaye le

Explication

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

Python, 32 octets

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

Fonction récursive qui génère une chaîne séparée par des espaces avec un espace de début.

Un programme de 34 octets (Python 2):

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

V , 5 octets (non concurrent)

òÄ$xh

Essayez-le en ligne!

Cette langue est plus récente que le défi, ce qui rend cette réponse non compétitive. Explication:

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

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

Prend des entrées $args[0], les chartransforme en tableau, redirige les personnages en boucle |%{...}. À chaque itération, nous nous accumulons $ovia +=le personnage actuel $_. Cette expression est encapsulée dans des parens donc une copie est placée sur le pipeline. En fin d'exécution, le pipeline est vidé via Write-Outputce qui met une nouvelle ligne entre les éléments.

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 octets

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

Version en ligne

Indésirable, inutile, opportuniste , 9 octets

E<+S0;*P