Résumé

Un nouveau langage de manipulation de chaînes a été créé, utilisant uniquement les caractères $+#-!*|@>! Votre tâche consiste à implémenter un interpréteur pour cela en aussi peu d'octets que possible.

Contribution

Une chaîne, qui est une seule ligne de cette langue. Cela peut être pris de toute manière raisonnable (stdin, paramètre de fonction, argument de ligne de commande, etc.), ou en tant que variable prédéfinie. Si le programme demande une entrée utilisateur, acceptez toutes les entrées utilisateur qu'il demande à stdin et rien de plus, voir ci-dessous. Vous pouvez supposer qu'il s'agit d'un programme valide.

Production

Quelle que soit la langue produite, les spécifications ci-dessous. Vous devez sortir une chaîne, de toute manière raisonnable (sortie standard, sortie de fonction, etc.) ou une valeur variable. Lorsque le langage sort explicitement, cela doit aller à stdout. Les failles standard sont interdites.

Spécifications linguistiques

Traitement et syntaxe

Le langage a une forme de traitement très simple car il ne fait que manipuler des chaînes: il commence par une chaîne vide ( ""), et la change à chaque terme. Un terme est composé d'une ou deux parties: une fonction (ci-dessous) suivie éventuellement d'un paramètre (ci-dessous), qui modifie son comportement. Les termes sont séparés par des tuyaux ( |). Vous pouvez supposer qu'il ne s'agira pas d'un programme vide et qu'aucun terme ne sera vide. Vous devez sortir la valeur à la fin du programme.

Les fonctions

La langue n'a que 6 fonctions, comme indiqué ci-dessous. Chaque fonction accepte un ou zéro paramètre.

• + concaténer des chaînes (prend un paramètre de chaîne, le concatène à la valeur actuelle)
• ! inverser l'ordre des caractères de la valeur actuelle (pas de paramètre)
• * répéter la chaîne (prend un paramètre entier, répète la valeur actuelle autant de fois)
• - supprime toutes les occurrences d'une valeur (prend un paramètre de chaîne, en supprime toutes les occurrences de la valeur actuelle)
• $ [pseudo-] mélange aléatoirement la valeur actuelle (aucun paramètre)
• <sortie de la valeur actuelle vers stdout(pas de paramètres)

Valeurs

Ce sont les valeurs qui peuvent être transmises aux fonctions, représentées par des expressions rationnelles qui leur correspondraient:

• @[^|]*un littéral de chaîne, y compris tout caractère autre que des tuyaux. Il peut être vide.
• #[0-9]+ un littéral entier
• >la ligne suivante de stdin. Si utilisé avec *, convertissez en entier.

Cas de test

╔════════════════════════╤═════════════╤══════════════╗
║code                    │input        │output        ║
╟────────────────────────┼─────────────┼──────────────╢
║+>|!|+@hello|*>         │13           │31hello31hello║
║                        │2            │              ║
╟────────────────────────┼─────────────┼──────────────╢
║+>|+@abcdefg|$          │hello        │hcloeebafdlg  ║
╟────────────────────────┼─────────────┼──────────────╢
║+@how areyou|-@o|->     │w            │h areyu       ║
╟────────────────────────┼─────────────┼──────────────╢
║+@out|<|*#3             │             │out           ║
║                        │             │outoutout     ║
╟────────────────────────┼─────────────┼──────────────╢
║+>                      │what ever 345│what ever 345 ║
╟────────────────────────┼─────────────┼──────────────╢
║+@$pe<i@l|<|-@$pe<i@l|+>│A|$o $pe<!@| │$pe<i@l       ║
║                        │             │A|$o $pe<!@|  ║
╟────────────────────────┼─────────────┼──────────────╢
║<|+>|!|<                │input text   |              ║
║                        │             │txet tupni    ║ 
║                        │             │txet tupni    ║
╟────────────────────────┼─────────────┼──────────────╢
║+@>#                    │             |>#            ║
╚════════════════════════╧═════════════╧══════════════╝

Notez que le cas de test 2 est aléatoire, donc toute permutation des caractères qu'il contient est valide. De plus, les sorties du tableau sont séparées par des sauts de ligne, mais votre programme n'a pas à faire de même. La dernière valeur dans chaque cas est la sortie finale.

Exemple (non-golfé) d'interpréteur python

Essayez-le en ligne! IMO mieux si vous l'exécutez via IDLE ou tout ce que vous utilisez. (Je l'ai joué à 424 octets après, mais je suis sûr que vous pouvez faire mieux).

Rubis -palF\| , 146 142 octets

r='';$F.map{|i|x=i[1]!=?>?i[2..-1]:gets.chomp;eval %w[r.reverse! r*=x.to_i 0 $><<r r=r.chars.shuffle*'' r.gsub!x,'' r+=x][i[0].ord*5%11]};$_=r

Essayez-le en ligne!

Réponse de Python de Port Brown . N'imprime pas les retours à la ligne après la sortie.

Comme d'habitude, la version Ruby 2.6 sera plus courte de 2 octets avec une indexation de plage infinie ( i[2..]).

R , 287 286 273 269 ​​octets

function(C,x='',`[`=gsub,`!`=intToUtf8,`?`=utf8ToInt){for(k in el(strsplit(C,'\\|'))){B=eval(parse(t='^.'['','(?<=.)>$'['readLines(,1)','[@#](.+)'['"\\1"',k],,T]]));x=switch((?substr(k,1,1))%%13-2,strrep(x,B),paste0(x,B),,B['',x,f=T],!rev(?x),print(x),,!sample(?x))};x}

Essayez-le en ligne!

• -1 grâce à @Kirill L.
• -4 merci à @Giuseppe

Code déroulé et explication:

function(C){                                      # C is the string manipulation expression
  x = ''                                          # initialize x = ''
  tokens = el(strsplit(C,'\\|'))                  # split C by pipe '|'
  for(k in tokens){                               # for each token k
    arg2 = k
    arg2 = gsub('[@#](.+)','"\\1"',k)             # replace @X or #X with "X" (in quotes)
    arg2 = gsub('(?<=.)>$','"readLines(,1)"',
                 arg2,perl=T)                     # replace > with readLines(,1)
    arg2 = gsub('^.','',arg2)                     # remove the first character
    B = eval(parse(t=arg2))                       # evaluate the string : this will be our 
                                                  # second argument B
    A = substr(k,1,1)                             # take the first character : 
                                                  # i.e. the main command (+,-,! etc)
    x = switch(A,                                 # switch on the main command, execute the 
            '+'=paste0(x,B),                      # corresponding expression and 
            '!'=intToUtf8(rev(utf8ToInt(x))),     # store the result into x
            '*'=strrep(x,B),                      # Note: in the actual code we switch on
            '-'=B['',x,f=T],                      # the utf8 value MOD 13-2 of the command
            '$'=intToUtf8(sample(utf8ToInt(x))),
            '<'=print(x)
        )
    }
    x                                             # return x (and print it implicitly)
}

Python 2 , 215 219 209 208 octets

from random import*
I=raw_input;o=''
for t in I().split('|'):p=t[1:]=='>'and I()or t[2:];exec"o=o[::-1] o*=int(p) 0 print(o) o=''.join(sample(o,len(o))) o=o.replace(p,'') o+=p".split()[ord(t[0])*5%11]
print o

Essayez-le en ligne!

-4 car raw_inputest requis.

9 octets grâce à Incarnation de l'ignorance ; 1 octet d' Asci uniquement .

C # (Visual C # Interactive Compiler) , 305 octets

a=>{string s="",d,g;foreach(var c in a.Split('|')){g=$"{c,2}";d=g[1]==62?ReadLine():g.Substring(2);var z=c[0]%14;s=z<1?string.Concat(Enumerable.Repeat(s,int.Parse(d))):z<2?s+d:z<4?s.Replace(d,""):z<5?s:z<6?string.Concat(s.Reverse()):string.Concat(s.OrderBy(_=>Guid.NewGuid()));Write(z==4?s:"");}return s;}

Essayez-le en ligne!

Perl 5 -MList::Util=shuffle -pF/\|/ , 220 217 210 183 octets

map{$,=s/..//r;$\=reverse$\if/^!/;$,ne""||chomp($,=<>),$\=~s/\Q$,//g if/^-/;say$\if/^</;$\=join"",shuffle$\=~/./g if/^\$/;$\.=$,eq""?<>=~s/\n//r:$,if/^\+/;$\x=$,eq""?<>:$,if/^\*/}@F}{

Essayez-le en ligne!

Javascript, 292 267 octets

f=(p)=>{c='';p.split`|`.map(l=>{v=l.substr(2);v=l[1]=='#'?parseInt(v):l[1]=='>'?prompt():v;c={'+':_=>c+v,'-':_=>c.split(v).join``,'*':_=>c.repeat(v),'$':_=>[...c].sort(_=>.5-Math.random()).join``,'!':_=>[...c].reverse().join``,'<':_=>alert(c)||c}[l[0]]();});return c}

JSFiddle