En dépit de votre protestation, votre patron vous a mis au travail sur un programme qui prend en entrée un seul entier non signé et affiche la chaîne "prime" si cet entier est premier et "pas premier" s'il ne l'est pas. Vous pouvez choisir la langue dans laquelle vous le faites, tant que le programme résultant est court; votre patron apprécie beaucoup le faible nombre de personnages. (Il comptera manuellement les caractères après avoir imprimé le code source.)

Donc, vous feriez mieux de commencer, le plus petit nombre de personnages gagne.

La partie amusante

Ceci est juste entre vous et moi, mais votre programme devrait également être valable dans une autre langue. Dans cette langue cependant, il convient d’afficher la chaîne "Si le chef trouve cela, j’arrête". Assurez-vous que votre patron ne comprend pas qu'il y a une insulte cachée lors de la lecture répétée du code, car il oublie s'il a déjà compté jusqu'à 17 ou 18. Pour cette raison, vous ne pouvez utiliser aucun des mots suivants: "le patron trouve cet arrêt" dans une partie du code, ni utiliser des anagrammes de ces 5 mots.

Bonus challenge pour lequel j'ai créé une prime

Ecrivez un programme qui ressemble réellement à ça, il résout simplement la première question et ne semble pas contenir de caractères inutiles. Cela inclut les commentaires et les segments de code qui ne contribuent évidemment à rien. Idéalement, un profane croirait que votre programme est en réalité aussi bref que possible sans être ingérable. Un commentaire utile ici et là, ça va.

Les règles du challenge bonus sont un peu plus lâches, au lieu d'être jugées sur des critères facilement mesurables, votre programme sera jugé davantage sur la manière dont il est interprété pour moi (et les votants bien sûr).

Je serai le dernier juge de l’entrée qui mérite le plus cette prime.

Modifier:

Après quelques minutes de comptage par votre chef, il a demandé à l’un de vos collègues d’écrire un programme de comptage de caractères pour lui. Ainsi, même les personnages qui ne sont pas visibles comptent pour votre nombre de personnages.

CJam ( GolfScript ), 60 59 octets

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

Merci à @mnbvmar pour le golf d'un octet!

Comment ça marche (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. ";

Essayez-le en ligne!

Comment ça marche (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.

Essayez-le en ligne!

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

Identifie les nombres premiers avec Python 2 , vous pose des problèmes avec Python 3 .

Prime

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

Essayez-le avec Python 2 ou Python 3 ! (Contrairement à la version golf ci-dessus, les rôles ont été modifiés: Python 3 est l'identificateur du nombre premier. Python 2 contient l'œuf de Pâques.)

S'il vous plaît, excusez mon mauvais anglais dans le texte d'aide! ;)

Et j'utilise le mot "quitter". Mais d’une manière ou d’une autre, j’ai besoin de décrire la fin de mon programme. ;)

Soumission de bonus (C / C ++ 11)

Les tests de primalité utilisant la méthode naïve habituelle sont tellement courants. C'est pourquoi j'ai inventé une toute nouvelle méthode naïve randomisée! Ce test est le suivant:

1. Choisissez n'importe quel entier d au hasard. Il ne doit pas être inférieur à 2 et supérieur à un peu plus sqrt(n).
2. Si d est un diviseur de n , la sortie not prime.
3. Si nous avons fait ce 20sqrt(n)temps de test , la sortie prime, sinon répétez.

Si le nombre est composite, il n'y a que très peu de probabilité (environ 10 ^-9 ) que cela ne fonctionne pas. Bien sûr, je ne pense pas que le générateur de nombres pseudo-aléatoires C / C ++ soit assez puissant. C'est pourquoi j'utilise mon propre générateur LFSR 256 bits !

#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 fonctionne correctement. Cependant, le compilateur C semble sortir un programme défectueux pour n> 2 ...

Remarque : rappelez-vous que C a besoin de l’ -lmoption (link math library) pour pouvoir compiler correctement.

Regardez max_rangevariable. Le mot clé C ++ 11 se autorésout en un "type correspondant" - dans ce cas double. Cependant, en C, il est défini comme un modificateur de variable (tel staticquel) - il ne définit pas le type. Ainsi, max_rangetype est un type C par défaut, c'est-à-dire int. Lorsque nous "essayons" de multiplier cette variable par 1.11111, la valeur C est mise "à zéro" de façon "intempestive" lors de la division par 100000. Nous obtenons un intervalle incorrect de nombres aléatoires à générer et LFSR, après avoir procédé à son état interne, génère une erreur décharge de la graine. C'est "accidentellement" le message Si le patron trouve cela, je quitte. \ N

Si vous trouvez la sortie défectueuse suivante:

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

incorrect, il suffit de supprimer la fprintfligne appropriée .

Mathematica / Brainfuck, 260

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

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

Essayez Golfscript ici et Javascript ici .

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

Je dirais que c'est incroyablement proche de ces solutions Mathematica qui, après tout, ont un contrôle intégré pour les nombres premiers.

Edit: Merci à Peter pour avoir enregistré deux autres six octets!

Voici quelques détails:

• La première 1.est nécessaire car ce qui suit //est un commentaire en Javascript, mais effectue deux fois la division en Golfscript. Cela provoquera une erreur si rien ne se trouve sur la pile, nous devons donc lui attribuer deux nombres. Incidemment, 1.est une syntaxe parfaitement valide en Javascript et sera simplement ignorée.
• "…"{(}%prend la chaîne, décrémente leurs valeurs de code de caractère de un et la pousse comme une chaîne. Cela se traduit par la chaîne que nous devons imprimer.
• ' démarre une chaîne dans Golfscript qui, par défaut, s'étend sur plusieurs lignes, de sorte que le code Javascript ci-dessous ne soit placé que dans la chaîne.
• Vient ensuite le code Javascript, qui utilise une approche assez connue pour détecter les nombres premiers au moyen d’expressions régulières.
• ';#'ferme la chaîne multiligne dans Golfscript, la supprime puis ignore le reste de la ligne. En Javascript, il s'agit simplement d'un littéral de chaîne qui sera ignoré.

C ++ / C99 / C90 - 248

Le code fonctionnera bien en C90, mais peut montrer quelque chose d'autre en C99 / C ++.

Non-golfé pour plus de clarté:

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

Comment cela fonctionne: C90 ne reconnaissant pas les commentaires sur une seule ligne, la chaîne du problème n'est plus multipliée par zéro.

CJam / Ruby, 132 95 91 87

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

Ma solution précédente était nettement sur-conçue; Celui-ci a été fortement inspiré par la solution de Martin Büttner, comprenant notamment le fait que la #bytesméthode peut apparemment prendre un bloc.

Comment ça marche?

Ruby comment character ( #) est l'opérateur d'exponentiation dans CJam, nous aurons donc besoin d'au moins deux nombres sur la pile avant de commencer, mais deux nombres nus ( 0 0) sont une erreur de syntaxe dans Ruby. L’un est bon, cependant, et, utilement, les nombres Ruby peuvent contenir des traits de soulignement comme séparateurs ( 1_234). _est l'opérateur de duplication de CJam, nous devons donc faire apparaître deux fois ( ;;) une fois que nous sommes à l'intérieur du commentaire. limplit une ligne à partir de l'entrée standard, la convertit en un entier, la saute et indique si elle est première ou non.

Pour entrer en mode Ruby, nous ouvrons une chaîne et continuons sur la ligne suivante afin que nous ne soyons plus dans le commentaire Ruby (ainsi, la nouvelle ligne est significative et doit être comptée). Chaque caractère du message est décodé et imprimé, puis nous commençons un autre commentaire Ruby afin de pouvoir fermer en toute sécurité la chaîne CJam avant de l'écraser. Ce qui reste sur la pile est de savoir si l'entrée était bonne ou non, ce qui sera imprimé à la fin du programme CJam.

CJam / Whitespace, 353 caractères (25 significatifs une fois imprimés)

Compte tenu de la nature sournoise du défi et du fait que le patron imprimera nos programmes afin de compter les personnages, j'ai accepté la suggestion de faire une solution impliquant Whitespace .

Contrairement à ma précédente affirmation, le programme Whitespace le plus court possible, qui affiche "Si le patron le trouve, j’arrête." 372 caractères, celui-ci le fait en 330. L'astuce consiste à utiliser l' copyinstruction qui vous permet de sélectionner des caractères répétés quelque part sur la pile au lieu de transmettre toutes les valeurs ASCII, qui seront toujours beaucoup plus grandes et nécessiteront donc davantage d'espaces. et des onglets à encoder. Voici une représentation pseudo-assemblée du programme pour les curieux:

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

Soumission de prix en prime (Perl / B? F? N? E-? 3)

Edit: Au départ, j’avais oublié d’imprimer la phrase, puis j’ai remarqué qu’elle l’imprimerait dans l’ordre inverse. J'ai remarqué cela après avoir été fait. J'étais sur le point de tuer un chaton, mais je l'ai réparé maintenant.

Ce n’est plus une mince affaire à présent, mais je pense que le rendre peu suspect et court est une tâche ardue. J'ai principalement réutilisé une de mes soumissions golfées, mais dans celle-ci, je dirais que la deuxième langue est vraiment difficile à repérer.

Si le patron le trouve, je démissionne vraiment, car je ne pourrai jamais l'insulter secrètement et si je ne peux pas le faire, à quoi ça sert?

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

Flexion et violation des règles:

• J'utilise le mot "le" ici, mais ce n'est pas le "le" qui est imprimé. Techniquement, il est peut-être invalide. Je vais laisser le PO décider si les règles doivent être aussi strictes pour le challenge bonus. Si oui, alors ainsi soit-il.
• Les règles indiquent que je ne peux pas utiliser certains mots, mais que nous lisons de gauche à droite, je suppose donc que les mots écrits verticalement sont valides.
• Je ne sais pas du tout comment j'ai toujours eu ce travail, vu les choses terribles que j'écris dans les commentaires. Je veux dire: des énigmes, vraiment?

Mathematica / Ruby, 115 106 octets

La partie Mathematica a été légèrement inspirée par la soumission de Peter Olson, mais la polyglotte avec Ruby est un peu plus élaborée ici.

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

Ruby fonctionne, car les deux #commentent tout ce qui est Mathematica. La raison pour laquelle Mathematica fonctionne est un peu plus intéressante. Le code que je veux exécuter est:

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

Mais ce n'est pas valide Ruby, donc je dois ajouter un #quelque part. #est le paramètre de Mathematica pour les fonctions anonymes. Donc, je mets #à l'avant, ce qui multiplie l'argument avec le résultat du If. Oui, cela sera multiplié par une ficelle , peu importe ce que cela signifie. Ensuite, je transforme cela en une fonction anonyme &et l'appelle immédiatement avec argument 1. Mathematica est assez intelligent pour savoir que la multiplication par 1 est toujours l’identité et n’exporte que la chaîne. Ensuite, le code Ruby est simplement placé dans un commentaire de bloc.

C (Soumission Bonus)

La version C est un vérificateur principal, tableau d'entrée en haut. Essayez de deviner quelle langue donne If the boss finds this, I quit.(ce n'est pas un espace).

// 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'autre langue:

Brainfuck . Exécuter ceci en tant que brainfuck avec un seul nombre en entrée produira la chaîne appropriée. Plus d’une entrée, et vous devrez vous assurer que les entrées du programme brainfuck sont des octets nuls.

Perl / Befunge-93 (108 106 110 )

Ma deuxième soumission, juste parce que. Utilise également des expressions régulières. Je parie qu'il y a un meilleur choix que Perl, par exemple Octave, mais je ne savais pas comment imprimer conditionnellement de manière brève.

J'abuse de la règle pour que la chaîne soit imprimée, car j'évite les anagrammes en la scindant en plusieurs chaînes.

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

Le numéro à vérifier provient de stdin.

• Edit: j'ai écrit "mon" au lieu de "le" accidentellement, la réparation a coûté +1 octet.
• Edit: utiliser ifau lieu de unless4 octets sauvegardés.
• Edit: Oublié "le", diviser celui-ci coûte également +2 octets.

Lua / PBrain (Brainf * ck procédural) - 813

Heh ... Désolé, j'ai été pris au piège en essayant d'être sournois. PBrain est comme BF, mais il vous permet de déclencher et de définir des blocs réutilisables de code BF. Son utilisation était complètement 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 octets (69 sans les commentaires)

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

Ceci utilise un algorithme très simple (ie inefficace). Lorsqu'il est exécuté avec rot13 (ce n'est pas un langage de programmation), il génère la phrase requise (avec d'autres non-sens).

Le pire, c’est que les commentaires énoncent une évidence et sont de toute façon plutôt inutiles.

C'est un polyglotte d'une autre manière, car il contient l'anglais et "l'espéranto". J'espère que le patron n'est pas un polyglotte.

05AB1E / Jelly , 28 octets

Pas une, mais DEUX langues de golf!

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

Explication dans 05AB1E:

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

Explication en gelée:

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

Essayez-le en ligne! (Jelly) Essayez-le en ligne! (05AB1E)

Python, 403 octets

Ceci est destiné au challenge bonus. Les commentaires ne comptent pas dans le 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"

Les tests au bas du code impriment:

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

Ce nombre entier maximum que j'ai défini (mi) cache le secret. Si converti en hexadécimal, la représentation en lettres ASCII de tous les deux chiffres de l'hexagone indique "Si le boss le trouve, je quitte." La partie sournoise utilise la fonction chr. Si le patron sait ce que cela fait et regarde assez attentivement, il saura que le code cache un message secret. Cependant, je l'ai un peu obscurci et j'ai fourni suffisamment d'explications à l'ensemble de l'entier max integer pour assurer, espérons-le, que c'est une partie légitime du programme.

Notez que pour la plupart des paramètres, cela fonctionne comme le veut le patron, mais si l’entrée n’est pas un entier ou si le nombre est supérieur à mi, p renvoie l’erreur qui contient la chaîne masquée. J'aurais pu mettre un appel d'impression dans la fonction, mais je pensais que son apparence serait plus réelle si elle était renvoyée.

C # - 288

Certainement pas le plus court, mais cela pourrait passer par beaucoup de patrons:

 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;

Une version lisible:

            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;