Ispirato dalla recente mania per un altro linguaggio a due personaggi, ;#

Intro

Secondo il consenso della comunità , le risposte accettabili su questo sito devono usare linguaggi di programmazione che, come minimo:

1. Può determinare se un numero naturale è primo
2. Può aggiungere due numeri naturali insieme
3. Può rappresentare un elenco / tupla di numeri, nonché un singolo numero

Ai fini di questa sfida, ignoreremo il n. 3. Pertanto, il linguaggio più semplice che potrebbe essere utilizzato su questo sito (ignorando il n. 3) avrebbe esattamente due comandi isPrimee add. Per facilità di interpretazione e conteggio dei byte, assegniamo isPrimea pe adda +. Quindi, abbiamo la nostra lingua +p,. La tua sfida è interpretare un po 'di +pcodice.

Comportamento

• +l' addistruzione prende due numeri, li aggiunge e genera il risultato
• pl' isPrimeistruzione accetta un singolo numero e viene emessa 1se è primo e 0se non lo è

Regole

• È necessario scrivere un programma / funzione che, data una stringa di caratteri, interpreta quella stringa come +pcodice. Puoi assumere input ben formati (solo +e pcaratteri).
• L'input è flessibile. È possibile considerare il programma come una stringa, una matrice di caratteri, una matrice intera di punti di codice, ecc. Anche l'input per il programma da interpretare è flessibile. È possibile inserire un array intero e utilizzare le voci durante l'esecuzione del programma oppure ciascuna istruzione ( +e p) può richiedere singolarmente l'input. Si può presumere che ci sarà abbastanza input per ogni istruzione. È garantito che l'input sia composto da numeri compresi tra 0 e 200 (ma i tuoi algoritmi dovrebbero teoricamente funzionare per qualsiasi input intero positivo).
• L'output è anche flessibile. Puoi stampare i risultati, restituirli come elenco, restituire una stringa che contiene tutti i risultati, ecc. Se stampato o restituito come stringa, l'output deve essere separato da un separatore coerente non a cifre, come una nuova riga, scheda, spazio o ,carattere. È possibile che si disponga di un separatore finale o di uno spazio bianco finale. Inoltre, pl'output può essere qualsiasi valore di verità o falsità, come definito dalla lingua in cui si sta lavorando, piuttosto che 1o 0.
• L'interprete può terminare o meno (se si tratta di un programma completo), ma deve interrompere la stampa dopo aver interpretato tutte le istruzioni. (Non può continuare a stampare il separatore per sempre, o un carattere null, ecc.).
• Queste scappatoie standard sono vietate per impostazione predefinita
• Questo è code-golf , la risposta con il minor numero di byte vince

Casi test

Program: +
Input: [56, 50]
Output: 106 
----------------------------------
Program: p
Input: [12]
Output: 0 
----------------------------------
Program: p
Input: [13]
Output: 1 
----------------------------------
Program: ++
Input: [172, 120, 33, 58]
Output: 292 91 
----------------------------------
Program: p
Input: [29]
Output: 1 
----------------------------------
Program: pp
Input: [176, 12]
Output: 0 0 
----------------------------------
Program: ++++p
Input: [32, 16, 69, 197, 73, 171, 21, 178, 72]
Output: 48 266 244 199 0 
----------------------------------
Program: pp+++p+pp+
Input: [151, 27, 119, 189, 198, 107, 174, 15, 166, 106, 134, 108, 169, 55, 42]
Output: 1 0 308 305 189 0 240 0 0 97 
----------------------------------
Program: p+p+++++++pp+p
Input: [143, 67, 30, 149, 178, 52, 112, 122, 55, 122, 142, 199, 20, 175, 138, 80, 116, 180, 50, 116, 15, 92, 74]
Output: 0 97 1 230 234 177 341 195 218 296 0 0 107 0 
----------------------------------
Program: ++p++p+pp+++++p+p+pp++
Input: [120, 177, 23, 116, 163, 52, 65, 98, 177, 16, 96, 131, 160, 48, 153, 0, 139, 33, 62, 49, 129, 86, 99, 135, 187, 80, 137, 130, 113, 136, 0, 1, 186, 100, 38, 153]
Output: 297 139 1 117 275 0 227 0 0 153 172 111 215 234 0 217 0 249 0 0 286 191 
----------------------------------
Program: ++p+++++p+p+++++++
Input: [181, 169, 6, 84, 68, 171, 129, 107, 106, 114, 197, 58, 11, 88, 156, 169, 43, 77, 49, 43, 102, 78, 93, 51, 91, 37, 64, 93, 82, 126, 181, 81, 44]
Output: 350 90 0 300 213 311 69 244 0 120 0 145 171 142 101 175 307 125 
----------------------------------
Program: ++p+
Input: [131, 127, 115, 40, 113, 196, 83]
Output: 258 155 1 279 
----------------------------------
Program: +ppp++p+ppp+p++++++++p+p+++pp+ppp++
Input: [6, 9, 187, 168, 96, 167, 178, 139, 86, 148, 99, 103, 166, 18, 119, 15, 132, 77, 16, 88, 139, 34, 58, 90, 43, 69, 68, 152, 59, 106, 134, 49, 155, 100, 52, 55, 27, 188, 41, 77, 23, 49, 171, 23, 193, 84, 111, 165, 80, 18, 63, 23, 116, 112, 119]
Output: 15 0 0 0 345 225 0 202 0 0 0 147 0 104 173 148 112 220 165 183 255 0 82 0 118 72 194 1 0 276 0 0 0 139 231 
----------------------------------
Program: ++++++++p++++++++++++
Input: [156, 5, 34, 25, 117, 98, 139, 131, 88, 82, 191, 13, 1, 170, 51, 116, 144, 85, 92, 170, 25, 94, 149, 131, 19, 161, 115, 160, 8, 6, 195, 101, 11, 185, 87, 50, 33, 140, 188, 135, 164]
Output: 161 59 215 270 170 204 171 167 0 177 195 243 150 276 168 201 112 272 83 328 299 
----------------------------------

Molti, molti, casi di test molto lunghi

Il codice java utilizzato per generare casi di test

Esempio

Di seguito è una funzione java non golfata che interpreterà +p:

public static void interpret(String program, int[] input) {
    int index = 0;
    for (char inst : program.toCharArray()) {
        switch (inst) {
            case '+':
                System.out.print((input[index++] + input[index++]) + " ");
                break;
            case 'p':
                int n = input[index++];
                System.out.print((isPrime(n) ? 1 : 0) + " ");
                break;
        }
    }
}

public static boolean isPrime(long n) { //Taken from /programming//a/2385999/4484294
    if (n < 2) return false;
    if (n == 2 || n == 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    long sqrtN = (long) Math.sqrt(n) + 1;
    for (long i = 6L; i <= sqrtN; i += 6) {
        if (n % (i - 1) == 0 || n % (i + 1) == 0) return false;
    }
    return true;
}

Nota: utilizzando la query di ricerca prime AND add AND interpret is:question, non sembrano esserci duplicati di questa domanda. Se ce n'è uno, scusa.

05AB1E , 5 byte

vy.V,

Provalo online!

Spiegazione

Questa sfida si adatta a 05AB1E come un guanto :)

vy      # for each instruction in the program
  .V    # execute as 05AB1E code
    ,   # print

Python 2, 135 133 byte

l,p=input()
i=j=0
while len(l)-i:print(int(all(l[i]%k for k in range(2,l[i])))if p[j]=='p'else l[i]+l[i+1]);i+=1+'p+'.find(p[j]);j+=1

-2 byte grazie a Kundor

Python 2 , 91 byte

p,i=input()
for c in p:n=i.pop(0);print all(n%k for k in range(2,n))if c>'+'else n+i.pop(0)

Provalo online!

Haskell, 88 79 byte

('+':r)!(a:b:c)=a+b:r!c
('p':r)!(a:c)=min(foldr((*).mod a)1[2..a-1])1:r!c
_!e=e

"commands" ! [args] per uso.

• Salvataggio di 9 byte grazie a @Laikoni (# 56433)

Sto ancora imparando Haskell; suggerimenti per il golf apprezzati!

Ruby 2.4, 77 + 7 = 84 byte

Usa la -rprimebandiera.

->g,i{g.chars.map{|c|c==?p?i.shift.prime?? 1:0: c==?+?i.shift(2).sum: p}-[p]}

Perl 6 , 70 byte

{@^b.rotor($^a.comb.map(1+(*ne'p'))).map({$_-2??.[0].is-prime!!.sum})}

Innanzitutto il rotormetodo viene utilizzato per dividere l'elenco di input in blocchi di dimensioni 1 o 2 a seconda che il carattere successivo del programma sia po meno. Quindi quella lista di pezzi viene mappata; i pezzi della dimensione 2 sono sommati e i pezzi della dimensione 1 hanno il loro unico elemento testato per la primalità.

Gelatina , 18 byte

ÆP,+/ị@L
OḂ‘Bṁ@Ç€K

Provalo online!

Soluzione alternativa, 18 byte

⁴Ḣ
¢+¢µ¢ÆPµḂ?
OÇ€K

Prova questo online!

C #, 130 129 byte

p=>d=>{var i=0;p.Any(c=>{Console.Write((c==43?d[i++]+d[i]:Enumerable.Range(2,d[i]-2).Any(x=>d[i]%x==0)?0:1)+" ");return++i<0;});}

Provalo online!

• 1 byte salvato salvando la funzione (grazie a Cyoce)

PowerShell 3+, 151 121 byte

$r,$v=$args;$p={0-notin((2..(($n=0+"$args")-1)|%{$n%$_}))};$i=0;$r|%{if($_-eq"p"){&p $v[$i]}else{$v[$i]+$v[($i+=1)]}$i++}

PowerShell non ha i primi incorporati, quindi ho dovuto implementare il mio. La mia prima versione è stata terribile e ho preso dalla maggior parte degli altri che testano 0 tra i risultati dei moduli, risparmiando molto. Anche sabbiato alcuni byte usando -notininvece di -notcontainsma significa che PowerShell v2 è fuori.

Spiegazione basata sui commenti

# $r is the program code. Assumed char array
# $v is the remaining variables in an assumed integer array.
$r,$v=$args
# Anonymous function to determine if a number is a prime or not.
# Test all potential factors. Check if any 0 modulus remainders are present
$p={0-notin((2..(($n=0+"$args")-1)|%{$n%$_}))}
# $i is an index for tracking location in $v
$i=0
# Cycle each of the instructions
$r|%{if($_-eq"p"){
        # Call the prime checking anonymous function on this number
        &p $v[$i]
    }else{
        # Add the next two numbers. Adjust the index accordingly. 
        $v[$i]+$v[($i+=1)]

    }
    # Next number in list. 
    $i++  
}
    # Next number in list. 
    $i++  
}

F #, 130 byte

let rec r=function|[],_->()|'+'::t,f::s::u->printf"%i "(f+s);r(t,u)|_::t,n::u->printf"%b "(List.exists((%)n>>(=)0)[2..n-1]);r(t,u)

Provalo online!

QBasic, 122 byte

INPUT p$
FOR i=1TO LEN(p$)
INPUT x
IF"+"=MID$(p$,i,1)THEN INPUT y:?x+y:ELSE f=0:FOR j=2TO x:f=f-(x MOD j=0):NEXT:?f=1
NEXT

Prende il codice come una riga di input, quindi accetta ogni numero di input sulla propria riga. Gli output sono intervallati dagli input perché vengono stampati non appena vengono calcolati. Il valore di verità è -1; falso è 0.