Interpretar + código p

15

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

Fénix Socrático
fuente
En sus resultados, los resultados de la ps se concatenan sin separador, ¿está previsto?
Gábor Fekete
¿Podemos usar una prueba heurística principal? es decir, isprimeen julia.
Rɪᴋᴇʀ
¡Empecé esa locura! Pero ... ¿qué ha hecho? Los robots ... no!
caird coinheringaahing
Curiosamente, hice exactamente lo contrario al desafío
caird coinheringaahing
@ GáborFekete ¿Son? A mí me parecen bien ...
Socratic Phoenix

Respuestas:

31

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
Emigna
fuente
66
Definitivamente la herramienta adecuada para el trabajo.
Erik the Outgolfer
1
Esto se ve engañoso ... quiero decir realmente.
Christopher
@Christopher: Por suerte +y psignifica agregar e isPrime en 05AB1E :)
Emigna
@Emigna Nunca he usado 05AB1E, ¡así que no tenía idea! Respuesta inteligente :)
Socrático Phoenix
@Emigna Espera, ¿eras Enigma?
Christopher
7

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

Hiperneutrino
fuente
i,j=0,0es redundante, ¿verdad? ¿No podría ser i,j=0?
Pavel
1
@ Phoenix: No, eso no funcionará. Sin i=j=0embargo, puedes hacerlo .
Nick Matteo
5

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!

Quelklef
fuente
Este consejo para usar la notación infija para funciones puede ahorrarle algunos bytes. Además, el caso base i _[]=[]se puede mover para que sea la última regla de coincidencia de patrones y luego se puede acortar i _ e=e, o algo así, _!e=edespués de cambiar a la notación infija.
Laikoni
(min$product ...puede ser min(product ....
Laikoni
product$map(mod a)se puede acortar a foldr((*).mod a)1.
Laikoni,
4

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]}
Tinta de valor
fuente
4

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.

Sean
fuente
3

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)
Mormegil
fuente
no estoy seguro de cómo funciona C #, pero ¿podría cambiar (p,d)=>a p=>d=>para guardar un byte y hacer una función curry?
Cyoce
Bien gracias. (Es discutible la cantidad de repetitivo de C # que se debe incluir en el recuento de bytes, pero sí, puede escribir eso. (Vea el TIO vinculado))
Mormegil
2

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++  
}
Mate
fuente
1

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!

Brunner
fuente
0

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.

DLosc
fuente