Trotz Ihres Protests wurden Sie von Ihrem Chef mit einem Programm beauftragt, das eine einzelne vorzeichenlose Ganzzahl als Eingabe verwendet und die Zeichenfolge "prime" ausgibt, wenn diese Ganzzahl prim ist, und "not prime", wenn dies nicht der Fall ist. Sie können wählen, in welcher Sprache Sie dies tun, solange das resultierende Programm kurz ist. Ihr Chef schätzt eine geringe Anzahl von Charakteren sehr. (Er zählt die Zeichen tatsächlich manuell , nachdem er den Quellcode ausgedruckt hat.)

Damit es besser geht, gewinnt die niedrigste Anzahl an Charakteren.

Der lustige Teil

Dies ist nur zwischen Ihnen und mir, aber Ihr Programm sollte auch in einer anderen Sprache gültig sein. In dieser Sprache sollte jedoch die Zeichenfolge "Wenn der Chef dies findet, kündige ich." Gedruckt werden. Stellen Sie sicher, dass Ihr Chef nicht herausfindet, dass es eine versteckte Beleidigung gibt, wenn er den Code immer wieder liest, da er immer wieder vergisst, ob er bis jetzt mit 17 oder 18 gezählt hat. Aus diesem Grund dürfen Sie keines der Wörter in "Der Chef findet das Ende" in einem Teil des Codes verwenden, und Sie können auch keine Anagramme dieser 5 Wörter verwenden.

Bonus-Herausforderung, für die ich ein Kopfgeld angelegt habe

Schreiben Sie ein Programm, das tatsächlich so aussieht, als würde es nur die erste Frage für das ungeübte Auge lösen und keine unnötigen Zeichen enthalten. Dazu gehören Kommentare und Codesegmente, die offensichtlich nichts beitragen. Im Idealfall würde ein Laie glauben, dass Ihr Programm so kurz ist, wie es nur sein kann, ohne nicht verwaltbar zu sein. Ein hilfreicher Kommentar hier und da ist aber okay.

Die Regeln für die Bonusherausforderung sind etwas lockerer, anstatt nach leicht messbaren Kriterien beurteilt zu werden, wird Ihr Programm mehr danach beurteilt, wie es mir (und den Wählern natürlich) entgegenkommt.

Ich werde der endgültige Richter sein, welcher Eintrag dieser Prämie am nächsten kommt.

Bearbeiten:

Nach ein paar Minuten, in denen Ihr Chef gezählt hat, ließ er von einem Ihrer Kollegen ein Charakterzählprogramm für ihn schreiben. So zählen auch Zeichen, die nicht sichtbar sind, zu Ihrer Zeichenanzahl.

CJam ( GolfScript ), 60 59 Bytes

"Jg!uif!cptt!gjoet!uijt-!J!rvju/"{(}%S#];"not prime"limp4*>

Vielen Dank an @mnbvmar für das Golfen ab 1 Byte!

Wie es funktioniert (CJam)

"Jg!uif!cptt!gjoet!uijt-!J!rvju/"  " Push that string.                                    ";
{(}%                               " Subtract 1 from each character code.                 ";
S#                                 " Find the index of the first space.                   ";
];                                 " Wrap the entire stack in an array and discard it.    ";
"not prime"                        " Push that string.                                    ";
li                                 " Read an integer from STDIN.                          ";
mp4*                               " Push 4 if it's prime and 0 if it isn't.              ";
>                                  " Remove that many chars from the start of the string. ";

Probieren Sie es online!

Wie es funktioniert (GolfScript)

"Jg!uif!cptt!gjoet!uijt-!J!rvju/"  # Push that string.
{(}%                               # Subtract 1 from each character code.
S#];"not prime"limp4*>             # Noop followed by a comment.

Probieren Sie es online!

Python 2 / Python 3 - 128

n=int(input())
s="Isf  tthhies ,b oIs sq ufiitn.d"
print(["not "*any([n%a<1for a in range(2,n)])+"prime",s[::2]+s[1::2]][1/2>0])

Identifiziert Primzahlen mit Python 2 und bringt Sie in Schwierigkeiten mit Python 3 .

Bonus

__help__ = """In the forloop I'm setting the values i to n.
To be a "notPrimes", it's n % i == 0 if: 1 < i, i < n. (We
do tests i<1/2 i==1, too). Then, prints resulting, prime text.
In case i==n: quit. Just if it aborts: try."""

# read integer from command line
n=int(input())

try:

    # primes = True
    notPrimes = False

    # try each i to n
    for i in range(n):

        # ignore 0 or 1
        if i < 1 / 2 or i == 1:
            continue

        # test divisibility
        if n % i == 0:
            notPrimes = True

    # print result
    if notPrimes:
        print("not prime")
    else:
        print("prime")

except:

    # if program aborts: print help and error code
    print(__help__ [::7])

Probieren Sie es mit Python 2 oder Python 3 ! (Im Gegensatz zur obigen Golfversion haben sich die Rollen geändert: Python 3 ist die Primzahlkennung. Python 2 enthält das Osterei.)

Entschuldigen Sie bitte mein schlechtes Englisch im Hilfetext! ;)

Und ich benutze das Wort "quit". Aber irgendwie muss ich beschreiben, wann mein Programm endet. ;)

Bonuseinreichung (C / C ++ 11)

Primalitätstests unter Verwendung der üblichen naiven Methode sind so Mainstream. Deshalb habe ich eine brandneue randomisierte naive Methode erfunden! Dieser Test ist wie folgt:

1. Wählen Sie eine beliebige ganze Zahl d nach dem Zufallsprinzip. Es darf nicht kleiner als 2 und etwas größer als sein sqrt(n).
2. Wenn d ein Teiler von n ist , wird ausgegeben not prime.
3. Wenn wir diesen Test 20sqrt(n)mal gemacht haben, ausgeben prime, sonst wiederholen.

Wenn die Zahl zusammengesetzt ist, besteht nur eine sehr geringe Wahrscheinlichkeit (etwa 10 ^-9 ), dass sie nicht funktioniert. Natürlich glaube ich nicht, dass der C / C ++ - Pseudozufallszahlengenerator leistungsfähig genug ist. Deshalb verwende ich meinen eigenen 256-Bit- LFSR-Generator !

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/* A 256-bit linear feedback shift register generating pseudorandom
 * numbers (its period is 2^256 - 1).
 */
struct LFSRGenerator {
    unsigned seed[8];
};

void lfsr_init_generator(struct LFSRGenerator *gen){
    gen->seed[0] = 0xE840CC92; gen->seed[1] = 0xC440CAD0;
    gen->seed[2] = 0x40E6E6DE; gen->seed[3] = 0xC8DCD2CC;
    gen->seed[4] = 0xD0E840E6; gen->seed[5] = 0x4058E6D2;
    gen->seed[6] = 0xEAE24092; gen->seed[7] = 0x145CE8D2;
}
void lfsr_proceed(struct LFSRGenerator *gen){
    // LFSR taps are x^256, x^254, x^251 and x^246
    unsigned new_bit =
        ((gen->seed[7]>>0)^(gen->seed[7]>>2)^
         (gen->seed[7]>>5)^(gen->seed[7]>>10)) & 1;

    // shift seed right
    gen->seed[7] >>= 1;
    int cell;
    for(cell = 6; cell >= 0; cell--){
        gen->seed[cell+1] |= ((gen->seed[cell]&1)<<31);
        gen->seed[cell] >>= 1;
    }
    gen->seed[0] |= (new_bit<<31);  // put new bit
}
void lfsr_error(struct LFSRGenerator *gen){
    fprintf(stderr, "Error! Developer info:\n");

    int cell;
    for(cell = 0; cell < 8; cell++){
        unsigned val = gen->seed[cell];
        putc((char)(val&0xFF), stderr); val >>= 8;
        putc((char)(val&0xFF), stderr); val >>= 8;
        putc((char)(val&0xFF), stderr); val >>= 8;
        putc((char)(val&0xFF), stderr);
    }
    putc('\n', stderr);
    exit(1);
}
int lfsr_get_num(struct LFSRGenerator *gen, int min_val, int max_val){
    lfsr_proceed(gen);
    int mod_num = max_val-min_val+1;   // = number of possible results
    if(mod_num <= 0)
        lfsr_error(gen);

    // take 6 first cells and compute them mod 'modNum'
    unsigned long long result = 0;
    int cell;
    for(cell = 5; cell >= 0; cell--){
        result = ((result << 32) | gen->seed[cell]) % mod_num;
    }
    return (int)result + min_val;
}

/**********************************************************************/



void end_not_prime(){
    printf("not prime\n");
    exit(0);
}
void end_prime(){
    printf("prime\n");
    exit(0);
}



int main(){ 
    int number;
    struct LFSRGenerator gen;
    lfsr_init_generator(&gen);


    printf("Provide a number to check its primality: ");
    scanf("%d", &number);

    if(number <= 1){
        end_not_prime();
    }
    if(number == 2){
        end_prime();
    }

    // just to make sure:
    //  * make 20*sqrt(n) tests
    //  * generate random divisors from 2 to 111111/100000 * sqrt(n)
    //      (in case max range doesn't include sqrt(n)
    auto num_checks = (int)floor(sqrt(number)*20);
    auto max_range = sqrt(number);
    max_range /= 100000;
    max_range *= 111111;
    max_range = floor(max_range+0.5);

    while(num_checks--){
        int rnd_div = lfsr_get_num(&gen, 2, max_range);
        if(number % rnd_div == 0){
            end_not_prime();
        }
    }
    end_prime();
}

C ++ 11 funktioniert ordnungsgemäß. Der C-Compiler scheint jedoch ein fehlerhaftes Programm für n> 2 auszugeben ...

Hinweis : Denken Sie daran, dass C die -lmOption (Link Math Library) benötigt, um erfolgreich kompiliert zu werden.

Schau dir die max_rangeVariable an. Das C ++ 11-Schlüsselwort wird autoin einen "passenden Typ" aufgelöst - in diesem Fall double. In C ist es jedoch als variabler Modifikator definiert (wie er staticist) - er definiert den Typ nicht. Somit max_rangeTyp ist ein Standard - C - Typ, das heißt int. Wenn wir versuchen, diese Variable mit 1.11111 zu multiplizieren, wird sie in C während der Division durch 100000 "unbeabsichtigt" auf Null gesetzt. Es wird ein falsches Intervall von Zufallszahlen generiert, und LFSR erzeugt nach Fortfahren seines internen Zustands einen Fehler und gibt die Binärdatei aus Müllkippe des Samens. Das ist "aus Versehen" Die Nachricht Wenn der Chef dies findet, habe ich gekündigt. \ N

Wenn Sie die folgende fehlerhafte Ausgabe finden:

Error! Developer info:
If the boss finds this, I quit.

falsch, entfernen Sie einfach die entsprechende fprintfZeile.

Mathematica / Brainfuck, 260

If[PrimeQ[Input[]],"prime","not prime"](*++++++++++[>+++>++++>+++++++>++++++++++>+++++++++++<<<<<-]>>>+++.>++.<<<++.>>>>++++++.<++.---.<<<.>>>---.>-----.++++..<<<<.>>>++++.+++.>-----.<-----.>+++++.<<<<.>>>>+.<++++.+.>-.<<<++++.<.>>.<<.>>>>--.++++.<.>-.<<<++.*)

Golfscript / Javascript (126 125 129 130 132 134 205 207 )

Versuchen Sie Golfscript hier und Javascript hier .

1.//"Jg!uif!cptt!gjoet!uijt-!J!rvju/"{(}%'
alert((/^1?$|^(11+?)\1+$/.test(Array(+prompt()+1).join(1))?"not ":"")+"prime");';#'

Ich würde sagen, es ist erschreckend nah an den Mathematica-Lösungen, die schließlich eine eingebaute Prüfung auf Primzahlen haben.

Edit: Danke an Peter für das Speichern von zwei weiteren sechs Bytes!

Hier sind einige Details:

• Das erste 1.ist erforderlich, da das folgende //ein Kommentar in Javascript ist, aber die Division in Golfscript zweimal durchführt. Dies wird fehlschlagen, wenn sich nichts auf dem Stapel befindet, daher müssen wir ihm zwei Zahlen geben. Im Übrigen 1.ist die Syntax in Javascript vollkommen gültig und wird einfach ignoriert.
• "…"{(}%Nimmt die Zeichenfolge, dekrementiert ihre Zeichencodewerte um eins und schiebt sie als Zeichenfolge. Dies führt zu der Zeichenfolge, die wir drucken müssen.
• ' Startet eine Zeichenkette in Golfscript, die sich standardmäßig über mehrere Zeilen erstreckt, wodurch das unten stehende Javascript nur in die Zeichenkette eingefügt wird.
• Als nächstes kommt der Javascript-Code, der einen bekannten Ansatz verwendet, um Primzahlen durch reguläre Ausdrücke zu erkennen.
• ';#'Schließt die mehrzeilige Zeichenfolge in Golfscript, verwirft sie und ignoriert den Rest der Zeile. In Javascript ist dies einfach ein String-Literal, das ignoriert wird.

C ++ / C99 / C90 - 248

Der Code läuft in C90 einwandfrei, kann aber in C99 / C ++ etwas anderes anzeigen.

Der Übersichtlichkeit halber nicht golfen:

int i=105,j=115,k=32,n=79;

int main() {
    char c[] = {i, 102, k, j+1, i-1, 101, k, 98, 111, j, j, k, 102, i, 
            110, 100, j, k, ++j, i-1, i, --j, k, i, k, 113, 117, i, 116};
    for (i=0;i<31;i++) c[i] = c[i] //* */ 1 + 1
            *0;
    for(i=2;i*i<=n;i++) if(n%i==0||n<2) {printf("not "); break;}
    printf("prime %s\n",c);
}

So funktioniert es: Da C90 einzeilige Kommentare nicht erkennt, wird die Problemzeichenfolge nicht mehr mit Null multipliziert.

CJam / Ruby, 132 95 91 87

0_0#;;limp4*"not prime">"
'Li#wkh#ervv#ilqgv#wklv/#L#txlw1'.bytes{|b|print (b-3).chr}#";

Meine vorherige Lösung war erheblich überarbeitet. dieser war stark von Martin Büttners Lösung inspiriert, einschließlich seiner Erkenntnis, dass die #bytesMethode anscheinend einen Block einnehmen kann.

Wie funktioniert es?

Rubys Kommentarzeichen ( #) ist der Potenzierungsoperator in CJam, daher benötigen wir mindestens zwei Zahlen auf dem Stapel, bevor wir beginnen, aber zwei leere Zahlen ( 0 0) sind ein Syntaxfehler in Ruby. Eines ist jedoch in Ordnung, und Ruby-Zahlen können als Trennzeichen Unterstriche enthalten ( 1_234). _ist der Duplizierungsoperator von CJam, daher müssen wir 2x ( ;;) einfügen, sobald wir im Kommentar sind. limpLiest eine Zeile von der Standardeingabe, konvertiert sie in eine Ganzzahl, fügt sie ein und legt fest, ob es sich um eine Primzahl handelt oder nicht.

Um in den Ruby-Modus zu gelangen, öffnen wir eine Zeichenfolge und fahren mit der nächsten Zeile fort, sodass wir nicht mehr im Ruby-Kommentar enthalten sind (daher ist die neue Zeile wichtig und muss gezählt werden). Jedes Zeichen der Nachricht wird dekodiert und gedruckt. Anschließend beginnen wir mit einem weiteren Ruby-Kommentar, damit wir die CJam-Zeichenfolge sicher schließen können, bevor wir sie einfügen. Was auf dem Stapel übrig bleibt, ist, ob die Eingabe prim war oder nicht, was beim Beenden des CJam-Programms gedruckt wird.

CJam / Whitespace, 353 (25 beim Drucken sinnvolle) Zeichen

Angesichts der Hinterhältigkeit der Herausforderung und der Tatsache, dass der Chef unsere Programme druckt, um die Charaktere zu zählen, nahm ich den Vorschlag an, eine Lösung mit Whitespace zu finden .

Entgegen meiner vorherigen Behauptung, dass das kürzestmögliche Whitespace-Programm "Wenn der Chef dies findet, kündige ich" ausgibt. wären 372 Zeichen, dies tut man in 330. Der Trick besteht darin, die copyAnweisung zu verwenden, um Wiederholungszeichen von irgendwo auf dem Stapel abzurufen, anstatt alle ASCII-Werte zu verschieben, die immer viel größer werden und daher mehr Leerzeichen erfordern und zu codierende Tabulatoren. Hier ist eine Pseudo-Assembler-Darstellung des Programms für Neugierige:

push 0
push . push t push i push u push q
push 32 push I
copy 1 push , push s copy 7 push h copy 10
copy 5 copy 4 push d push n copy 6 push f
copy 5 copy 5 dup push o push b
copy 4 push e copy 14 copy 14
copy 3 copy 10 copy 23

0: dup jz 1 ochr jump 0
1: exit

Einreichung des Bonuspreises (Perl / B? F? N? E-? 3)

Bearbeiten: Ich habe ursprünglich vergessen, den Satz tatsächlich auszudrucken, und dann festgestellt, dass er in umgekehrter Reihenfolge gedruckt wird. Ich habe das bemerkt, nachdem ich fertig war. Ich war kurz davor, ein Kätzchen zu töten, aber ich habe es jetzt behoben.

Dies ist in keiner Weise mehr kurz, aber ich glaube, dass es eine verdammt schwierige Aufgabe ist, es unauffällig und kurz zu machen. Ich habe meistens eine meiner tatsächlichen Golfunterlagen wiederverwendet, aber in dieser würde ich sagen, dass die zweite Sprache wirklich schwer zu erkennen ist.

Wenn der Chef das findet, höre ich wirklich auf, weil ich ihn niemals heimlich beleidigen kann, und wenn ich das nicht kann, worum geht es dann?

# ^ Prime Checker ([>:#,_@| Golf Inc. Ltd. | @_,#:<])
# ^ Ingo Bürk, (C) 2014
################################################################################################
# Input should be a "reasonably"
# small integer, or I can't guarantee
# that the check is fast at all.
#
# More Details:   - the numbers 0 and 1 are
#                   handled as not prime,
#                   even if some people disagree
#
#                 - because my employer prefers shortness                 
#                   over well-tested, modular and
#                   somewhat pretty code, the used method is
#                   somewhat questionable

#                 - first of all, the input is converted
#                   into a string of 1s such that the
#                   number of 1s equals the input;
#                   directly after that, a regexp is applied
#                   such that it checks if the input is prime

#                 - the regexp is not really my work, so I
#                   have to give attribution to its author
#                   if I want to use it here; I got it on
#                   stackoverflow:
#                   "http://stackoverflow.com/questions/3296050/how-does-this-regex-find-primes"

# <=> <--- a riddle^^
    use v5.10;

# Definition of prime number:
#############################
# "A prime is a positive integer with exactly two unique divisors."
# ,
#
# I should mention that input is given via stdin.
#
# quality documentation like this is why I get paid so much.
# use this script at your own risk.
# it has been known that checking primes like this can crash interpreters.
# this never happened to me, though.
# .
# "Less is more" -- Robert Browning (1812-1889) [Riddle Solution]

    print"not "if(1x shift)=~/^1?$|^(11+?)\1+$/;say"prime"

Biegen und Brechen der Regeln:

• Ich benutze dort das Wort "the", aber es ist nicht das "the", das gedruckt wird. Es könnte technisch ungültig sein, ich werde das OP entscheiden lassen, ob die Regeln für die Bonusherausforderung so streng sein müssen. Wenn ja, dann soll es so sein.
• Die Regeln besagen, dass ich bestimmte Wörter nicht verwenden kann, aber wir lesen von links nach rechts, daher gehe ich davon aus, dass die vertikal ausgeschriebenen Wörter gültig sind.
• Ich habe keine Ahnung, wie ich diesen Job noch habe, wenn ich die schrecklichen Dinge sehe, die ich in Kommentaren schreibe. Ich meine: Rätsel, wirklich?

Mathematica / Ruby, 115 106 Bytes

Der Mathematica-Teil wurde leicht von Peter Olsons Beitrag inspiriert, aber das Polyglotten mit Ruby ist hier etwas ausgefeilter.

#If[PrimeQ@Input[],"","not "]<>"prime"&@1(*
"Jg!uif!cptt!gjoet!uijt-!J!rvju/".bytes{|c|print (c-1).chr}#*)

Ruby funktioniert, weil die beiden #alles auskommentieren, was Mathematica ist. Der Grund, warum Mathematica funktioniert, ist etwas interessanter. Der Code, den ich ausführen möchte, ist:

If[PrimeQ@Input[],"","not "]<>"prime"

Aber das ist kein gültiger Ruby, also muss ich #irgendwo einen hinzufügen . #ist der Parameter von Mathematica für anonyme Funktionen. Also habe ich #vorne gesetzt, was das Argument mit dem Ergebnis des multipliziert If. Ja, es multipliziert das mit einer Zeichenkette , was auch immer das bedeutet. Dann mache ich daraus eine anonyme Funktion mit &und rufe sie sofort mit argument auf 1. Nun, Mathematica ist klug genug zu wissen, dass die Multiplikation mit 1 immer die Identität ist und nur den String ausgibt. Anschließend wird der Ruby-Code einfach in einen Blockkommentar eingefügt.

C (Bonuseinreichung)

Bei der C-Version handelt es sich um einen Prime Checker, bei dem das Eingabearray oben steht. Versuchen Sie zu erraten, welche Sprache sich ergibt If the boss finds this, I quit.(es handelt sich nicht um Whitespace).

// input numbers
unsigned z[] = {4};
// number of inputs
int n = 1;

int bad(unsigned);
int good(unsigned);
// [ ... ] is used to group code into blocks to make the code easier to understand
main(c){
    if(c != 1){
        // someone needs help running this program!
        // goto the end where help text is displayed!
        // remember: gotos are not evil
        goto helpme;
    }
    int i;
    // looping down is faster than using ++
    for(i = n; i--;){
        // first we check if input is divisible by two
        // checking out of loop because `>>` is faster
        //  than `/`

        // must be either greater (not divisible by 2) or equal (divisible by 2)
        unsigned y = z[i];
        if(y > (y>>1)*2){
            // is not divisible by 2
            // we must check every other number now to ensure primality
            unsigned j;
            for(j = 3; j < z[i]; ){
                // check if number is divisible by j

                // make another copy of z[i]:
                unsigned k = z[i];

                // compilers are stupid-they have a tendency 
                //  to generate really slow code for division
                //  outside of a while loop conditional
                // therefore we do division by repeated subtraction
                // [
                    // repeated subtraction-subtract until k is less than j
                    while(k / j){
                        k -= j;
                    }
                    // if k is zero-k is divisible by j and is not a prime
                    if(!k){
                        break;
                    }
                    // bring k back down to zero-there could be
                    // memory issues if we don't-very bad
                    // afterwards continue the loop
                    while(--k > 0);
                    // increment j to continue checking
                    //  we undo if we overflowed
                    //   so we don't enter an infinite loop
                    j += 1;
                    if(j < 1){ // overflow check
                        j = 4294967295u; // max unsigned int size
                    }
                // ]
            }
            // if j >= y then y must be a prime.
            // but if j < y then j < z[i] and j must be a factor
            // j - y == 0 is used to test this-if true y is a prime
            // [
                if(j - y == 0){
                    // yay - a prime!
                    // subtraction necessary as good() and bad()
                    //  shift the value printed by 1 (who knows why)
                    good(y-1);
                }else{
                    // not a prime - oh no!
                    // output this number as not a prime
                    bad(y-1);
                }
                // we are done >+–__-+<   x_x finally! >_<
            // ]
            // >.< nearly done
            // cleanup: if y or j < 0 do -- until they are 0-
            //  avoiding memory issues is vital
            while(--y); while(--j);
        }else{
            // is divisible by 2
            // determine if this is a prime: only a prime if is 2
            // also must be non-zero
            // [
                if(!y-- || y > 1){
                    // uh oh: not a prime
                    // output
                    bad(y);
                    // undo changes to the number
                    ++y; 
                }else{
                    // prime
                    // output
                    good(y);
                    // undo changes to the number
                    y += 1;
                }
                // done here <__≥ coding is exhausting
            // ]
            // clean up! clean up! everybody everywhere!
            while(y)
                // use ++ because its faster here
                // seriously: we profiled it
                ++y;
        }
    }
    return 0;
    helpme:
    // ++-++-++-++-++-++-++-++-++-++-++-++
    // +    the dreaded HELP section     +
    // ++-++-++-++-++-++-++-++-++-++-++-++
        printf("This program checks the primality"
               " of hard coded constants\n"
               "Do not run with any arguments.\n"
               "\n");
        printf("Please press any character to see more information >");
        getchar();
        printf("This is version 1 of the primality checker.\n"
               "If your version is >=1 it is new enough to work\n");
    return 0;
}

// this prints the number x+1
//  (used because profile tests have shown it to be
//   marginally faster)
print_number(unsigned x){
    x += 1;
    // scanf is way to slow.
    // itoa is nonstandard - unacceptable for an important program 
    //   such as this primality checker!
    // we are using a loop here - recursion is dangerous and should
    //   be avoided at all costs! 
    // recursion is also absurdly slow - see recursive fib() for 
    //   an example.
    int i;
    // start from the highest place then move down all the way to the ones place
    for(i = 4000000000u / (1 << 2); i; i /= 10){
        int k = x / i % 10;
        // arrays are best avoided.
        // switches make the code convoluted
        //   so we use if chains
        if(k >= 9){
            putchar('9');
        }else if(k >= 8){
            putchar('8');
        }else if(!(--k - 6)){ // after a single round of profiling 
                              // it was determined that these 
                              // particular checks were optimal.
            putchar('7');
        }else if(4 <= --k - 0){ // a check with the -0 was shown to 
                                // be marginally faster on one test
                                // than without the -0.
            putchar('6'); 
        }else if((++k + 1) / (4 + 1)){// it's optimal! really..
            putchar('5');
        }else if(3 <= k){ // constant first to avoid problems with missing `=`s.
            putchar('4');
        }else if(k > 0 && k / 2 > 0){
            putchar('3');
        }else if(++k + 1 == 1+2){ // this secret optimization is a company secret.
            putchar('2');
        }else if(++k + 42 == 44){ // another top secret company secret.
            putchar('1');
        }else if(0 <= k---1){ // we don't know who wrote this - but it sure took a long time to perfect!
            putchar('0');
        }
    }
    return i-i; // allows for a tail nonrecursion optimization.
}

bad(unsigned c){
    int *q = (int *)&c;
    if(c >= 0) // minor optimization: this was a nanosecond faster one time
        print_number(c);

    // some bit fiddling optimizations
    --*q;
    *q = -*(char *)q ^ (int)(-c * 0xBAADF823 - 43.23); 
    if(*q < ++*q) *q &= +*q * 0x4AF0 + 3 ^ (int)+0x79.32413p23; 

    // <.> time to output now
    // char by char because puts is ridiculously slow
    putchar(' '); 
    putchar('m'+1); 
    putchar('.'*'>'%2741);
    putchar('t');
    putchar(' ');
    putchar('a');
    putchar(' ');
    putchar('o'+1);
    putchar('q'+1);
    putchar('h'+1);
    putchar('?'+'.');
    putchar('7'+'.');
    putchar('<'-'6'/2);
    putchar(('.' << 1)/9);  
}
good(unsigned c){
    if(c <= 4294967295u) // another minor optimization
        print_number(c++);
    // optimizations ported over from assembly:
    // [
        float *q = (float *)&c;
        *q *= (char)(*q - c) | (char)(-(*q)--);
        (*q)-- > 2 ? *q += 1 : (*q = *q*c < c);
    // ]
    if(!(4294967295u > c + 23.3))
        // >.> these optimizations >>.<< are really <.> hard to write
        --c;

    // char by char once more.
    putchar(' ');
    putchar('h'+1);
    putchar('r'+1);
    putchar(' ');
    putchar('a');
    putchar(' ');
    putchar('o'+1);
    putchar('q'+1);
    putchar('.'*'n'/'0'); // division by zero > no division by zero.
    putchar(('<'*'-'/'.'<<3)%355);
    putchar('d'+1);
    putchar(' '+1);
    putchar('\n');
}
// end of program. the cake is a lie!

Die andere Sprache:

Brainfuck . Wird dies als Brainfuck mit nur einer Eingabenummer ausgeführt, wird die entsprechende Zeichenfolge ausgegeben. Bei mehr als einer Eingabe müssen Sie sicherstellen, dass die Eingaben für das Brainfuck-Programm null Byte sind.

Perl / Befunge-93 (108 106 110 )

Meine zweite Vorlage, nur weil. Verwendet auch reguläre Ausdrücke. Ich wette, es gibt eine bessere Wahl als Perl, zum Beispiel Octave, aber ich konnte nicht herausfinden, wie man auf kurze Weise bedingt druckt.

Ich missbrauche die Regel für den Ausdruck der Zeichenfolge, da ich Anagramme vermeide, indem ich sie in mehrere Zeichenfolgen aufteile.

# ".t""iuq I ,s""iht s""dnif s""sob e""ht fI">:#,_@
print"not "if(1x shift)=~/^1?$|^(11+?)\1+$/;print"prime"

Die zu überprüfende Nummer wird von stdin übernommen.

• Edit: Ich habe versehentlich "my" anstelle von "the" geschrieben, die Korrektur kostete +1 Byte.
• Bearbeiten: mit ifstatt unless4 Bytes gespeichert.
• Edit: Vergaß "das" und teilte dieses ebenfalls mit +2 Bytes.

Lua / PBrain (prozedurales Brainf * ck) - 813

Tut mir leid, dass ich versucht habe, hinterlistig zu sein. PBrain ist genau wie BF, aber es ermöglicht Ihnen, wiederverwendbare Blöcke von BF-Code auszulösen und zu definieren. Die Verwendung war völlig unnötig.

--Blua

x00=[[--(>++++++[>++++++<-]>----)
:<<:+++++++++.[-]<<:<<:<<:++++++.[-]>>++++++[<+++++>-]<++.<
<<:<<:<<:<<:------------.[-]<<:<<:<<:++++++++.[-]<<:<<:<<:+++++.[-]>.<
<<:<<:<<:++.[-]<<:<<:<<:<<:-----------------.[-]<<:<<:<<:<<:-------------..[-]>.<
<<:<<:<<:++++++.[-]<<:<<:<<:+++++++++.[-]<<:<<:<<:++++++++++++++.[-]<<:<<:<<:++++.[-]<<:<<:<<:<<:-------------.[-]>.<
<<:<<:<<:<<:------------.[-]<<:<<:<<:++++++++.[-]<<:<<:<<:+++++++++.[-]<<:<<:<<:<<:-------------.[-]<<:++++++++++++.[-]>.<
<<:<<:+++++++++.[-]>.<
<<:<<:<<:<<:---------------.[-]<<:<<:<<:<<:-----------.[-]<<:<<:<<:+++++++++.[-]<<:<<:<<:<<:------------.[-]<<:++++++++++++++.[-]-+]]
n=arg[1] or #x00 IF=string _=print EXIT=os.exit I='not prime'
for i=2,n-1 do

    if IF.find('b0ss',n%i) then _(I)EXIT() end

end
print(I:sub(5))

Python 2 / Rot13 - 270 Bytes (69 ohne Kommentare)

#Code is commented in both English and Esperanto to be more future proof.

#Read number and convert to int.
#Vs gur obff svaqf guvf, V dhvg.
x=input()

#Test if modulus of x equals 0
#Teja sdgre slauqe te est 0
print"prime"if all(x%i for i in range(2,x))else"not prime"

Dies verwendet einen sehr einfachen (dh ineffizienten) Algorithmus. Wenn es mit rot13 (vermutlich keine Programmiersprache) ausgeführt wird, wird der erforderliche Satz (zusammen mit anderem Unsinn) erzeugt.

Das Schlimmste ist, dass die Kommentare das Offensichtliche angeben und sowieso ziemlich nutzlos sind.

Dies ist ein Polyglott auf eine andere Weise, indem es sowohl Englisch als auch "Esperanto" enthält. Ich hoffe, der Chef ist selbst kein Polyglott.

05AB1E / Jelly , 28 Bytes

Nicht eine, sondern ZWEI Golfsprachen!

p,“ßṙ¬kʂUƭ_eµ$ⱮgkṪḞSėdȦṬSN€»

Erklärung in 05AB1E:

p                                      Primality check
 ,                                     Print out; disable implicit output
  “ßṙ¬kʂUƭ_eµ$ⱮgkṪḞSėdȦṬSN€»           Push some random weird string; implicit output disabled

Erklärung in Jelly:

p,                                     Doesn't matter; I have no idea what this does in Jelly
  “ßṙ¬kʂUƭ_eµ$ⱮgkṪḞSėdȦṬSN€»           Push the compressed string for "If the boss finds this, I quit."

Probieren Sie es online! (Gelee) Probieren Sie es online! (05AB1E)

Python, 403 Bytes

Dies ist für die Bonusherausforderung vorgesehen. Die Kommentare zählen nicht zum bytecount.

# Hey boss!  Here is that primality test function.  Please feel free to get rid of the comments.  I know they take up a lot of space.
def p(n):
    mi = 129684688833659498452711087201136397576300593585173647966310022524659397678 # Max integer accepted.  We all want to test big primes, but this is too big.  I did a bunch of really fancy math to come to this number.
    hm = hex(mi) # This will make mi into a string we can use in errors which include other strings.  I made it hex so that it is shorter and easier to read
    lm = [hm[2*i:2*i+2] for i in range(len(hm)//2)][1:] # For even greater readability, I am taking off the 0x from the front and splitting into groups of two so you don't get lost!
    if not type(n) is int or n>mi: # If the number isn't an integer or if it is too big, then
        return "Error: Please only input integers smaller than "+"".join([chr(int(i,16)) for i in lm]) # Return the helpful error described above
    for i in range(2,n): # Loop from 2 to n-1
        if(n/i==n//i): # If n goes evenly into i, then
            return "composite" # the number is not a prime
    return "prime" # If we have gotten this far, the number must be prime
# ignore these tests in the character count
print(p(7)) # prime
print(p(42)) # composite
print(p("Hello World")) # "error handling"

Die Tests am unteren Rand des Codes drucken:

prime
composite
Error: Please only input integers smaller than If the boss finds this, I quit.

Diese von mir definierte maximale Ganzzahl (mi) verbirgt das Geheimnis. Wenn es in Hex umgewandelt wird, lautet die ASCII-Buchstaben-Darstellung für alle zwei Hexadezimalstellen "Wenn der Chef dies findet, beende ich". Der hinterhältige Teil benutzt die chr-Funktion. Wenn der Chef weiß, was das tut, und genau genug nachschaut, weiß er, dass der Code eine geheime Nachricht verbirgt. Allerdings habe ich das ein wenig verschleiert und genug Erklärungen für die ganze Max-Integer-Sache geliefert, um dem Chef hoffentlich zu versichern, dass es ein legitimer Teil des Programms ist

Beachten Sie, dass es für die meisten Parameter so funktioniert, wie der Chef es wünscht, aber wenn die Eingabe keine Ganzzahl ist oder die Zahl irgendwie größer als mi ist, gibt p den Fehler zurück, der die verborgene Zeichenfolge enthält. Ich hätte einen Druckaufruf in die Funktion einfügen können, aber ich dachte, es würde realer aussehen, wenn es zurückgegeben würde.

C # - 288

Sicherlich nicht die kürzeste, aber es könnte von vielen Chefs passieren:

 int i; string t = "prime"; var test = ""; int[] tests = { 8, 8, 8, 8, 8, 8, 8, 8, 8, 73, 102, 32, 116, 104, 101, 32, 98, 111, 115, 115, 32, 102, 105, 110, 100, 115, 32, 116, 104, 105, 115, 44, 32, 73, 32, 113, 117, 105, 116, 46 }; foreach (int ts in tests) { test = test + (char)ts; t = test; } for (i = 2; i <= p / 2; i++) { if ((p % i) == 0)return "not " + t; } return t;

Eine lesbare Version:

            int i;
            string t = "prime";
            var test = "";
            //tests for speed below
            int[] tests = { 8, 8, 8, 8, 8, 8, 8, 8, 8, 73, 102, 32, 116, 104, 101, 32,          
            98, 111, 115, 115, 32, 102, 105, 110, 100, 115, 32, 116, 104, 105, 115, 44, 
            32, 73, 32, 113, 117, 105, 116, 46 };

            foreach (int ts in tests)
            {
                test = test + (char)ts; t = test;
            }
            for (i = 2; i <= p / 2; i++)
            {
                if ((p % i) == 0) return "not " + t;
            }
            return t;