Sommario

È stato creato un nuovo linguaggio di manipolazione delle stringhe, usando solo i caratteri $+#-!*|@>! Il tuo compito è implementare un interprete per il minor numero di byte possibile.

Ingresso

Una stringa, che è una singola riga di questa lingua. Questo può essere preso in qualsiasi modo ragionevole (stdin, parametro di funzione, argomento della riga di comando ecc.) O come variabile predefinita. Se il programma richiede input utente, accetta tutti gli input utente richiesti da stdin e nient'altro, vedi sotto. Puoi presumere che sia un programma valido.

Produzione

Qualunque sia la lingua prodotta, le specifiche di seguito. È necessario generare una stringa, in qualsiasi modo ragionevole (stdout, output di funzione, ecc.) O un valore variabile. Quando la lingua viene emessa in modo esplicito, questo deve passare a stdout. Le scappatoie standard sono vietate.

Specifiche linguistiche

Elaborazione e sintassi

Il linguaggio ha una forma molto semplice di elaborazione in quanto esegue solo la manipolazione di stringhe: inizia con una stringa vuota ( "") e la modifica con ogni termine. Un termine è composto da una o due parti: una funzione (sotto) seguita eventualmente da un parametro (sotto), che modifica il suo comportamento. I termini sono separati da pipe ( |). Puoi presumere che non sarà un programma vuoto e nessun termine sarà vuoto. Dovresti emettere il valore alla fine del programma.

funzioni

La lingua ha solo 6 funzioni, come mostrato di seguito. Ogni funzione accetta uno o zero parametri.

• + concatena le stringhe (accetta un parametro stringa, lo concatena al valore corrente)
• ! inverti l'ordine dei caratteri del valore corrente (nessun parametro)
• * ripeti la stringa (accetta un parametro intero, ripete il valore corrente più volte)
• - rimuove tutte le occorrenze di un valore (accetta un parametro stringa, rimuove tutte le occorrenze di un valore dal valore corrente)
• $ [pseudo-] mescola casualmente il valore corrente (nessun parametro)
• <emette il valore corrente su stdout(nessun parametro)

Valori

Questi sono i valori che possono essere passati alle funzioni, rappresentati da regex che li corrisponderebbe:

• @[^|]*una stringa letterale, incluso qualsiasi carattere diverso da pipe. Potrebbe essere vuoto.
• #[0-9]+ un intero letterale
• >la riga successiva di stdin. Se utilizzato con *, converti in intero.

Casi 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    ║
╟────────────────────────┼─────────────┼──────────────╢
║+@>#                    │             |>#            ║
╚════════════════════════╧═════════════╧══════════════╝

Si noti che il caso di test 2 è casuale, quindi qualsiasi permutazione dei caratteri al suo interno è valida. Inoltre, gli output nella tabella sono separati da nuove righe, ma il tuo programma non deve fare lo stesso. L'ultimo valore in ogni caso è l'output finale.

Interprete python di esempio (senza golf)

Provalo online! IMO meglio se lo esegui tramite IDLE o qualunque cosa tu usi. (L'ho passato a golf a 424 byte dopo, ma sono sicuro che molto si può fare di meglio).

Rubino -palF\| , 146 142 byte

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

Provalo online!

La risposta di Python di Port of Chas Brown . Non stampa newline dopo l'output.

Come al solito, la versione 2.6 di Ruby sarà più corta di 2 byte con indicizzazione di intervallo infinito ( i[2..]).

R , 287 286 273 269 byte

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}

Provalo online!

• -1 grazie a @Kirill L.
• -4 grazie a @Giuseppe

Codice non spiegato e spiegazione:

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 byte

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

Provalo online!

-4 perché raw_inputè richiesto.

9 byte grazie a Embodiment of Ignorance ; 1 byte solo da Ascii .

C # (compilatore interattivo Visual C #) , 305 byte

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

Provalo online!

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

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

Provalo online!

Javascript, 292 267 byte

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