Inspiré par l'engouement récent pour un autre langage à deux caractères, ;#

Intro

Selon le consensus de la communauté , les réponses acceptables sur ce site doivent utiliser des langages de programmation qui, au minimum:

1. Peut déterminer si un nombre naturel est premier
2. Peut additionner deux nombres naturels ensemble
3. Peut représenter une liste / tuple de nombres, ainsi qu'un seul nombre

Aux fins de ce défi, nous ignorerons le numéro 3. Par conséquent, le langage le plus simple qui pourrait être utilisé sur ce site (en ignorant # 3) aurait exactement deux commandes, isPrimeet add. Pour faciliter l'interprétation et le comptage d'octets, attribuons isPrimeà pet addà +. Ainsi, nous avons notre langue +p,. Votre défi est d'interpréter du +pcode.

Comportement

• +l' addinstruction prend deux nombres, les ajoute et génère le résultat
• pl' isPrimeinstruction prend un seul nombre et sort 1si elle est première et 0si elle n'est pas

Règles

• Vous devez écrire un programme / fonction qui, étant donné une chaîne de caractères, interprète cette chaîne comme du +pcode. Vous pouvez supposer une entrée bien formée (uniquement +et des pcaractères).
• L'entrée est flexible. Vous pouvez prendre le programme sous forme de chaîne, de tableau de caractères, de tableau entier de points de code, etc. L'entrée pour le programme en cours d'interprétation est également flexible. Vous pouvez prendre un tableau d'entiers et utiliser des entrées pendant l'exécution du programme, ou chaque instruction ( +et p) peut demander individuellement une entrée. Vous pouvez supposer qu'il y aura suffisamment d'entrées pour chaque instruction. L'entrée est composée de nombres compris entre 0 et 200 (mais vos algorithmes devraient théoriquement fonctionner pour toute entrée entière positive).
• La sortie est également flexible. Vous pouvez imprimer les résultats, les renvoyer sous forme de liste, renvoyer une chaîne contenant tous les résultats, etc. S'ils sont imprimés ou renvoyés sous forme de chaîne, la sortie doit être séparée par un séparateur cohérent non numérique, tel qu'une nouvelle ligne, tabulation, espace ou ,caractère. Vous pouvez avoir un séparateur de fin ou des espaces de fin. De plus, pla sortie de 'peut être n'importe quelle valeur truey ou falsey, telle que définie par la langue dans laquelle vous travaillez, plutôt que 1ou 0.
• L'interpréteur peut se terminer ou non (s'il s'agit d'un programme complet), mais il doit arrêter l'impression une fois que toutes les instructions ont été interprétées. (Il ne peut pas continuer à imprimer le séparateur indéfiniment, ou un caractère nul, etc.).
• Ces failles standard sont interdites par défaut
• C'est le code-golf , la réponse avec le moins d'octets gagne

Cas de 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 
----------------------------------

Beaucoup, beaucoup, très longs cas de test

Le code java utilisé pour générer des cas de test

Exemple

Ci-dessous, une fonction java non golfée qui interprétera +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;
}

Remarque: En utilisant la requête de recherche prime AND add AND interpret is:question, il ne semble pas y avoir de doublons à cette question. S'il y en a un, désolé.

05AB1E , 5 octets

vy.V,

Essayez-le en ligne!

Explication

Ce défi convient à 05AB1E comme un gant :)

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

Python 2, 135 133 bytes

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 octets grâce à kundor

Python 2 , 91 octets

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)

Essayez-le en ligne!

Haskell, 88 79 octets

('+':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] pour utilisation.

• 9 octets enregistrés grâce à @Laikoni (# 56433)

J'apprends toujours Haskell; conseils de golf appréciés!

Ruby 2.4, 77 + 7 = 84 octets

Utilise le -rprimedrapeau.

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

Perl 6 , 70 octets

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

Tout d'abord, la rotorméthode est utilisée pour diviser la liste d'entrée en morceaux de taille 1 ou 2 selon que le caractère suivant du programme l'est pou non. Ensuite, cette liste fragmentée est mappée; les morceaux de taille 2 sont additionnés, et les morceaux de taille 1 ont leur seul élément testé pour la primauté.

Gelée , 18 octets

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

Essayez-le en ligne!

Solution alternative, 18 octets

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

Essayez celui-ci en ligne!

C #, 130 129 octets

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

Essayez-le en ligne!

• 1 octet enregistré en curryant la fonction (merci à Cyoce)

PowerShell 3+, 151 121 octets

$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 n'a pas de fonctionnalités intégrées principales, j'ai donc dû rouler le mien. Ma première version était terrible et j'ai pris de la plupart des autres qui testent 0 parmi les résultats de module ce qui économise beaucoup. Également sabré quelques octets en utilisant -notinau lieu de -notcontainsmais cela signifie que PowerShell v2 est sorti.

Explication basée sur les commentaires

# $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 octets

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)

Essayez-le en ligne!

QBasic, 122 octets

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

Prend le code comme ligne d'entrée, puis prend chaque numéro d'entrée sur sa propre ligne. Les sorties sont entrecoupées des entrées car elles sont imprimées dès qu'elles sont calculées. La valeur véridique est -1; falsey l'est 0.