尽管您提出了抗议，您的老板还是让您开始工作在一个程序中，该程序采用一个无符号整数作为输入，如果该整数是质数，则输出字符串“ prime”，如果不是则输出字符串“ not prime”。只要生成的程序简短，就可以选择使用哪种语言。您的老板非常欣赏字符数少的东西。（在打印出源代码之后，他实际上将手动计算字符。）

因此，您最好做到这一点，以最少的字符数为准。

有趣的部分

这只是在您我之间，但是您的程序也应该以另一种语言有效。但是，用这种语言，它应该打印字符串“如果老板发现了，我就退出了。”。反复阅读代码时，请确保您的上司不会发现有隐藏的侮辱，因为他会忘记自己到目前为止是否算过17或18。因此，您可能无法在代码的一部分中使用“老板发现此辞职”中的任何单词，也不能使用这5个单词和它们的字谜。

我创造了赏金的奖金挑战

编写实际上看起来像是在解决未经训练的眼睛的第一个问题并且似乎不包含不必要的字符的程序。其中包括注释和代码段，这些注释和代码段显然没有任何作用。理想情况下，一个外行人会相信您的程序实际上尽可能的短而不被无法管理。有用的评论在这里，虽然可以。

奖金挑战的规则稍微宽松一些，而不是根据容易衡量的标准来判断，您的程序将更多地根据它如何影响我（当然还有选民）来进行判断

我将是哪个条目最接近应得的悬赏的最终裁判。

编辑：

在您的老板数分钟之后，他让您的一个同事为他编写了一个字符计数程序。因此，即使看不见的字符也计入您的字符数。

CJam（GolfScript），60 59字节

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

感谢@mnbvmar打高尔夫球1个字节！

工作原理（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. ";

在线尝试！

运作方式（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.

在线尝试！

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

使用Python 2识别素数，使用Python 3麻烦您。

奖金

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

尝试使用Python 2或Python 3！（与上面的高尔夫版本相反，角色更改了：Python 3是素数标识符。Python2包含复活节彩蛋。）

请在帮助文本中用我的英语不好！;）

我确实使用“退出”一词。但是我需要以某种方式描述我的程序何时终止。;）

奖金提交（C / C ++ 11）

使用通常的朴素方法进行原始性测试非常普遍。这就是为什么我发明了一种全新的随机天真方法！该测试如下：

1. 随机选择任何整数d。它不能小于2且大于大于1 sqrt(n)。
2. 如果d是n的除数，则输出not prime。
3. 如果我们做了这个测试20sqrt(n)时间，则输出prime，否则重复。

如果该数字是复合数字，则几乎没有任何可能性（大约10 ^-9）不起作用。当然，我不认为C / C ++伪随机数生成器足够强大。这就是为什么我使用自己的256位LFSR发生器！

#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正常工作。但是，C编译器似乎正在输出n> 2的错误程序。

注意：请记住，C需要-lm选项（链接数学库）才能成功编译。

看max_range变量。auto在这种情况下，C ++ 11关键字解析为“匹配类型” double。但是，在C语言中它被定义为变量修饰符（按原样static）-它没有定义类型。因此，max_rangetype是默认的C类型，即int。当我们“尝试”将此变量乘以1.11111时，在C中，它在除以100000时会被“无意地”置零。我们得到一个不正确的随机数区间，并且在进行内部状态运算后LFSR会产生错误，并输出二进制种子的转储。那是“偶然”的信息如果老板发现了这个，我就辞职了。\ n

如果发现以下错误输出：

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

错误，只需删除相应的fprintf行即可。

Mathematica / Brainfuck，260

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

Golfscript /使用Javascript（126 125 129 130 132 134 205 207）

在这里尝试Golfscript和在这里Javascript。

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

我要说的是，它与那些Mathematica解决方案非常接近，毕竟这些解决方案具有对质数的内置检查。

编辑：感谢彼得节省了另外两个六个字节！

以下是一些详细信息：

• 第一个1.是必需的，因为以下//是Javascript中的注释，但在Golfscript中执行了两次除法。如果堆栈上没有任何内容，这将出错，因此我们需要给它两个数字。顺便说一句，这1.是Javascript中完全有效的语法，将被忽略。
• "…"{(}%接收字符串，将其字符代码值减一，然后将其作为字符串推送。这导致我们需要打印的字符串。
• ' 在Golfscript中启动一个字符串，默认情况下它会跨越多行，从而导致以下Javascript仅放入该字符串中。
• 接下来是Javascript代码，它使用某种众所周知的方法通过正则表达式检测素数。
• ';#'在Golfscript中关闭多行字符串，将其丢弃，然后忽略该行的其余部分。在Javascript中，这只是一个字符串文字，将被忽略。

C ++ / C99 / C90-248

该代码将在C90中很好地运行，但在C99 / C ++中可能会显示其他内容。

为了清楚起见，不做广告：

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

工作原理： 由于C90无法识别单行注释，因此问题字符串不再乘以零。

CJam / Ruby，132 95 91 87

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

我以前的解决方案设计过度。这项工作受到MartinBüttner的解决方案的极大启发，包括他意识到该#bytes方法显然会产生阻碍。

它是如何工作的？

Ruby的注释字符（#）是CJam中的幂运算符，因此在开始之前，我们至少需要在堆栈上包含两个数字，但是0 0在Ruby中，两个裸数字（）是语法错误。不过，一个很好，而且，有益的是，Ruby数字可以包含下划线作为分隔符（1_234）。_是CJam的复制运算符，因此;;一旦进入注释，我们需要弹出两次（）。limp从标准输入读取一行，将其转换为整数，将其弹出，然后推入是否为质数。

要进入Ruby模式，我们打开一个字符串并继续到下一行，这样我们就不再位于Ruby注释中（因此，换行符很重要，必须进行计数）。消息的每个字符都被解码并打印，然后我们开始另一个Ruby注释，以便我们可以在弹出CJam字符串之前安全地关闭它。堆栈上剩下的是输入是否为质数，该值在CJam程序终止时打印出来。

CJam / Whitespace，353个字符（打印时有25个有意义的字符）

考虑到挑战的不足性质，以及老板将打印我们的程序以计算字符的事实，我接受了提出一个涉及Whitespace的解决方案的建议。

与我以前的说法相反，即最短的Whitespace程序显示“如果老板找到了，我就退出了”。会是372个字符，这是在330中做到的。技巧是使用copy指令从堆栈中的某个位置提取重复字符，而不是推送所有ASCII值，因为这些ASCII值总是会更大，因此需要更多空间和制表符进行编码。这是好奇的程序的伪汇编表示形式：

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

奖金提交（Perl / B？f？n？e-？3）

编辑：我最初忘记实际打印该句子，然后注意到它将以相反的顺序打印它。完成后我注意到了这一点。我本来打算杀死一只小猫，但现在我把它固定了。

这绝不再短了，但我相信使其变得毫无疑问且短是一项艰巨的任务。我大部分时候都重复使用了我实际的高尔夫作品之一，但是在这一本书中，我会说第二种语言确实很难发现。

如果老板发现了这一点，我真的会辞职，因为我将永远无法秘密地侮辱他，如果我不能这样做，那又有什么意义呢？

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

弯曲和破坏规则：

• 我在其中使用“ the”一词，但不是被打印出来的“ the”。从技术上讲，这可能是无效的，我将让OP决定奖励挑战的规则是否必须如此严格。如果是这样，那就这样吧。
• 规则规定我不能使用某些单词，但是我们从左到右阅读，因此我假定垂直写出这些单词是有效的。
• 看到我在评论中写的糟糕的东西，我不知道我怎么还能得到这份工作。我的意思是：谜语，真的吗？

Mathematica / Ruby，115106字节

Mathematica部分受到了Peter Olson的投稿的启发，但是与Ruby的多语言融合在这里更加详细。

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

Ruby之所以有效，是因为两者#将Mathematica的所有内容都注释掉了。Mathematica工作的原因更加有趣。我要执行的代码是：

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

但这不是有效的Ruby，因此我需要在#某个地方添加一个。#是Mathematica的匿名函数参数。因此，我放在#最前面，它将参数与的结果相乘If。是的，无论什么意思，它将与字符串相乘。然后，我将其转换为带有的匿名函数，&并立即使用arguments调用它1。好吧，Mathematica非常聪明，知道乘以1 始终是恒等式并且仅输出字符串。之后，只需将Ruby代码放入块注释中即可。

C（奖金提交）

C版本是素数检查器，输入数组在顶部。尝试猜测产生什么语言If the boss finds this, I quit.（不是空格）。

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

其他语言：

操蛋。仅用一个输入数字来运行此操作即可输出适当的字符串。输入不止一个，您必须确保Brainfuck程序的输入为空字节。

的Perl / Befunge-93（108 106 110）

我的第二次提交，仅仅是因为。也使用正则表达式。我敢打赌，比起Perl，还有一个更好的选择，例如Octave，但我想不通如何在短时间内有条件地进行打印。

我在滥用要打印的字符串的规则，因为我通过将其分成多个字符串来避免了字谜。

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

要检查的号码来自stdin。

• 编辑：我不小心写了“ my”而不是“ the”，修复它花费了+1个字节。
• 编辑：使用if而不是unless保存的4个字节。
• 编辑：忘记了“ the”，将其拆分为2字节。

Lua / PBrain（过程性脑力劳动）-813

嘿...对不起，被骗了。PBrain与BF一样，但是它允许您触发和定义BF代码的可重用块。完全没有必要使用它。

--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字节（69个不包括注释）

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

这使用了非常简单（即效率低下）的算法。当使用rot13（可以说不是编程语言）运行时，它会生成所需的句子（以及其他废话）。

最糟糕的部分是，这些评论陈述了明显的内容，无论如何都没有用。

通过同时包含英语和“世界语”，这是另一种通俗的说法。我希望老板不是一个会说多种语言的人。

05AB1E / Jelly，28个字节

不是一个，而是两个高尔夫语言！

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

05AB1E中的解释：

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

果冻中的解释：

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

在线尝试！（果冻） 在线尝试！（05AB1E）

Python，403个字节

这是针对奖金挑战的。注释不计入字节数。

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

代码底部的测试打印：

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

我定义的最大整数（mi）隐藏了秘密。如果转换为十六进制，则十六进制的每两位数字的ASCII字母表示为“如果老板发现此错误，我退出。” 偷偷摸摸的部分正在使用chr函数。如果老板知道该怎么做并且正在仔细地看，他将知道该代码隐藏了一条秘密消息。但是我对此感到困惑，并为整个最大整数问题提供了足够的解释，以希望向老板保证这是程序的合法部分。

请注意，对于大多数参数，它的工作方式就像老板希望的那样，但是如果输入的不是整数或数字比mi大，则p返回包含隐藏字符串的错误。我本可以在函数内部进行打印调用，但是我认为如果返回该调用，它将看起来更加真实。

C＃-288

当然不是最短的，但许多老板可能会忽略：

 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;

可读版本：

            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;