Nonostante la tua protesta, sei stato messo a lavorare dal tuo capo su un programma che accetta un singolo intero senza segno come input e stampa la stringa "primo" se quell'intero è primo e "non primo" se non lo è. Puoi scegliere in quale lingua farlo, purché il programma risultante sia breve; il tuo capo apprezza molto un basso numero di personaggi. (Conterà effettivamente i caratteri manualmente dopo aver stampato il codice sorgente.)

Quindi è meglio che ci riesca, vince il numero di personaggi più basso.

La parte divertente

Questo è solo tra te e me, ma il tuo programma dovrebbe essere valido anche in un'altra lingua. In questa lingua, però, dovrebbe stampare la stringa "Se il capo lo trova, me ne vado". Assicurati che il tuo capo non capisca che c'è un insulto nascosto quando legge il codice più e più volte mentre continua a dimenticare se aveva contato fino a 17 o 18 finora. Per questa ragione non puoi usare nessuna delle parole in "il boss trova questo smesso" in una parte del codice, né puoi usare e anagrammi di quelle 5 parole.

Sfida bonus per la quale ho creato una taglia

Scrivi un programma che in realtà sembra che risolva la prima domanda all'occhio non allenato e non sembra contenere caratteri non necessari. Ciò include commenti e segmenti di codice che ovviamente non contribuiscono a nulla. Idealmente, un laico crede che il tuo programma sia effettivamente il più breve possibile senza essere ingestibile. Un commento utile qui e lì va bene però.

Le regole per la sfida bonus sono un po 'più allentate, invece di essere giudicate in base a criteri facilmente misurabili, il tuo programma sarà giudicato più da come viene da me (e dagli elettori ovviamente)

Sarò il giudice finale di quale voce si avvicina di più al meritare questa generosità.

Modificare:

Dopo alcuni minuti del conteggio del tuo capo, uno dei tuoi colleghi ha scritto un programma di conteggio dei personaggi per lui. Quindi anche i personaggi che non sono visibili contano ai fini del conteggio dei personaggi.

CJam ( GolfScript ), 60 59 byte

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

Grazie a @mnbvmar per il golf off 1 byte!

Come funziona (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. ";

Provalo online!

Come funziona (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.

Provalo 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])

Identifica i numeri primi con Python 2 , ti mette nei guai con Python 3 .

indennità

__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])

Provalo con Python 2 o Python 3 ! (Contrariamente alla versione golf sopra i ruoli cambiati: Python 3 è l'identificatore del numero primo. Python 2 contiene l'uovo di Pasqua.)

Per favore, scusa il mio pessimo inglese nel testo di aiuto! ;)

E io uso la parola "esci". Ma in qualche modo devo descrivere quando termina il mio programma. ;)

Invio bonus (C / C ++ 11)

I test di primalità utilizzando il solito metodo ingenuo sono così mainstream. Ecco perché ho inventato un nuovo metodo ingenuo randomizzato! Questo test è il seguente:

1. Scegli un numero intero d a caso. Non deve essere inferiore a 2 e maggiore di un po 'più di sqrt(n).
2. Se d è un divisore di n , output not prime.
3. Se abbiamo effettuato questi 20sqrt(n)tempi di test , output prime, altrimenti ripetere.

Se il numero è composto, ci sono solo poche probabilità (circa 10 ^-9 ) che non funzioni. Naturalmente, non credo che il generatore di numeri pseudocasuali C / C ++ sia abbastanza potente. Ecco perché uso il mio generatore LFSR a 256 bit !

#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 funziona correttamente. Tuttavia, il compilatore C sembra emettere un programma difettoso per n> 2 ...

Nota : ricordare che C necessita -lmdell'opzione (link libreria matematica) per compilare correttamente.

Guarda max_rangevariabile. La parola chiave C ++ 11 si autorisolve in un "tipo di corrispondenza", in questo caso double. Tuttavia, in C è definito come modificatore di variabili (così com'è static) - non definisce il tipo. Quindi max_rangetype è un tipo C predefinito, cioè int. Quando "proviamo" a moltiplicare questa variabile per 1.11111, in C viene azzerato "involontariamente" durante la divisione per 100000. Otteniamo un intervallo errato di numeri casuali da generare e LFSR dopo aver proceduto il suo stato interno genera un errore, producendo il file binario discarica del seme. Questo è "accidentalmente" Il messaggio Se il capo lo trova, io smetto. \ N

Se trovi il seguente output difettoso:

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

errato, basta rimuovere la fprintfriga appropriata .

Mathematica / Brainfuck, 260

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

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

Prova Golfscript qui e Javascript qui .

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

Direi che è incredibilmente vicino a quelle soluzioni Mathematica che, dopotutto, hanno un controllo integrato per i numeri primi.

Modifica: grazie a Peter per aver salvato altri due sei byte!

Ecco alcuni dettagli:

• Il primo 1.è necessario perché il seguente //è un commento in Javascript, ma esegue la divisione due volte in Golfscript. Questo errore si spegne se non c'è nulla nello stack, quindi dobbiamo dargli due numeri. Per inciso, 1.è una sintassi perfettamente valida in Javascript e verrà semplicemente ignorata.
• "…"{(}%prende la stringa, decrementa i loro valori del codice carattere di uno e lo spinge come una stringa. Ciò comporta la stringa che dobbiamo stampare.
• ' avvia una stringa in Golfscript che per impostazione predefinita si estende su più righe, facendo in modo che Javascript sotto venga inserito solo nella stringa.
• Il prossimo è il codice Javascript, che utilizza un approccio piuttosto noto per rilevare i numeri primi attraverso le espressioni regolari.
• ';#'chiude la stringa multilinea in Golfscript, la scarta e quindi ignora il resto della linea. In Javascript, questa è semplicemente una stringa letterale che verrà ignorata.

C ++ / C99 / C90 - 248

Il codice verrà eseguito correttamente in C90, ma potrebbe mostrare qualcos'altro in C99 / C ++.

Non golfato per chiarezza:

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

Come funziona: poiché C90 non riconosce i commenti a riga singola, la stringa del problema non viene più moltiplicata per zero.

CJam / Ruby, 132 95 91 87

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

La mia precedente soluzione era stata notevolmente ingegnerizzata; questo è stato fortemente ispirato dalla soluzione di Martin Büttner, inclusa la sua consapevolezza che il #bytesmetodo può apparentemente prendere un blocco.

Come funziona?

Il carattere di commento di Ruby ( #) è l'operatore esponenziale in CJam, quindi avremo bisogno di almeno due numeri nello stack prima di iniziare, ma due numeri nudi ( 0 0) è un errore di sintassi in Ruby. Uno va bene, però, e, utile, i numeri di Ruby possono contenere trattini bassi come separatori ( 1_234). _è l'operatore di duplicazione di CJam, quindi abbiamo bisogno di pop due volte ( ;;) una volta all'interno del commento. limplegge una riga dallo standard input, la converte in un numero intero, la apre e spinge indipendentemente dal fatto che sia o meno primo.

Per entrare in modalità Ruby, apriamo una stringa e proseguiamo sulla riga successiva in modo da non essere più nel commento di Ruby (quindi, la nuova riga è significativa e deve essere contata). Ogni carattere del messaggio viene decodificato e stampato, quindi iniziamo un altro commento di Ruby in modo da poter chiudere in sicurezza la stringa CJam prima di farla scoppiare. Ciò che rimane nello stack è se l'input è stato o meno primo, che viene stampato al termine del programma CJam.

CJam / Whitespace, 353 (25 significativi se stampati)

Data la natura subdola della sfida e il fatto che il capo stamperà i nostri programmi per contare i personaggi, ho accettato il suggerimento di fare una soluzione che coinvolga Whitespace .

Contrariamente alla mia precedente affermazione che il programma Whitespace più breve possibile che stampa "Se il capo lo trova, me ne vado". sarebbe 372 caratteri, questo lo fa in 330. Il trucco è usare l' copyistruzione per strappare i caratteri ripetuti da qualche parte dello stack piuttosto che spingere tutti i valori ASCII, che saranno sempre molto più grandi e quindi richiedono più spazi e schede da codificare. Ecco una rappresentazione pseudo-assembleare del programma per i curiosi:

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

Presentazione del premio bonus (Perl / B? F? N? E-? 3)

Modifica: inizialmente avevo dimenticato di stampare effettivamente la frase e poi ho notato che l'avrebbe stampata in ordine inverso. Ho notato questo dopo aver finito. Stavo per uccidere un gattino, ma l'ho risolto ora.

Questo non è più breve, ma credo che renderlo insospettabile e breve sia un compito estremamente difficile. Ho principalmente riutilizzato una delle mie attuali proposte golfistiche, ma in questa direi che la seconda lingua è davvero difficile da individuare.

Se il capo lo trova, smetto davvero, perché non sarò mai in grado di insultarlo segretamente e se non posso farlo, che senso ha?

# ^ 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"

Bending and Breaking of the Rules:

• Sto usando la parola "the" lì dentro, ma non è il "the" che viene stampato. Potrebbe essere tecnicamente non valido, lascerò decidere all'OP se le regole devono essere così rigide per la sfida bonus. Se è così, allora così sia.
• Le regole affermano che non posso usare determinate parole, ma leggiamo da sinistra a destra, quindi presumo che avere le parole scritte in verticale sia valido.
• Non ho idea di come ho ancora ottenuto questo lavoro, vedendo le cose terribili che scrivo nei commenti. Voglio dire: indovinelli, davvero?

Mathematica / Ruby, 115 106 byte

La parte di Mathematica è stata leggermente ispirata dalla proposta di Peter Olson, ma il poliglottaggio con Ruby è un po 'più elaborato qui.

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

Ruby funziona, perché i due #commentano tutto ciò che è Mathematica. Il motivo per cui Mathematica funziona è un po 'più interessante. Il codice che voglio eseguire è:

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

Ma questo non è valido Ruby, quindi devo aggiungere un #posto. #è il parametro di Mathematica per funzioni anonime. Quindi ho messo #in primo piano, che moltiplica l'argomento con il risultato di If. Sì, lo moltiplicherà con una stringa , qualunque cosa significhi. Poi lo trasformo in una funzione anonima con &e la chiamo immediatamente con argomento 1. Bene, Mathematica è abbastanza intelligente da sapere che la moltiplicazione per 1 è sempre l'identità e genera solo la stringa. Successivamente, il codice Ruby viene semplicemente inserito in un commento a blocchi.

C (Invio bonus)

La versione C è un controllore primario, array di input in alto. Prova a indovinare quale linguaggio produce If the boss finds this, I quit.(non è spazio bianco).

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

L'altra lingua:

Brainfuck . Eseguendolo come brainfuck con un solo numero di input, verrà emessa la stringa appropriata. Più di un input e dovrai assicurarti che l'input per il programma brainfuck sia null byte.

Perl / Befunge-93 (108 106 110 )

La mia seconda presentazione, solo perché. Utilizza anche espressioni regolari. Scommetto che c'è una scelta migliore di Perl, ad esempio Octave, ma non sono riuscito a capire come stampare in modo condizionale in breve tempo.

Sto abusando della regola per la stampa della stringa mentre evito gli anagrammi dividendola in più stringhe.

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

Il numero da controllare è preso dallo stdin.

• Modifica: ho scritto "mio" invece di "il" per errore, riparandolo costava 1 byte.
• Modifica: usando ifinvece di unless4 byte salvati.
• Modifica: Dimenticato "il", dividendo anche quello costato +2 byte.

Lua / PBrain (procedurale Brainf * ck) - 813

Heh ... Mi dispiace, sono stato preso nel tentativo di essere subdolo. PBrain è proprio come BF, ma consente di attivare e definire blocchi riutilizzabili di codice BF. L'uso era completamente inutile.

--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 byte (69 non contando i commenti)

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

Questo utilizza un algoritmo molto semplice (cioè inefficiente). Quando eseguito con rot13 (probabilmente non un linguaggio di programmazione), produce la frase richiesta (insieme ad altre sciocchezze).

La parte peggiore è che i commenti affermano l'ovvio e sono comunque abbastanza inutili.

Questo è un poliglotta in un altro modo, contenente sia inglese che "esperanto". Spero che il capo non sia lui stesso un poliglotta.

05AB1E / Jelly , 28 byte

Non uno, ma DUE lingue per il golf!

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

Spiegazione 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

Spiegazione in gelatina:

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

Provalo online! (Gelatina) Provalo online! (05AB1E)

Python, 403 byte

Questo è destinato alla sfida bonus. I commenti non contano per il conteggio parziale.

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

I test in fondo al codice stampano:

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

Quel numero intero massimo che ho definito (mi) nasconde il segreto. Se convertito in esadecimale, la rappresentazione in lettere ASCII di ogni due cifre di esadecimale fa "Se il boss trova questo, ho lasciato." La parte subdola sta usando la funzione chr. Se il capo sa cosa fa e guarda abbastanza attentamente, saprà che il codice nasconde un messaggio segreto. Tuttavia l'ho offuscato un po 'e ho fornito una spiegazione sufficiente all'intera cosa del numero intero massimo per assicurare, spero, al capo che sia una parte legittima del programma

Nota che per la maggior parte dei parametri funziona come vuole il capo, ma se l'input non è un numero intero o il numero è in qualche modo più grande di mi, p restituisce l'errore che contiene la stringa nascosta. Avrei potuto inserire una chiamata di stampa all'interno della funzione, ma ho pensato che sarebbe stato più reale se fosse stato restituito.

C # - 288

Certamente non il più breve, ma potrebbe passare da molti boss:

 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;

Una versione leggibile:

            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;