A pesar de su protesta, su jefe lo puso a trabajar en un programa que toma un solo entero sin signo como entrada e imprime la cadena "primo" si ese entero es primo y "no primo" si no lo es. Puede elegir en qué idioma hacer esto, siempre que el programa resultante sea corto; tu jefe aprecia mucho el bajo recuento de caracteres. (Realmente contará manualmente los caracteres después de imprimir el código fuente).

Así que es mejor que lo hagas, gana el recuento de caracteres más bajo.

La parte divertida

Esto es solo entre usted y yo, pero su programa también debe ser válido en otro idioma. Sin embargo, en este lenguaje, debería imprimir la cadena "Si el jefe encuentra esto, renuncio". Asegúrate de que tu jefe no descubra que hay un insulto oculto al leer el código una y otra vez, ya que siempre se olvida si había contado hasta 17 o 18 hasta ahora. Por esa razón, no puede usar ninguna de las palabras en "el jefe encuentra esta salida" en parte del código ni puede usar anagramas de esas 5 palabras.

Desafío de bonificación para el que he creado una recompensa

Escriba un programa que realmente parezca que solo resuelve la primera pregunta para el ojo inexperto y no parece contener caracteres innecesarios. Esto incluye comentarios y segmentos de código que obviamente no aportan nada. Idealmente, un laico creería que su programa es en realidad lo más corto posible sin ser inmanejable. Sin embargo, un comentario útil aquí y allá está bien.

Las reglas para el desafío de la bonificación son un poco más flexibles, en lugar de ser juzgadas según criterios fácilmente medibles, su programa será juzgado más sobre cómo se me presenta (y a los votantes, por supuesto)

Seré el juez final de cuál entrada se acerca más a merecer esta recompensa.

Editar:

Después de unos minutos de contar a tu jefe, hizo que uno de tus colegas escribiera un programa de conteo de personajes para él. Por lo tanto, incluso los personajes que no son visibles cuentan para tu personaje.

CJam ( GolfScript ), 60 59 bytes

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

¡Gracias a @mnbvmar por jugar golf en 1 byte!

Cómo funciona (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. ";

Pruébalo en línea!

Cómo funciona (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.

Pruébalo en línea!

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 números primos con Python 2 , te mete en problemas con Python 3 .

Prima

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

¡Pruébalo con Python 2 o Python 3 ! (En contraste con la versión de golf anterior, los roles cambiaron: Python 3 es el identificador de número primo. Python 2 contiene el huevo de Pascua).

¡Por favor, disculpe mi mal inglés en el texto de ayuda! ;)

Y uso la palabra "dejar de fumar". Pero de alguna manera necesito describir cuándo termina mi programa. ;)

Envío de bonificación (C / C ++ 11)

La prueba de primalidad utilizando el método ingenuo habitual es muy convencional. ¡Es por eso que he inventado un nuevo método ingenuo aleatorizado! Esta prueba es la siguiente:

1. Elija cualquier número entero d al azar. No debe ser menor que 2 y mayor que un poco más que sqrt(n).
2. Si d es un divisor de n , salida not prime.
3. Si realizamos estos 20sqrt(n)tiempos de prueba , salida prime, de lo contrario repita.

Si el número es compuesto, hay muy poca probabilidad (alrededor de 10 ^-9 ) de que no funcione. Por supuesto, no creo que el generador de números pseudoaleatorios C / C ++ sea lo suficientemente potente. ¡Es por eso que uso mi propio generador LFSR de 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 funciona correctamente. Sin embargo, el compilador de C parece estar generando un programa defectuoso para n> 2 ...

Nota : recuerde que C necesita la -lmopción (biblioteca matemática de enlaces) para compilar con éxito.

Mira la max_rangevariable. La palabra clave C ++ 11 se autoresuelve en un "tipo coincidente", en este caso double. Sin embargo, en C se define como un modificador variable (como staticestá), no define el tipo. Por lo tanto, el max_rangetipo es un tipo C predeterminado, es decir int. Cuando "intentamos" multiplicar esta variable por 1.11111, en C se pone "involuntariamente" a cero durante la división por 100000. Obtenemos un intervalo incorrecto de números aleatorios que se generarán y LFSR después de continuar su estado interno genera un error, generando el binario vertedero de la semilla. Eso es "accidentalmente" El mensaje Si el jefe encuentra esto, lo dejo. \ N

Si encuentra la siguiente salida defectuosa:

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

incorrecto, simplemente elimine la fprintflínea apropiada .

Mathematica / Brainfuck, 260

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

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

Pruebe Golfscript aquí y Javascript aquí .

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

Diría que es sorprendentemente cercano a esas soluciones de Mathematica que, después de todo, tienen un cheque incorporado para números primos.

Editar: ¡ Gracias a Peter por guardar otros dos seis bytes!

Aquí hay algunos detalles:

• El primero 1.es necesario porque el siguiente //es un comentario en Javascript, pero realiza la división dos veces en Golfscript. Esto generará un error si no hay nada en la pila, por lo que debemos darle dos números. Por cierto, 1.es una sintaxis perfectamente válida en Javascript y simplemente será ignorada.
• "…"{(}%toma la cadena, disminuye sus valores de código de caracteres en uno y la empuja como una cadena. Esto da como resultado la cadena que necesitamos imprimir.
• ' inicia una cadena en Golfscript que, de manera predeterminada, se extiende sobre varias líneas, lo que hace que el Javascript a continuación solo se coloque en la cadena.
• El siguiente es el código Javascript, que utiliza un enfoque algo conocido para detectar números primos a través de expresiones regulares.
• ';#'cierra la cadena de varias líneas en Golfscript, la descarta y luego ignora el resto de la línea. En Javascript, esto es simplemente un literal de cadena que será ignorado.

C ++ / C99 / C90 - 248

El código se ejecutará bien en C90, pero puede mostrar algo más en C99 / C ++.

Sin golf para mayor claridad:

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

Cómo funciona esto: como C90 no reconoce los comentarios de una sola línea, la cadena del problema ya no se multiplica por cero.

CJam / Ruby, 132 95 91 87

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

Mi solución anterior fue significativamente sobre ingeniería; Este se inspiró en gran medida en la solución de Martin Büttner, incluida su comprensión de que el #bytesmétodo aparentemente puede tomar un bloqueo.

¿Como funciona?

El carácter de comentario de Ruby ( #) es el operador de exponenciación en CJam, por lo que necesitaremos al menos dos números en la pila antes de comenzar, pero dos números desnudos ( 0 0) es un error de sintaxis en Ruby. Sin embargo, uno está bien y, útilmente, los números de Ruby pueden contener guiones bajos como separadores ( 1_234). _es el operador de duplicación de CJam, por lo que debemos hacer pop dos veces ( ;;) una vez que estemos dentro del comentario. limplee una línea desde la entrada estándar, la convierte en un número entero, la saca y empuja si es primo o no.

Para ingresar al modo Ruby, abrimos una cadena y continuamos en la siguiente línea para que ya no estemos en el comentario de Ruby (por lo tanto, la nueva línea es significativa y debe contarse). Cada carácter del mensaje se decodifica e imprime, y luego comenzamos otro comentario de Ruby para que podamos cerrar con seguridad la cadena de CJam antes de abrirla. Lo que queda en la pila es si la entrada fue primordial o no, lo que se imprime al finalizar el programa CJam.

CJam / Whitespace, 353 caracteres (25 significativos cuando se imprimen)

Dada la naturaleza encubierta del desafío y el hecho de que el jefe imprimirá nuestros programas para contar los personajes, acepté la sugerencia de hacer una solución que involucrara a Whitespace .

Contrariamente a mi afirmación anterior de que el programa Whitespace más corto posible que imprime "Si el jefe encuentra esto, renuncio". serían 372 caracteres, este lo hace en 330. El truco consiste en utilizar la copyinstrucción para extraer caracteres repetidos de algún lugar de la pila en lugar de presionar todos los valores ASCII, que siempre serán mucho más grandes y, por lo tanto, requerirán más espacios y pestañas para codificar. Aquí hay una representación de pseudoensamblaje del programa para curiosos:

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

Envío de premio adicional (Perl / B? F? N? E-? 3)

Editar: Originalmente olvidé imprimir la oración y luego noté que la imprimiría en orden inverso. Me di cuenta de esto después de haber terminado. Estaba a punto de matar a un gatito, pero lo arreglé ahora.

Esto ya no es corto, pero creo que hacerlo poco útil y corto es una tarea extremadamente difícil. Principalmente he reutilizado una de mis presentaciones de golf reales, pero en esta diría que el segundo idioma es realmente difícil de detectar.

Si el jefe encuentra esto, realmente renuncio, porque nunca podré insultarlo en secreto y si no puedo hacerlo, ¿qué sentido tiene?

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

Doblar y romper las reglas:

• Estoy usando la palabra "the" allí, pero no es "the" lo que se imprime. Puede ser técnicamente inválido, dejaré que el OP decida si las reglas deben ser tan estrictas para el desafío de bonificación. Si es así, que así sea.
• Las reglas establecen que no puedo usar ciertas palabras, pero leemos de izquierda a derecha, por lo que asumo que las palabras escritas verticalmente es válido.
• No tengo idea de cómo conseguí este trabajo, viendo las cosas terribles que escribo en los comentarios. Quiero decir: acertijos, ¿en serio?

Mathematica / Ruby, 115106 bytes

La parte de Mathematica se inspiró ligeramente en la presentación de Peter Olson, pero la políglota con Ruby es un poco más elaborada aquí.

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

Ruby funciona, porque los dos #comentan todo lo que es Mathematica. La razón por la cual Mathematica funciona es un poco más interesante. El código que quiero ejecutar es:

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

Pero eso no es válido Ruby, así que necesito agregar un #lugar. #es el parámetro de Mathematica para funciones anónimas. Así que pongo #al frente, que multiplica el argumento con el resultado de If. Sí, lo multiplicará con una cadena , lo que sea que eso signifique. Luego convierto esto en una función anónima con &y lo llamo inmediatamente con argumento 1. Bueno, Mathematica es lo suficientemente inteligente como para saber que la multiplicación por 1 es siempre la identidad y solo genera la cadena. Luego, el código Ruby simplemente se coloca en un comentario de bloque.

C (Presentación de bonificación)

La versión C es un verificador principal, matriz de entrada en la parte superior. Trata de adivinar qué idioma produce If the boss finds this, I quit.(no es espacio en blanco).

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

El otro idioma:

Brainfuck . Ejecutar esto como brainfuck con solo un número de entrada generará la cadena adecuada. Más de una entrada, y tendrá que asegurarse de que la entrada al programa brainfuck sea bytes nulos.

Perl / Befunge-93 (108 106 110 )

Mi segunda presentación, solo porque. También usa expresiones regulares. Apuesto a que hay una mejor opción que Perl, por ejemplo, Octave, pero no pude encontrar la forma de imprimir condicionalmente de una manera corta.

Estoy abusando de la regla para que se imprima la cadena, ya que evito los anagramas al dividirla en varias cadenas.

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

El número a verificar se toma de stdin.

• Editar: escribí "mi" en lugar de "el" accidentalmente, arreglarlo costó +1 byte.
• Editar: usando en iflugar de unless4 bytes guardados.
• Editar: se olvidó de "el", dividiendo ese también costó +2 bytes.

Lua / PBrain (Brainf * ck procesal) - 813

Je ... Lo siento, me quedé atrapado tratando de ser tortuoso. PBrain es como BF, pero le permite activar y definir bloques reutilizables de código BF. Su uso era completamente innecesario.

--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 sin contar comentarios)

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

Esto utiliza un algoritmo muy simple (es decir, ineficiente). Cuando se ejecuta con rot13 (posiblemente no es un lenguaje de programación), produce la oración requerida (junto con otras tonterías).

La peor parte es que los comentarios dicen lo obvio y de todos modos son bastante inútiles.

Este es un políglota de otra manera, al contener inglés y "esperanto". Espero que el jefe no sea un políglota.

05AB1E / Jelly , 28 bytes

¡No uno, sino DOS idiomas de golf!

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

Explicación en 05AB1E:

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

Explicación en 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."

Pruébalo en línea! (Jelly) ¡ Pruébalo en línea! (05AB1E)

Python, 403 bytes

Esto está destinado para el desafío de bonificación. Los comentarios no cuentan para el 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"

Las pruebas en la parte inferior del código se imprimen:

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

Ese número entero máximo que definí (mi) esconde el secreto. Si se convierte en hexadecimal, la representación de la letra ASCII de cada dos dígitos del hexadecimal hace que "si el jefe encuentra esto, renuncio". La parte disimulada está usando la función chr. Si el jefe sabe lo que hace y está mirando con suficiente cuidado, sabrá que el código oculta un mensaje secreto. Sin embargo, lo ofusqué un poco y proporcioné suficiente explicación a todo el número entero máximo para, con suerte, asegurarle al jefe que es una parte legítima del programa.

Tenga en cuenta que para la mayoría de los parámetros funciona como lo desea el jefe, pero si la entrada no es un número entero o el número es de alguna manera mayor que mi, p devuelve el error que contiene la cadena oculta. Podría haber puesto una llamada de impresión dentro de la función, pero pensé que se vería más real si se devolviera.

C # - 288

Ciertamente no es el más corto, pero podría pasar por muchos jefes:

 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 versión legible:

            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;