Transformez lentement une chaîne en une autre

31

Le défi

Étant donné deux chaînes / un tableau de chaînes, sortez la première chaîne en rétrécissant lentement et en la développant à nouveau dans la deuxième chaîne.

Vous pouvez supposer que les chaînes commenceront toujours par le même caractère.

Exemple

Input:
"Test", "Testing"

Output:
Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Vous sortez d'abord le premier mot:

Test

Ensuite, vous continuez à supprimer une lettre jusqu'à ce que la chaîne comporte un caractère:

Tes
Te
T

Continuez ensuite à ajouter une lettre du deuxième mot jusqu'à ce que ce soit fait:

Te
Tes
Test
Testi
Testin
Testing

(si les deux chaînes ont un caractère, il suffit d'en sortir une fois.)

Cas de test

"Hello!", "Hi."
Hello!
Hello
Hell
Hel
He
H
Hi
Hi.

"O", "O"

O

"z", "zz"

z
zz

".vimrc", ".minecraft"

.vimrc
.vimr
.vim
.vi
.v
.
.m
.mi
.min
.mine
.minec
.minecr
.minecra
.minecraf
.minecraft

"     ", "   "

SSSSS
SSSS
SSS
SS
S
SS
SSS

"0123456789", "02468"

0123456789
012345678
01234567
0123456
012345
01234
0123
012
01
0
02
024
0246
02468

(remarque: sur l'espace / quatrième cas de test, remplacez le S par des espaces)

Règles

  • C'est le golf de code , donc la réponse la plus courte en octets gagne! Tiebreaker est le poste le plus voté. Le gagnant sera choisi le 09/10/2016.

  • Les failles standard sont interdites.

code-golf  string 
— acrolithe
source
Est-ce que 2 sauts de ligne de fin (une ligne vide visible après la séquence) seront autorisés ou non?
— seshoumara

Réponses:

11

Pyth, 9 octets

j+_._Et._

Un programme qui prend la deuxième chaîne, puis la première chaîne, sous forme de chaînes entre guillemets sur STDIN et imprime le résultat.

Essayez-le en ligne

Comment ça marche

j+_._Et._  Program. Inputs: Q, E
   ._E     Yield prefixes of E as a list
  _        Reverse the above
       ._  Yield prefixes of Q as a list (implicit input fill)
      t    All but the first element of above
 +         Merge the two lists
j          Join on newlines
           Implicitly print
— TheBikingViking
source
14

V , 14 octets

òYp$xhòjòÄ$xhh

Essayez-le en ligne!

Explication:

ò     ò     "Recursively:
 Yp         "  Yank the current line and paste it
   $        "  Move to the end of the current line
    x       "  Delete one character
     h      "  Move One character to the right.
            "  Because of the way loops work in V, this will throw an error if there
            "  Is only one character on the current line.

Maintenant, le tampon ressemble à ceci:

0123456789
012345678
01234567
0123456
012345
01234
0123
012
01
0

Nous avons juste besoin de faire la même chose en sens inverse pour la ligne suivante:

j           "Move down one line
 ò     ò    "Recursively (The second ò is implicit)
  Ä         "  Duplicate this line up
   $        "  Move to the end of the current line
    x       "  Delete one character
     hh     "  Move two characters to the right.
            "  Because of the way loops work in V, this will throw an error if there
            "  Is only two characters on the current line.

Solution alternative plus intéressante :

òÄ$xhòç^/:m0
ddGp@qd
— DJMcMayhem
source
3
C'est comme si vim est toujours un bon outil pour le travail
— Downgoat
@Downgoat Exactement. C'est pourquoi vous devez commencer à jouer au golf en V.: P
— DJMcMayhem
9

Python, 93 octets

f=lambda a,b,r='',i=2:a and f(a[:-1],b,r+a+'\n')or(len(b)>=i and f(a,b,r+b[:i]+'\n',i+1)or r)

Commence par la chaîne vide r, ajoute aet une nouvelle ligne et supprime le dernier caractère de ajusqu'à ce qu'il asoit vide, puis ajoute les parties requises de bet une nouvelle ligne en gardant un compteur i, qui commence 2jusqu'à ce que la longueur de bsoit dépassée, puis revient r. A une nouvelle ligne de fin.

Tous les tests sont sur ideone

— Jonathan Allan
source
2 choses. 1) Je crois que vous avez mal compté les personnages et c'est en fait 93 et ​​2) Vous n'avez pas besoin de le dire r="". Simple rfonctionnerait toujours.
Merci @JackBates. 1. Correct et mis à jour - j'ai probablement oublié le f=. 2. Sans le r=''présent f('test','testing')ne fonctionnerait pas; oui f('test','testing',''), mais nous devons suivre les spécifications.
— Jonathan Allan
Pardonne-moi. Je regardais juste le code et non les exemples.
7

05AB1E , 9 octets

.pRI.p¦«»

Explication

.pR           # prefixes of first word
     I.p       # prefixes of second word
         ¦       # remove first prefix
          «     # concatenate
           »    # join with newlines

Essayez-le en ligne!

— Emigna
source
7

Rétine, 50 41 26 octets

Merci à Martin Ender d'avoir économisé 15 (!) Octets.

M&!r`.+
Om`^.¶[^·]+|.+
A1`

Prend la saisie avec les deux chaînes séparées par une nouvelle ligne:

Test
Testing

Essayez-le en ligne!

Explication

M&!r`.+

La première ligne génère les "étapes" des deux mots:

Testing
Testin
Testi
Test
Tes
Te
T
Test
Tes
Te
T

Mest pour le mode de correspondance, &considère les correspondances qui se chevauchent et !imprime les correspondances au lieu du nombre d'entre elles. La raison pour laquelle elle est inversée est l' roption de gauche à droite: le moteur commence à rechercher des correspondances à la fin de la chaîne et continue vers le début.

Om`^.¶[^·]+|.+

Cela obtient tout dans le bon ordre: il Ocontrôle toutes les correspondances de l'expression régulière suivante: un personnage sur sa propre ligne et chaque caractère (y compris les nouvelles lignes) après, qui correspond à la seconde moitié entière comme un bloc, ou sinon une ligne de caractères , qui correspond à chaque ligne individuelle. Ces correspondances sont ensuite triées par point de code, donc le T suivi de la nouvelle ligne va en premier, suivi des lignes, croissant par la longueur.

A1`

Maintenant, nous avons juste cette première ligne de caractères en haut, donc nous utilisons le Amode ntigrep pour rejeter la première correspondance de l'expression régulière par défaut .+.

Ancienne version

M&!r`.+
O`\G..+¶
s`(.*)¶.¶(.*)
$2¶$1
¶.$

Essayez cette version en ligne!

Explication

La première ligne est la même, alors voyez l'explication ci-dessus.

O`\G..+¶

Cela inverse les lignes de la première moitié (deuxième mot d'entrée). Il Orenseigne en fait les lignes et l'expression régulière limite les correspondances: il doit s'agir d'une ligne de deux caractères ou plus ( ..+) suivie d'une nouvelle ligne ( ) qui commence là où le dernier s'est arrêté ( \G). Dans l'exemple ci-dessus, le single Tau milieu ne correspond pas, donc rien après.

Te
Tes
Test
Testi
Testin
Testing
T
Test
Tes
Te
T

Nous avons maintenant les deux bons composants, mais dans le mauvais ordre.

s`(.*)¶.¶(.*)
$2¶$1

¶.¶correspond au seul T au milieu, dont nous n'avons pas besoin mais sépare les deux parties. Les deux (.*)capturent tout avant et après, y compris les nouvelles lignes grâce au smode en ligne unique. Les deux captures sont remplacées dans le bon ordre par une nouvelle ligne entre les deux.

Maintenant, nous avons terminé, à moins que les chaînes d'entrée ne comportent qu'un caractère, auquel cas l'entrée n'a pas changé. Pour se débarrasser du doublon, nous remplaçons ¶.$(lors de la dernière ligne de la chaîne un seul caractère) par rien.

— NinjaBearMonkey
source
4

Python 2, 88 82 octets

x,y=input(),input()
for i in x:print x;x=x[:-1]
s=y[0]
for i in y[1:]:s+=i;print s

Prend deux entrées, chacune entourée de guillemets.

Merci @JonathanAllan pour avoir sauvé quelques octets et signalé un bug.

— atlasologue
source
1
Pas besoin de l' len(x)en x=x[:len(x)-1]car fonctionne tranchage offset négatif - vous pouvez simplement écrire x=x[:-1]. Le seul problème est que votre code ne gérera pas " ", " "très bien le cas de test.
— Jonathan Allan
1
Vous pouvez supprimer le second input()et utiliser un format d'entrée comme"<str1>", "<str2>"
— LevitatingLion
Vous pouvez remplacer la deuxième ligne par for i in range(x):print x[-i:]et la quatrième ligne par for i in range(1,y):print y[:-i]. Pas sûr que cela fonctionnerait, cependant.
— clismique
4

Perl, 34 28 octets

Comprend +2pour-0n

Exécutez avec les chaînes sur des lignes distinctes sur STDIN:

perl -M5.010 -0n slow.pl
Test
Testing
^D

slow.pl:

/(^..+|
\K.+?)(?{say$&})^/

Laissez le regex backtracking faire le travail ...

— Ton Hospel
source
3

Cheddar , 76 octets

(a,b,q=s->(|>s.len).map((_,i)->s.head(i+1)))->(q(a).rev+q(b).slice(1)).vfuse

Un peu plus longtemps que je ne l'aurais souhaité. Je vais ajouter une explication bientôt

Essayez-le en ligne!

— Downgoat
source
Que fait |>-il?
— Cyoce
@Cyoce unary |> est la plage [0, n) binaire est [a, b]
— Downgoat
3

Brachylog , 32 octets

:1aLtT,Lhbr:Tc~@nw
:2fb
~c[A:B]h

Essayez-le en ligne!

Explication

Brachylog n'a pas de préfixe intégré, donc nous obtiendrons les préfixes en utilisant concatenate(voir prédicat 2): un préfixe de Sis Psi Pconcaténé à Q(quoi que ce soit) entraîne S.

  • Prédicat principal:

    :1aL                  L is all prefixes of both elements of the input (see predicate 1)
   LtT,               T is the second element of L
       Lhbr           Remove the first prefix of the first list of L and reverse it
           :Tc        Concatenate with T
              ~@n     Join with newlines
                 w    Write to STDOUT

  • Prédicat 1:

    :2f                   Find all prefixes of the input string (see predicate 2)
   b                  Remove the first one (empty string)

  • Prédicat 2:

    ~c[A:B]               Input is the result of concatenating A to B
       h              Output is A
— Fataliser
source
3

Javascript, 103 81 octets

f=(x,y,n=1)=>x?`
`+x+f(x.slice(0,-1),y):n++<y.length?`
`+y.slice(0,n)+f(x,y,n):''

Exemple: f("Test", "Testing")

Sortie:

Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Réponse originale

f=(x,y,n=1)=>x?(console.log(x),f(x.slice(0,-1),y)):n++<y.length?(console.log(y.slice(0,n)),f(x,y,n)):''
— Hedi
source
3

Java, 188 179 octets

interface E{static void main(String[]a){int i=a[0].length();while(i>1)System.out.println(a[0].substring(0,i--));while(i<=a[1].length())System.out.println(a[1].substring(0,i++));}}

Mise à jour

  • Suppression de la variable s, sauvegarde de 9 octets

Non golfé :

interface E {

    static void main(String[] a) {
        int i = a[0].length();
        while (i > 1) {
            System.out.println(a[0].substring(0, i--));
        }
        while (i <= a[1].length()) {
            System.out.println(a[1].substring(0, i++));
        }
    }
}

Utilisation :

$ java E 'test' 'testing'
test
tes
te
t
te
tes
test
testi
testin
testing
— Master_ex
source
3

Haskell, 54 53 47 octets

t[]=[]
t x=x:t(init x)
(.reverse.t).(++).init.t

Exemple d'utilisation: ((.reverse.t).(++).init.t) "Hello" "Hi!"-> ["Hello","Hell","Hel","He","H","Hi","Hi!"].

De la magie sans point. C'est la même chose que f x y = (init(t x))++reverse (t y)où tfait une liste de toutes les sous-chaînes initiales, par exemple t "HI!"-> ["H","HI","HI!"].

— nimi
source
Hm, t=reverse.tail.inits?
— Bergi
@Bergi: bien sûr, mais a initsbesoin import Data.List.
— nimi
3

GNU sed, 57 45 + 2 (drapeaux rn) = 47 octets

:;1{/../p};2G;2h;s/.(\n.*)?$//;/./t;g;s/.$//p

Courir:

echo -e "Test\nTesting" | sed -rnf morphing_string.sed

L'entrée doit être les deux chaînes séparées par une nouvelle ligne. Le code est exécuté par sed pour chaque ligne.

La boucle :supprime un caractère de la fin de la chaîne de manière itérative. Le signal de sortie lié à la première chaîne de caractères est imprimée directement, à l' exception du premier caractère: 1{/../p}. La sortie de la deuxième chaîne est stockée dans l'espace d'attente dans l'ordre inverse ( 2G;2h) pendant la suppression et imprimée à la fin.

— seshoumara
source
3

C (gcc) , 102 97 95 93 octets

n;f(char*a,char*b){for(n=strlen(a);n;puts(a))a[n--]=0;for(a=b+1;*a++;*a=n)n=*a,*a=0,puts(b);}

Essayez-le en ligne!

La première boucle écrase la chaîne avec 0 octet à partir de la fin et utilise puts() pour imprimer la chaîne. La deuxième boucle ne peut pas simplement écraser depuis le début, elle doit stocker l'ancienne valeur pour pouvoir la remettre; l'octet 0 marche juste vers la fin.

Merci à @homersimpson et @ceilingcat pour chaque rasage de 2 octets!

— G. Sliepen
source
1
Vous pouvez enregistrer un couple d' octets en déclarant ncomme un int global comme: n;f(char*a,char*b){n=strlen(a).... Et vous pouvez probablement faire n=*a=0une affectation enchaînée dans le corps de votre boucle for.
— homersimpson
Merci @homersimpson. Mais n = * a = 0 n'est pas la même chose que n = * a, * a = 0.
— G. Sliepen du
2

Python 3, 104 octets

Meh.

n='\n';lambda x,y:x+n+n.join(x[:-i]for i in range(1,len(x)-1))+n+n.join(y[:i]for i in range(1,len(y)+1))

Merci à @DJMcMayhem d'avoir joué au golf à 21 octets.

Ideone ça!

— Beta Decay
source
1
Vous pouvez prendre 5 octets de si vous le faites n='\n'et utiliser n au lieu de '\n'. Vous pourriez retirer 8 de plus si vous n='\n';lambda x,y:n.join(x+n+n.join(x[:-i]for i in range(1,len(x)-1))+n+n.join(y[:i]for i in range(1,len(y)+1)))
— utilisiez
2

REPL / Javascript, 109 octets

Utilise une fausse chaîne pour réduire la chaîne d'origine

Abuse la sous-chaîne avec un plus grand nombre pour faire croître la seconde, s'arrête lorsqu'elle est sur le point d'imprimer le même mot que la dernière fois.

(a,b)=>{l=console.log;z='substring';for(c=a.length;d=a[z](0,c--);){l(d)}for(c=2;d!=(n=b[z](0,c++));){l(d=n)}}

Démo:

> ((a,b)=>{l=console.log;z='substring';for(c=a.length;d=a[z](0,c--);){l(d)}for(c=2;d!=(n=b[z](0,c++));){l(d=n)}})("asdf","abcd")
[Log] asdf
[Log] asd
[Log] as
[Log] a
[Log] ab
[Log] abc
[Log] abcd
— Vartan
source
1
c'est 1 octet plus court à faire a=>b=>...et appelez la fonction avec (a) (b)
— Zwei
2

Brainfuck, 38 55 octets

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

Modifier: inclus des sauts de ligne dans la sortie

— Jeff
source
Je n'arrive pas à faire fonctionner votre code. L'entrée est-elle séparée par une nouvelle ligne? Quel interprète utilisez-vous?
— acrolith
2

Dyalog APL , 20 13 octets

↑(⌽,\⍞),1↓,\⍞

↑ matrify

(⌽,\⍞)reverse ( ⌽) concaténation cumulative ( ,\) de l'entrée de caractères ( ⍞)

, préposé à

1↓ un élément abandonné

,\⍞ concaténation cumulative de la saisie de caractères

TryAPL en ligne!

— Adam
source
2

Raquette 193 octets

(define(f l)
(let*((s(list-ref l 0))
(x(string-length s)))
(for((n x))
(println(substring s 0(- x n))))
(set! s(list-ref l 1))
(for((n(range 1(string-length s))))
(println(substring s 0(add1 n))))))

Essai: 

(f(list "Test" "Testing"))

"Test"
"Tes"
"Te"
"T"
"Te"
"Tes"
"Test"
"Testi"
"Testin"
"Testing"


(f(list "Hello!" "Hi."))

"Hello!"
"Hello"
"Hell"
"Hel"
"He"
"H"
"Hi"
"Hi."
— rnso
source
Il doit supprimer le dernier caractère de la chaîne d'entrée, pas le premier.
— agilob
2

Floroid , 69 octets

a,b=L.J
c=1
NZ(a)!=1:z(a);a=a[:-1]
z(a)
NZ(a)!=Z(b):c+=1;a=b[:c];z(a)

C'est un début. Prend l'entrée de STDIN.

Testcases

Input: Test Testing
Output:
Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Input: O O
Output: O
— Yytsi
source
1

JavaScript (ES6), 92 octets

(s,t)=>s.replace(/./g,`
$\`$&`).split`
`.slice(2).reverse().join`
`+t.replace(/./g,`
$\`$&`)

Les replaceinstructions forment un triangle de chaînes, ce qui est exactement ce qui est requis pour la seconde moitié de la sortie, mais la première moitié doit être inversée et la ligne à un caractère en double supprimée. Remarque: génère une nouvelle ligne de début si la première chaîne est un seul caractère. Si cela n'est pas souhaitable, alors pour un octet supplémentaire, cette version génère toujours une nouvelle ligne de fin:

(s,t)=>s.replace(/./g,`
$\`$&\n`).split(/^/m).slice(1).reverse().join``+t.replace(/./g,`
$\`$&\n`)
— Neil
source
1

C, 142 octets

#define _(x,y) while(y)printf("%.*s\n",d,x-c);
f(char*a,char*b){int c=1,d=strlen(a)+1;while(*++a==*++b)c++;_(a,--d>=c)d++;_(b,d++<strlen(b-c))}

Fournir f(char* str1, char* str2).

— Keyu Gan
source
1

TI-Basic, 56 octets

Prompt Str1,Str2
Str1
While 1<length(Ans
Disp Ans
sub(Ans,1,length(Ans)-1
End
For(I,1,length(Str2
Disp sub(Str2,1,I
End

Exemple d'utilisation

Str1=?Test
Str2=?Testing
Test
Tes
Te
T
Te
Tes
Test
Testi
Testin
Testing

Str1=?O
Str2=?O
O

Str1=?z
Str2=?zz
z
zz
— Timtech
source
1

Java, 168 136 octets

(s,d)->{int i=s.length()+1;while(i-->1)System.out.println(s.substring(0,i));while(i++<d.length())System.out.println(d.substring(0,i));};

Programme de test non golfé

public static void main(String[] args) {

    BiConsumer<String, String> biconsumer = (s, d) -> {
        int i = s.length() + 1;
        while (i-- > 1) {
            System.out.println(s.substring(0, i));
        }
        while (i++ < d.length()) {
            System.out.println(d.substring(0, i));
        }
    };

    biconsumer.accept("Test", "Testing123");

}
— Shaun Wild
source
1

(Lambdabot) Haskell - 41 octets

f=(.drop 2.inits).(++).reverse.tail.inits

Plus lisible, mais deux octets de plus:

a!b=(reverse.tail$inits a)++drop 2(inits b)


Sortie:

f "Hello" "Hi!"
["Hello","Hell","Hel","He","H","Hi","Hi!"]
— BlackCap
source
1

J, 18 octets

]\@],~[:}:[:|.]\@[

Ungolfed:

]\@] ,~ [: }: [: |. ]\@[

Il s'agit d'un 7 trains:

]\@] ,~ ([: }: ([: |. ]\@[))

Le train le plus à l'intérieur se [: |. ]\@[compose d'un capuchon [:à gauche, nous appliquons donc |.(inverse) au résultat de ]\@[, qui est ]\(préfixes) sur[ (argument de gauche).

Voici à quoi cela ressemble sur l' testing, testentrée:

   'testing' ([: |. ]\@]) 'test'
test
tes
te
t

Cela nous donne presque la première partie. Le 5-train en dehors de cela est ([: }: ([: |. ]\@[)), ce qui s'applique }:(betail, supprimer le dernier élément) à l'expression ci-dessus:

   'testing' ([: }: [: |. ]\@]) 'test'
test
tes
te

(C'est parce que nous ne pouvons pas avoir de point médian en double.)

La partie extérieure est enfin:

]\@] ,~ ([: }: ([: |. ]\@[))

Il est composé de ]\@](préfixes de l'argument de gauche) et ,~(ajoutez ce qui est à gauche avec ce qui est à droite), nous laissant avec le résultat souhaité:

   'testing' (]\@] ,~ ([: }: ([: |. ]\@[))) 'test'
testing
testin
testi
test
tes
te
t
te
tes
test

Cas de test

   k =: ]\@] ,~ ([: }: ([: |. ]\@[))
   'o' k 'o'
o
   k~ 'o'
o
   'test' k 'test'
test
tes
te
t
te
tes
test
   k~ 'test'
test
tes
te
t
te
tes
test
   '. . .' k '...'
. . .
. .
. .
.
.
..
...
   'z' k 'zz'
z
zz
— Conor O'Brien
source
Vous pouvez le réorganiser à 14 octets en utilisant(,~}:@|.)&(]\)
— miles
1

PHP, 117 109 octets

for($i=strlen($a=$argv[1]);$i>1;)echo" ".substr($a,0,$i--);
for(;$j<strlen($b=$argv[2]);)echo" ".$c.=$b[$j++];


for($i=strlen($a=$argv[1]);$i>1;)echo substr($a,0,$i--)." ";
for(;$i<=strlen($b=$argv[2]);)echo substr($b,0,$i++)." ";

PHP, 107 octets (ne fonctionne pas avec des chaînes contenant 0)

for($a=$argv[1];$a[$i];)echo substr($a.a,0,-++$i)." ";
for($b=$argv[2];$b[$j];)echo substr($b,0,++$j+1)." ";
— Crypto
source
1

C, 111 octets

f(char*a, char*b){int l=strlen(a),k=1;while(*a){printf("%s\n",a);a[--l]=0;}while(b[k]) printf("%.*s\n",++k,b);}

Test non golfé

#include <stdio.h>
#include <string.h>

f(char*a, char*b) {
  int l=strlen(a), k=1;
  while(*a) {
    printf("%s\n",a);
    a[--l]=0;
  }
  while(b[k])
    printf("%.*s\n",++k,b);
}

int main() {
  char a[10] = {0};
  char b[10] = {0};

  for (int i=0; i<5; ++i) {
    a[i] = 'a' + i;
    b[i] = 'a' + i*2;
  }

  f(&(a[0]), &(b[0]));
}
— UKMonkey
source
1

brainfuck, 162 octets

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

Essayez-le ici

L'entrée prend les deux chaînes séparées par un saut de ligne.

Premier programme avec brianfuck et premier code golf, donc je suis sûr qu'il y a beaucoup d'optimisation à faire. Mais je me suis amusé à le faire.

Ungolfed

,[>,] Read all input
++++++++++ Flag for 10
[                   Subtract 10 from each cell to flag space for blank
    [-<]            
    >
        [->]
        <
]
++++++++++ Flag for 10
[                   Add 10 back to each cell with value in it
    <[+<]<[+<]
    >[+>]>[+>]<---
]
<[<]<[<]>               goto first cell in first string string      

[                           Print first word subtracting one each time
    [.>]                    Print first string
    ++++++++++.----------   Print new line
    <[-]                    Kill last letter of first string
    <                       Back one
    [                       Move each first string character up one
          [->+<]
          <
    ]>>
]
>[<+>-]>                    Move to first letter of scond string back one goto second letter
[                               
    [<+>-]                  Move next letter back
    <[<]>                   Move to start of string
    [.>]                    Print string
    ++++++++++.----------   Print new line
    >
]
— gtwebb
source
Bienvenue chez PPCG! Premier post impressionnant!
— Rɪᴋᴇʀ
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.