Inspiriert von der jüngsten Begeisterung für eine weitere Sprache mit zwei Charakteren, ;#

Intro

Nach dem Konsens der Community müssen für akzeptable Antworten auf dieser Website Programmiersprachen verwendet werden, die mindestens Folgendes umfassen:

1. Kann bestimmen, ob eine natürliche Zahl eine Primzahl ist
2. Kann zwei natürliche Zahlen addieren
3. Kann eine Liste / ein Tupel von Zahlen sowie eine einzelne Zahl darstellen

Für die Zwecke dieser Herausforderung werden wir # 3 ignorieren. Daher würde die einfachste Sprache, die auf dieser Site verwendet werden könnte (ignoriert # 3), genau zwei Befehle haben, isPrimeund add. Zur Erleichterung der Interpretation und Byteanzahl, lassen Sie uns assign isPrimeauf pund addzu +. So haben wir unsere Sprache +p. Ihre Herausforderung besteht darin, +pCode zu interpretieren .

Verhalten

• +Der addBefehl nimmt zwei Zahlen, addiert sie und gibt das Ergebnis aus
• pDer isPrimeBefehl nimmt eine einzelne Zahl und gibt aus, 1ob es sich um eine Primzahl 0handelt oder nicht

Regeln

• Sie müssen ein Programm / eine Funktion schreiben, die bei einer gegebenen Zeichenfolge diese Zeichenfolge als +pCode interpretiert . Sie können eine wohlgeformte Eingabe annehmen (nur +und pZeichen).
• Die Eingabe ist flexibel. Sie können das Programm als Zeichenfolge, Zeichenfeld, ganzzahliges Feld von Codepunkten usw. aufnehmen. Die Eingabe für das zu interpretierende Programm ist ebenfalls flexibel. Sie können ein ganzzahliges Array aufnehmen und Einträge beim Ausführen des Programms verbrauchen, oder jeder Befehl ( +und p) fordert einzeln Eingaben an. Sie können davon ausgehen, dass für jede Anweisung genügend Eingaben vorhanden sind. Die Eingabe besteht garantiert aus Zahlen zwischen 0 und 200 (aber Ihre Algorithmen sollten theoretisch für jede positive Ganzzahleingabe funktionieren).
• Die Ausgabe ist auch flexibel. Sie können die Ergebnisse drucken, als Liste zurückgeben, eine Zeichenfolge zurückgeben, die alle Ergebnisse enthält usw. Wenn Sie gedruckt oder als Zeichenfolge zurückgegeben werden, muss die Ausgabe durch ein nicht-stelliges, konsistentes Trennzeichen (z. B. eine neue Zeile) getrennt werden. Tabulator, Leerzeichen oder ,Zeichen. Möglicherweise haben Sie ein nachgestelltes Trennzeichen oder ein nachgestelltes Leerzeichen. Auch pkann ‚s Ausgang jeder truthy oder Falsey Wert sein, wie sie in der Sprache definiert Sie arbeiten in, statt 1oder 0.
• Der Interpreter wird möglicherweise beendet oder nicht (wenn es sich um ein vollständiges Programm handelt), muss jedoch den Druckvorgang beenden, nachdem alle Anweisungen interpretiert wurden. (Es kann nicht für immer das Trennzeichen oder ein Nullzeichen usw. gedruckt werden.)
• Diese Standardlücken sind standardmäßig verboten
• Das ist Code-Golf , die Antwort mit den wenigsten Bytes gewinnt

Testfälle

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

Viele, viele, sehr lange Testfälle

Der Java-Code, der zum Generieren von Testfällen verwendet wird

Beispiel

Nachfolgend finden Sie eine Java-Funktion ohne Golf, die Folgendes interpretiert +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;
}

Hinweis: Bei Verwendung der Suchabfrage prime AND add AND interpret is:questionscheint es keine Duplikate zu dieser Frage zu geben. Wenn es eine gibt, tut mir leid.

05AB1E , 5 Bytes

vy.V,

Probieren Sie es online!

Erläuterung

Diese Herausforderung passte 05AB1E wie angegossen :)

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

Probieren Sie es online!

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] für den Einsatz.

• 9 Bytes gespart dank @Laikoni (# 56433)

Ich lerne immer noch Haskell; Golftipps erwünscht!

Ruby 2.4, 77 + 7 = 84 Bytes

Verwendet die -rprimeFlagge.

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

Zuerst rotorwird die Eingabeliste mit der Methode in Blöcke der Größe 1 oder 2 aufgeteilt, je nachdem, ob das nächste Zeichen des Programms ist poder nicht. Dann wird diese unterteilte Liste überlagert; Brocken der Größe 2 werden summiert, und Brocken der Größe 1 lassen ihr einziges Element auf Ursprünglichkeit prüfen.

Jelly , 18 Bytes

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

Probieren Sie es online!

Alternative Lösung, 18 Byte

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

Versuchen Sie dieses online!

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

Probieren Sie es online!

• 1 Byte durch Aufrufen der Funktion eingespart (dank Cyoce)

PowerShell 3+, 151 121 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 hat keine eingebauten Prime-Funktionen, daher musste ich meine eigenen rollen. Meine erste Version war schrecklich und ich habe von den meisten anderen, die unter den Modul-Ergebnissen auf 0 testen, genommen, was viel spart. Außerdem werden ein paar Bytes gesäubert, indem -notinstattdessen -notcontainsPowerShell v2 verwendet wird.

Kommentarbasierte Erklärung

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

Probieren Sie es online!

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

Nimmt den Code als Eingabezeile und nimmt dann jede Eingabenummer in eine eigene Zeile. Die Ausgaben werden mit den Eingaben gemischt, da sie gedruckt werden, sobald sie berechnet wurden. Der wahre Wert ist -1; Falsey ist 0.