あなたの抗議にもかかわらず、あなたは入力として単一の符号なし整数を取り、その整数が素数であれば文字列「prime」を出力し、そうでなければ「素数ではない」という文字列を出力するプログラムで上司に働きかけられました。結果のプログラムが短い限り、これを行う言語を選択できます。上司は文字数が少ないことを非常に高く評価しています。（彼はソースコードを印刷した後、実際に手動で文字を数えます。）

だからあなたはそれに到達する方が良い、最低の文字数が勝ちます。

楽しい部分

これはあなたと私の間だけですが、あなたのプログラムは別の言語でも有効でなければなりません。ただし、この言語では、「上司がこれを見つけた場合、私は辞めます。」という文字列を出力する必要があります。上司がコードを何度も読むときに隠れたhidden辱があることを理解していないことを確認してください。そのため、コードの一部で「上司がこれをやめた」という単語を使用したり、これら5つの単語のアナグラムを使用したりすることはできません。

私が賞金を獲得したボーナスチャレンジ

実際に訓練されていない目には最初の質問を解決するだけで、不要な文字が含まれていないように見えるプログラムを作成します。これには、明らかに何も貢献しないコメントとコードのセグメントが含まれます。理想的には、素人はあなたのプログラムが実際には管理できないほど短くなると信じています。ここで役立つコメントがありますが、大丈夫です。

ボーナスチャレンジのルールは少し緩いです。簡単に測定可能な基準で判断されるのではなく、あなたのプログラムは私（そしてもちろん有権者）にどのように対処するかについてより判断されます。

私は、この賞金に値するエントリーに最も近いエントリーの最終審査員になります。

編集：

あなたの上司が数分間数えた後、彼はあなたの同僚の1人に彼のためにキャラクターカウントプログラムを書いてもらいました。したがって、表示されていない文字も、文字数にカウントされます。

CJam（GolfScript）、60 59バイト

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

1バイトのゴルフをしてくれた@mnbvmarに感謝します！

仕組み（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で試してみてください！（上記のゴルフバージョンとは異なり、ロールが変更されました。Python3は素数識別子です。Python2にはイースターエッグが含まれています。）

ヘルプテキストで私の悪い英語を許してください！;）

そして、「quit」という言葉を使用します。しかし、どういうわけか私は私のプログラムが終了するときを説明する必要があります。;）

ボーナスの提出（C / C ++ 11）

通常の素朴な方法を使用した素数テストが主流です。だからこそ、まったく新しいランダム化された素朴な方法を発明しました！このテストは次のとおりです。

1. 任意の整数dをランダムに選択します。2より小さく、1より少し大きくてはいけませんsqrt(n)。
2. もしdはの除数nは、出力not prime。
3. このテスト20sqrt(n)時間を出力した場合、output 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変数を見てください。C ++ 11キーワードautoは「一致するタイプ」に解決されます-この場合double。ただし、Cでは、（そのままのstatic）変数修飾子として定義されています-型を定義しません。したがって、max_rangetypeはデフォルトのCタイプ、つまりですint。Cでこの変数を1.11111で乗算しようとすると、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ソリューションに驚くほど近いと思います。

編集：さらに2つの 6バイトを保存してくれたピーターに感謝します！

詳細は次のとおりです。

• 1.以下//はJavascriptではコメントですが、Golfscriptでは2回除算を実行するため、最初のものが必要です。スタック上に何もない場合はエラーになりますので、2つの数字を指定する必要があります。ちなみに、1.Javascriptでは完全に有効な構文であり、無視されます。
• "…"{(}%文字列を取得し、文字コード値を1つ減らし、文字列としてプッシュします。これにより、印刷する必要がある文字列が生成されます。
• ' はデフォルトで複数行に及ぶ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のべき乗演算子です。したがって、開始する前にスタック上に少なくとも2つの数字が必要になり0 0ますが、Rubyの2つの裸の数字（）は構文エラーです。ただし、1つでも問題ありません。また、Rubyの数字には、区切り記号としてアンダースコアを含めることができます（1_234）。_CJamの複製演算子であるため;;、コメント内に2回ポップする必要があります（）。limp標準入力から行を読み取り、整数に変換し、ポップして、素数であるかどうかをプッシュします。

Rubyモードに入るために、文字列を開いて次の行に進み、Rubyのコメントがなくなるようにします（したがって、改行は重要であり、カウントする必要があります）。メッセージの各文字はデコードされて出力されます。次に、ポップする前にCJam文字列を安全に閉じることができるように、別のRubyコメントを開始します。スタックに残っているのは、入力が素数であったかどうかであり、CJamプログラムの終了時に出力されます。

CJam / Whitespace、353（印刷時に25の意味のある）文字

挑戦の手に負えない性質と、ボスがキャラクターを数えるために私たちのプログラムを印刷するという事実を考えると、私はWhitespaceを含む解決策を行うことの提案を取り上げました。

「上司がこれを見つけた場合、私は辞めます。これは330文字です。これは330で行います。トリックは、copyすべての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）

編集：私はもともと実際に文章を印刷するのを忘れて、それが逆の順番で印刷することに気づきました。終わった後、私はこれに気づきました。私は子猫を殺す準備ができていたが、今それを修正した。

これは決して短くはありませんが、疑わしくなく短くすることは難しい作業の1つの地獄だと思います。私は実際にゴルフで提出したもののほとんどを再利用しましたが、これでは第二言語を見つけるのは本当に難しいと思います。

上司がこれを見つけた場合、私は本当に辞めます。私が彼をひそかにin辱することは決してできないからです。もし私がそれをできないなら、何がポイントですか？

# ^ 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、115 106バイト

Mathematicaの部分はPeter Olsonの提案に少し触発されましたが、ここではRubyによるポリグロット化がもう少し複雑です。

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

Rubyは機能#します。2つがMathematicaであるすべてをコメントアウトしているからです。Mathematicaが動作する理由はもう少し興味深いです。実行したいコードは次のとおりです。

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

しかし、それは有効なRubyではないので、#どこかに追加する必要があります。#は、匿名関数に対するMathematicaのパラメータです。その#ため、引数をの結果で乗算する先頭に配置しIfます。はい、それが意味するものは何でも、それを文字列で乗算します。次に、これをで無名関数に変換し&、すぐにargumentで呼び出します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!

他の言語：

ブレインファック。これを1つの入力番号のみで Brainfuckとして実行すると、適切な文字列が出力されます。複数の入力があり、brainfuckプログラムへの入力がnullバイトであることを確認する必要があります。

Perl / Befunge-93（108 106 110）

私の2番目の提出、という理由だけで。正規表現も使用します。Octaveのように、Perlよりも良い選択肢があると思いますが、短い方法で条件付きで印刷する方法がわかりませんでした。

アナグラムをいくつかの文字列に分割することでアナグラムを避けているため、文字列を印刷する規則を乱用しています。

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

チェックする番号は標準入力から取得されます。

• 編集：「the」の代わりに「my」を誤って作成しました。これを修正すると、+ 1バイトかかりました。
• 編集：保存された4バイトのif代わりに使用しunlessます。
• 編集：「the」を忘れて、コストも+2バイトに分割しました。

Lua / PBrain（手続き型Brainf * ck）-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 / ゼリー、28バイト

1つではなく、2つのゴルフ言語！

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）は秘密を隠します。16進数に変換すると、16進数の2桁ごとのASCII文字表現は「上司がこれを見つけた場合、私は辞めます」になります。卑劣な部分はchr関数を使用しています。上司がそれを理解し、十分に注意深く見ている場合、上司はコードが秘密のメッセージを隠していることを知るでしょう。しかし、それを少し難読化し、最大整数値全体に十分な説明を提供して、上司にプログラムの正当な部分であることを願っています

ほとんどのパラメーターでは上司が望むように機能しますが、入力が整数でない場合や数値がmiよりも大きい場合、pは非表示の文字列を含むエラーを返します。関数内でprint呼び出しを行うこともできますが、返されるとよりリアルに見えると思いました。

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;