Inspirado por la reciente moda por otro lenguaje de dos caracteres, ;#

Introducción

Según el consenso de la comunidad , las respuestas aceptables en este sitio deben usar lenguajes de programación que, como mínimo:

1. Puede determinar si un número natural es primo
2. Puede sumar dos números naturales juntos
3. Puede representar una lista / tupla de números, así como un solo número

Para los propósitos de este desafío, ignoraremos el # 3. Por lo tanto, el lenguaje más simple que podría usarse en este sitio (ignorando el n. ° 3) tendría exactamente dos comandos, isPrimey add. Para facilitar la interpretación y el recuento de bytes, asignemos isPrimeto py addto +. Por lo tanto, tenemos nuestro idioma +p,. Su desafío es interpretar un +pcódigo.

Comportamiento

• +la addinstrucción toma dos números, los agrega y genera el resultado
• pla isPrimeinstrucción toma un solo número y 1muestra si es primo y 0si no lo es

Reglas

• Debe escribir un programa / función que, dada una cadena de caracteres, interprete esa cadena como +pcódigo. Puede asumir una entrada bien formada (solo +y pcaracteres).
• La entrada es flexible. Puede tomar el programa como una cadena, matriz de caracteres, matriz entera de puntos de código, etc. La entrada para el programa que se está interpretando también es flexible. Puede tomar una matriz entera y usar entradas a medida que se ejecuta el programa, o cada instrucción ( +y p) puede solicitar entradas individualmente. Puede suponer que habrá suficiente información para cada instrucción. Se garantiza que la entrada constará de números entre 0 y 200 (pero sus algoritmos deberían funcionar teóricamente para cualquier entrada entera positiva).
• La salida también es flexible. Puede imprimir los resultados, devolverlos como una lista, devolver una cadena que contenga todos los resultados, etc. Si se imprime o devuelve como una cadena, la salida debe estar separada por un separador consistente que no sea un dígito, como una nueva línea, tabulación, espacio o ,personaje. Puede tener un separador final o algún espacio en blanco final. Además, pel resultado puede ser cualquier valor verdadero o falso, según lo definido por el idioma en el que está trabajando, en lugar de 1o 0.
• El intérprete puede finalizar o no (si es un programa completo), pero debe dejar de imprimir después de que se interpreten todas las instrucciones. (No puede continuar imprimiendo el separador para siempre, o un carácter nulo, etc.).
• Estas lagunas estándar están prohibidas por defecto
• Este es el código de golf , la respuesta con la menor cantidad de bytes gana

Casos de prueba

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

Muchos, muchos, casos de prueba muy largos

El código Java utilizado para generar casos de prueba.

Ejemplo

A continuación se muestra una función java sin golf que interpretará +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: Al usar la consulta de búsqueda prime AND add AND interpret is:question, no parece haber duplicados a esta pregunta. Si hay uno, lo siento.

05AB1E , 5 bytes

vy.V,

Pruébalo en línea!

Explicación

Este desafío encaja 05AB1E como un guante :)

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 bytes gracias a kundor

Python 2 , 91 bytes

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)

Pruébalo en línea!

Haskell, 88 79 bytes

('+':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] para usar.

• Guardado 9 bytes gracias a @Laikoni (# 56433)

Todavía estoy aprendiendo Haskell; consejos de golf apreciados!

Ruby 2.4, 77 + 7 = 84 bytes

Usa la -rprimebandera.

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

Perl 6 , 70 bytes

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

Primero, el rotormétodo se usa para dividir la lista de entrada en fragmentos de tamaño 1 o 2, dependiendo de si el siguiente carácter del programa es po no. Luego, esa lista fragmentada se asigna; se suman trozos de tamaño 2, y se prueba la primalidad de los trozos de tamaño 1.

Jalea , 18 bytes

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

Pruébalo en línea!

Solución alternativa, 18 bytes.

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

¡Prueba este en línea!

C #, 130 129 bytes

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

Pruébalo en línea!

• Guardado 1 byte al curry la función (gracias a Cyoce)

PowerShell 3+, 151121 bytes

$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 no tiene funciones integradas principales, por lo que tuve que rodar el mío. Mi primera versión fue terrible y tomé de la mayoría de las otras que prueban 0 entre los resultados del módulo, lo que ahorra mucho. También sabed algunos bytes usando en -notinlugar de -notcontainspero significa que PowerShell v2 está fuera.

Explicación basada en comentarios

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

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)

Pruébalo en línea!

QBasic, 122 bytes

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

Toma el código como una línea de entrada, luego toma cada número de entrada en su propia línea. Las salidas se intercalan con las entradas porque se imprimen tan pronto como se calculan. El verdadero valor es -1; Falsey es 0.