Apesar do seu protesto, você foi contratado pelo seu chefe em um programa que usa um único número inteiro não assinado como entrada e imprime a string "prime" se esse número inteiro for prime e "not prime" se não for. Você pode escolher em qual idioma você faz isso, desde que o programa resultante seja curto; seu chefe aprecia muito uma baixa contagem de caracteres. (Ele realmente contará os caracteres manualmente depois de imprimir o código fonte.)

Então é melhor você chegar lá, a menor contagem de caracteres vence.

A parte divertida

Isso é apenas entre você e eu, mas seu programa também deve ser válido em outro idioma. Nesse idioma, porém, ele deve imprimir a string "Se o chefe encontrar isso, eu desisto". Certifique-se de que seu chefe não descubra que existe um insulto oculto ao ler o código repetidas vezes, pois ele esquece se tinha contado até 17 ou 18 até agora. Por esse motivo, você não pode usar nenhuma das palavras em "o chefe encontra essa opção" em parte do código, nem o uso de anagramas e essas 5 palavras.

Desafio de bônus pelo qual eu criei uma recompensa

Escreva um programa que realmente resolva a primeira pergunta para quem não é treinado e não pareça conter caracteres desnecessários. Isso inclui comentários e segmentos de código que obviamente não contribuem com nada. Idealmente, um leigo acreditaria que seu programa é realmente o mais curto possível sem ser incontrolável. Um comentário útil aqui e ali está bem.

As regras para o desafio do bônus são um pouco mais flexíveis, em vez de serem julgadas por critérios facilmente mensuráveis, seu programa será julgado mais sobre como isso acontece comigo (e com os eleitores, é claro)

Eu serei o juiz final cuja inscrição se aproxima mais de merecer essa recompensa.

Editar:

Depois de alguns minutos contando seu chefe, ele pediu que um de seus colegas escrevesse um programa de contagem de caracteres para ele. Assim, mesmo os personagens que não são visíveis contam para a contagem de caracteres.

CJam ( GolfScript ), 60 59 bytes

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

Obrigado a @mnbvmar por jogar fora um byte!

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

Experimente online!

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

Experimente 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 números primos com o Python 2 , e você cria problemas com o Python 3 .

Bônus

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

Experimente com Python 2 ou Python 3 ! (Ao contrário da versão de golfe acima, as funções foram alteradas: o Python 3 é o identificador do número principal. O Python 2 contém o ovo da Páscoa.)

Por favor, desculpe meu inglês ruim no texto de ajuda! ;)

E eu uso a palavra "sair". Mas de alguma forma eu preciso descrever quando meu programa termina. ;)

Envio de bônus (C / C ++ 11)

O teste de primazia usando o método ingênuo usual é tão comum. É por isso que eu inventei um novo método ingênuo e randomizado! Este teste é o seguinte:

1. Escolha qualquer número inteiro d aleatoriamente. Não deve ser menor que 2 e maior que um pouco mais que sqrt(n).
2. Se d é um divisor de n , produza not prime.
3. Se fizermos esse 20sqrt(n)tempo de teste , a saída será primerepetida.

Se o número for composto, há muito pouca probabilidade (cerca de 10 a ⁹ ) de que ele não funcione. Obviamente, não acredito que o gerador de números pseudo-aleatórios em C / C ++ seja poderoso o suficiente. É por isso que eu uso meu próprio gerador 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 corretamente. No entanto, o compilador C parece estar produzindo um programa defeituoso para n> 2 ...

Nota : lembre-se de que C precisa da -lmopção (vincular biblioteca matemática) para compilar com êxito.

Veja a max_rangevariável. A palavra-chave C ++ 11 autoresolve para um "tipo correspondente" - nesse caso double. No entanto, em C é definido como um modificador de variável (como staticé) - não define o tipo. Assim, max_rangetype é um tipo C padrão, ou seja int. Quando "tentamos" multiplicar essa variável por 1,11111, em C ela é zerada "não intencionalmente" durante a divisão por 100000. Obtemos um intervalo incorreto de números aleatórios a serem gerados e o LFSR após prosseguir com seu estado interno gera um erro, gerando um erro binário. despejo da semente. Isso é "acidentalmente". A mensagem Se o chefe encontrar isso, eu desisto. \ N

Se você encontrar a seguinte saída com defeito:

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

incorreto, basta remover a fprintflinha apropriada .

Mathematica / Brainfuck, 260

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

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

Experimente o Golfscript aqui e o Javascript aqui .

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

Eu diria que é chocantemente próximo das soluções Mathematica que, afinal, possuem uma verificação interna para números primos.

Edit: Obrigado a Peter por salvar outros dois seis bytes!

Aqui estão alguns detalhes:

• O primeiro 1.é necessário porque o seguinte //é um comentário em Javascript, mas realiza a divisão duas vezes no Golfscript. Isso resultará em erro se não houver nada na pilha, portanto, precisamos fornecer dois números. Aliás, 1.é uma sintaxe perfeitamente válida em Javascript e será apenas ignorada.
• "…"{(}%pega a string, diminui seus valores de código de caracteres em um e a empurra como uma string. Isso resulta na string que precisamos imprimir.
• ' inicia uma string no Golfscript que, por padrão, se estende por várias linhas, fazendo com que o Javascript abaixo seja inserido apenas na string.
• A seguir, está o código Javascript, que usa uma abordagem bastante conhecida para detectar números primos por meio de expressões regulares.
• ';#'fecha a seqüência de várias linhas no Golfscript, descarta-a e depois ignora o restante da linha. Em Javascript, isso é simplesmente uma literal de string que será ignorada.

C ++ / C99 / C90 - 248

O código será bem executado no C90, mas pode mostrar algo mais no C99 / C ++.

Sem golfe para maior clareza:

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

Como isso funciona: Como o C90 não reconhece comentários de linha única, a sequência do problema não é mais multiplicada por 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}#";

Minha solução anterior foi significativamente projetada em excesso; este foi fortemente inspirado pela solução de Martin Büttner, incluindo sua percepção de que o #bytesmétodo aparentemente pode levar um bloqueio.

Como funciona?

O caractere de comentário de Ruby ( #) é o operador de exponenciação no CJam, portanto, precisaremos de pelo menos dois números na pilha antes de começar, mas dois números simples ( 0 0) são um erro de sintaxe no Ruby. Porém, um é bom e, útil, os números Ruby podem conter sublinhados como separadores ( 1_234). _é o operador de duplicação do CJam, por isso precisamos aparecer duas vezes ( ;;) quando estivermos dentro do comentário. limplê uma linha da entrada padrão, a converte em um número inteiro, a exibe e pressiona se é ou não primo.

Para entrar no modo Ruby, abrimos uma string e continuamos na próxima linha para que não fiquemos mais no comentário Ruby (portanto, a nova linha é significativa e deve ser contada). Cada caractere da mensagem é decodificado e impresso e, em seguida, iniciamos outro comentário Ruby para que possamos fechar com segurança a string CJam antes de exibi-la. O que resta na pilha é se a entrada foi ou não pronta, impressa no final do programa CJam.

CJam / espaço em branco, 353 (25 significativos quando impressos) caracteres

Dada a natureza dissimulada do desafio e o fato de o chefe estar imprimindo nossos programas para contar os caracteres, aceitei a sugestão de fazer uma solução envolvendo o espaço em branco .

Contrariamente à minha afirmação anterior de que o programa Whitespace mais curto possível, que exibe "Se o chefe encontra isso, eu desisto". haveria 372 caracteres, este é o caso em 330. O truque é usar a copyinstrução para extrair caracteres repetidos de algum lugar da pilha, em vez de empurrar todos os valores ASCII, que sempre serão muito maiores e, portanto, exigirão mais espaços e guias para codificar. Aqui está uma representação de pseudo-montagem do programa para os 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

Envio de Prêmio de Bônus (Perl / B? F? N? E-? 3)

Editar: originalmente eu esqueci de imprimir a frase e notei que ela seria impressa na ordem inversa. Percebi isso depois de terminar. Eu estava prestes a matar um gatinho, mas consertei agora.

Isso não é mais curto, mas acredito que torná-lo não-suspeito e curto é uma tarefa difícil. Na maioria das vezes, reutilizei uma das minhas finalizações de golfe, mas nesta, eu diria que o segundo idioma é realmente difícil de detectar.

Se o chefe acha isso, eu realmente desisto, porque nunca poderei insultá-lo secretamente e, se não puder fazer isso, qual é o sentido?

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

Dobra e violação das regras:

• Estou usando a palavra "the" lá dentro, mas não é o "the" que é impresso. Pode ser tecnicamente inválido, deixarei o OP decidir se as regras devem ser rigorosas para o desafio do bônus. Se assim for, então que seja.
• As regras declaram que não posso usar determinadas palavras, mas lemos da esquerda para a direita, portanto, presumo que as palavras escritas verticalmente sejam válidas.
• Não tenho ideia de como ainda consegui esse emprego, vendo as coisas terríveis que escrevo nos comentários. Quero dizer: enigmas, realmente?

Mathematica / Ruby, 115 106 bytes

A parte do Mathematica foi levemente inspirada pela submissão de Peter Olson, mas a poliglota com Ruby é um pouco mais elaborada aqui.

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

Ruby funciona, porque os dois #comentam tudo o que é Mathematica. A razão pela qual o Mathematica funciona é um pouco mais interessante. O código que eu quero executar é:

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

Mas isso não é válido para Ruby, então preciso adicionar um em #algum lugar. #é o parâmetro do Mathematica para funções anônimas. Então eu coloquei #na frente, o que multiplica o argumento com o resultado do If. Sim, ele multiplicará isso por uma string , o que isso significa. Então eu transformo isso em uma função anônima &e chamo imediatamente de argumento 1. Bem, o Mathematica é inteligente o suficiente para saber que a multiplicação por 1 é sempre a identidade e apenas gera a string. Depois, o código Ruby é simplesmente colocado em um comentário em bloco.

C (envio de bônus)

A versão C é um verificador principal, matriz de entrada na parte superior. Tente adivinhar o que a linguagem produz If the boss finds this, I quit.(não é espaço em branco).

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

A outra lingua:

Brainfuck . Executando isso como foda cerebral com apenas um número de entrada produzirá a sequência apropriada. Mais de uma entrada, e você terá que garantir que a entrada para o programa brainfuck seja bytes nulos.

Perl / Befunge-93 (108 106 110 )

Minha segunda submissão, apenas porque. Também usa expressões regulares. Aposto que há uma escolha melhor do que Perl, por exemplo, Octave, mas não consegui descobrir como imprimir condicionalmente de uma maneira curta.

Estou abusando da regra de imprimir a string, pois evito anagramas dividindo-a em várias.

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

O número a ser verificado é obtido no stdin.

• Edit: eu escrevi "my" em vez de "the" acidentalmente, corrigi-lo custou +1 byte.
• Editar: usando em ifvez de unless4 bytes salvos.
• Edit: Esqueceu sobre "the", dividindo esse também custou +2 bytes.

Lua / PBrain (Brainf process * ck) - 813

Heh ... Desculpe, fui pego tentando ser desonesto. O PBrain é igual ao BF, mas permite ativar e definir blocos reutilizáveis ​​de código BF. Seu uso foi completamente desnecessário.

--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 sem contar os comentários)

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

Isso usa um algoritmo muito simples (isto é, ineficiente). Quando executado com rot13 (provavelmente não é uma linguagem de programação), produz a sentença necessária (junto com outras bobagens).

A pior parte é que os comentários afirmam o óbvio e são inúteis de qualquer maneira.

Este é um poliglota de outra maneira, contendo inglês e "esperanto". Espero que o chefe não seja um poliglota.

05AB1E / Jelly , 28 bytes

Não uma, mas duas línguas de golfe!

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

Explicação em 05AB1E:

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

Explicação em Jelly:

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

Experimente online! (Geléia) Experimente online! (05AB1E)

Python, 403 bytes

Isto é destinado ao desafio de bônus. Os comentários não contam para o número de bytes.

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

Os testes na parte inferior do código são impressos:

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

Esse número máximo máximo que eu defini (mi) oculta o segredo. Se convertida em hexadecimal, a representação em letras ASCII de cada dois dígitos hexadecimais indica "Se o chefe encontrar isso, eu desisto". A parte sorrateira está usando a função chr. Se o chefe souber o que isso faz e estiver olhando com bastante atenção, ele saberá que o código oculta uma mensagem secreta. No entanto, ofusquei isso um pouco e forneci explicações suficientes para todo o número inteiro máximo, para garantir ao chefe que é uma parte legítima do programa.

Observe que, para a maioria dos parâmetros, ele funciona como o chefe deseja, mas se a entrada não for um número inteiro ou o número for maior que mi, p retornará o erro que contém a cadeia oculta. Eu poderia ter colocado uma chamada de impressão dentro da função, mas pensei que pareceria mais real se fosse retornada.

C # - 288

Certamente não é o mais curto, mas pode passar por muitos chefes:

 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;

Uma versão legível:

            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;