Bất chấp sự phản đối của bạn, bạn đã được ông chủ đưa vào làm việc trên một chương trình lấy một số nguyên không dấu làm đầu vào và in chuỗi "số nguyên tố" nếu số nguyên đó là số nguyên tố và "không phải số nguyên tố" nếu không. Bạn có thể chọn ngôn ngữ bạn thực hiện bằng ngôn ngữ này, miễn là chương trình kết quả ngắn; ông chủ của bạn đánh giá rất cao số lượng nhân vật thấp. (Anh ấy thực sự sẽ đếm các ký tự theo cách thủ công sau khi in mã nguồn.)

Vì vậy, bạn tốt hơn để có được nó, số lượng nhân vật thấp nhất chiến thắng.

Phần thú vị

Đây chỉ là giữa bạn và tôi, nhưng chương trình của bạn cũng phải hợp lệ trong một ngôn ngữ khác. Tuy nhiên, trong ngôn ngữ này, nó sẽ in chuỗi "Nếu ông chủ tìm thấy thứ này, tôi sẽ bỏ." Hãy chắc chắn rằng ông chủ của bạn không phát hiện ra sự xúc phạm tiềm ẩn khi đọc đi đọc lại mã khi anh ta quên mất nếu anh ta đếm đến 17 hoặc 18 cho đến nay. Vì lý do đó, bạn không được sử dụng bất kỳ từ nào trong "ông chủ tìm thấy việc này" trong một phần của mã cũng như bạn không thể sử dụng và đảo chữ của 5 từ đó.

Thử thách tiền thưởng mà tôi đã tạo ra tiền thưởng cho

Viết một chương trình thực sự trông giống như nó chỉ giải quyết câu hỏi đầu tiên cho mắt chưa được huấn luyện và dường như không chứa các ký tự không cần thiết. Điều này bao gồm các nhận xét và phân đoạn mã rõ ràng không đóng góp gì. Lý tưởng nhất, một giáo dân sẽ tin rằng chương trình của bạn thực sự ngắn đến mức có thể mà không thể quản lý được. Một nhận xét hữu ích ở đây và có được mặc dù.

Các quy tắc cho thử thách tiền thưởng hơi lỏng lẻo, thay vì được đánh giá dựa trên các tiêu chí dễ đo lường, chương trình của bạn sẽ được đánh giá nhiều hơn về cách nó đến với tôi (và tất nhiên là các cử tri)

Tôi sẽ là thẩm phán cuối cùng của mục nào đến gần nhất để xứng đáng với tiền thưởng này.

Biên tập:

Sau vài phút đếm sếp của bạn, anh ta đã có một trong những đồng nghiệp của bạn viết chương trình đếm nhân vật cho anh ta. Vì vậy, ngay cả các ký tự không nhìn thấy được tính vào số lượng nhân vật của bạn.

CJam ( GolfScript ), 60 59 byte

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

Cảm ơn @mnbvmar vì đã chơi golf 1 byte!

Cách thức hoạt động (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. ";

Hãy thử trực tuyến!

Cách thức hoạt động (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.

Hãy thử trực tuyến!

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

Xác định các số nguyên tố với Python 2 , khiến bạn gặp rắc rối với Python 3 .

Thêm

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

Hãy thử nó với Python 2 hoặc Python 3 ! (Trái ngược với phiên bản golf ở trên, vai trò đã thay đổi: Python 3 là định danh số nguyên tố. Python 2 chứa trứng Phục sinh.)

Xin vui lòng, xin lỗi tiếng Anh xấu của tôi trong văn bản trợ giúp! ;)

Và tôi sử dụng từ "bỏ". Nhưng bằng cách nào đó tôi cần mô tả khi chương trình của tôi chấm dứt. ;)

Gửi tiền thưởng (C / C ++ 11)

Kiểm tra tính nguyên thủy bằng phương pháp ngây thơ thông thường là rất chính thống. Đó là lý do tại sao tôi đã phát minh ra một phương pháp ngây thơ ngẫu nhiên hoàn toàn mới! Thử nghiệm này như sau:

1. Chọn bất kỳ số nguyên d ngẫu nhiên. Nó không được nhỏ hơn 2 và lớn hơn một chút so với sqrt(n).
2. Nếu d là ước của n , đầu ra not prime.
3. Nếu chúng tôi thực hiện 20sqrt(n)lần kiểm tra này , đầu ra prime, lặp lại.

Nếu số là tổng hợp, chỉ có rất ít xác suất (khoảng 10 ^-9 ) là nó không hoạt động. Tất nhiên, tôi không tin rằng trình tạo số giả danh C / C ++ đủ mạnh. Đó là lý do tại sao tôi sử dụng trình tạo LFSR 256 bit của riêng mình !

#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 hoạt động chính xác. Tuy nhiên, trình biên dịch C dường như đang xuất ra một chương trình bị lỗi cho n> 2 ...

Lưu ý : hãy nhớ rằng C cần -lmtùy chọn (thư viện toán học liên kết) để biên dịch thành công.

Nhìn vào max_rangebiến. Từ khóa C ++ 11 phân autogiải thành "loại phù hợp" - trong trường hợp này double. Tuy nhiên, trong C, nó được định nghĩa là một công cụ sửa đổi biến (như statichiện tại) - nó không xác định loại. Do đó, max_rangeloại là một loại C mặc định, đó là int. Khi chúng tôi "cố gắng" nhân biến này với 1.1111, trong C, nó bị "vô tình" trong khi chia cho 100000. Chúng tôi nhận được một khoảng ngẫu nhiên của các số ngẫu nhiên được tạo và LFSR sau khi tiến hành trạng thái bên trong của nó tạo ra lỗi, xuất ra nhị phân đổ hạt giống. Đó là "vô tình" Thông báo Nếu ông chủ tìm thấy điều này, tôi đã bỏ. \ N

Nếu bạn tìm thấy đầu ra bị lỗi sau:

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

không chính xác, chỉ cần loại bỏ các fprintfdòng thích hợp .

Toán học / Brainfuck, 260

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

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

Hãy thử Golfscript tại đây và Javascript tại đây .

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

Tôi muốn nói rằng nó rất gần với các giải pháp Mathicala, sau đó, có một kiểm tra tích hợp cho các số nguyên tố.

Chỉnh sửa: Cảm ơn Peter đã lưu hai sáu byte khác!

Dưới đây là một số chi tiết:

• Đầu tiên 1.là cần thiết bởi vì sau đây //là một nhận xét trong Javascript, nhưng thực hiện phân chia hai lần trong Golfscript. Điều này sẽ báo lỗi nếu không có gì trên stack, vì vậy chúng ta cần cung cấp cho nó hai số. Ngẫu nhiên, 1.là một cú pháp hoàn toàn hợp lệ trong Javascript và sẽ bị bỏ qua.
• "…"{(}%lấy chuỗi, giảm giá trị mã ký tự của chúng theo một và đẩy nó thành chuỗi. Điều này dẫn đến chuỗi chúng ta cần in.
• ' bắt đầu một chuỗi trong Golfscript theo mặc định kéo dài qua một số dòng, khiến Javascript bên dưới chỉ được đưa vào chuỗi.
• Tiếp theo là mã Javascript, sử dụng một cách tiếp cận khá nổi tiếng để phát hiện các số nguyên tố thông qua các biểu thức thông thường.
• ';#'đóng chuỗi nhiều dòng trong Golfscript, loại bỏ nó và sau đó bỏ qua phần còn lại của dòng. Trong Javascript, đây đơn giản là một chuỗi ký tự sẽ bị bỏ qua.

C ++ / C99 / C90 - 248

Mã này sẽ chạy tốt trong C90, nhưng có thể hiển thị một cái gì đó khác trong C99 / C ++.

Un-golfed cho rõ ràng:

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ách thức hoạt động: Vì C90 không nhận ra các nhận xét dòng đơn, chuỗi vấn đề không còn được nhân với số không.

CJam / Ruby, 132 95 91 87

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

Giải pháp trước đây của tôi đã được thiết kế quá mức đáng kể; cái này được truyền cảm hứng rất nhiều từ giải pháp của Martin Büttner, bao gồm cả việc anh ta nhận ra rằng #bytesphương pháp này rõ ràng có thể mất một khối.

Làm thế nào nó hoạt động?

Ký tự nhận xét của Ruby ( #) là toán tử lũy thừa trong CJam, vì vậy chúng ta sẽ cần ít nhất hai số trên ngăn xếp trước khi bắt đầu, nhưng hai số trần ( 0 0) là lỗi cú pháp trong Ruby. Tuy nhiên, một cái là tốt, và, một cách hữu ích, các số Ruby có thể chứa dấu gạch dưới là dấu phân cách ( 1_234). _là toán tử sao chép của CJam, vì vậy chúng tôi cần bật hai lần ( ;;) một khi chúng tôi vào trong bình luận. limpđọc một dòng từ đầu vào tiêu chuẩn, chuyển đổi nó thành một số nguyên, bật nó và đẩy cho dù đó có phải là số nguyên tố hay không.

Để vào chế độ Ruby, chúng tôi mở một chuỗi và tiếp tục lên dòng tiếp theo để chúng tôi không còn nhận xét về Ruby nữa (do đó, dòng mới có ý nghĩa và phải được tính). Mỗi ký tự của tin nhắn được giải mã và in, sau đó chúng tôi bắt đầu một nhận xét khác của Ruby để chúng tôi có thể đóng chuỗi CJam một cách an toàn trước khi bật nó. Những gì còn lại trên ngăn xếp là liệu đầu vào có phải là số nguyên tố hay không, được in khi chấm dứt chương trình của CJam.

Các ký tự CJam / Whitespace, 353 (25 có ý nghĩa khi được in)

Với bản chất của thử thách, và thực tế là ông chủ sẽ in các chương trình của chúng tôi để đếm các nhân vật, tôi đã đưa ra gợi ý về việc thực hiện một giải pháp liên quan đến Whitespace .

Trái ngược với khẳng định trước đây của tôi rằng chương trình Whitespace ngắn nhất có thể in "Nếu ông chủ tìm thấy điều này, tôi sẽ bỏ việc." sẽ là 372 ký tự, cái này thực hiện trong 330. Bí quyết là sử dụng copyhướng dẫn để gảy các ký tự lặp lại từ đâu đó trên ngăn xếp thay vì đẩy tất cả các giá trị ASCII, vốn sẽ luôn lớn hơn nhiều và do đó cần nhiều khoảng trống hơn và các tab để mã hóa. Đây là một đại diện lắp ráp giả của chương trình cho người tò mò:

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

Gửi giải thưởng thưởng (Perl / B? F? N? E-? 3)

Chỉnh sửa: Ban đầu tôi quên thực sự in câu và sau đó nhận thấy nó sẽ in theo thứ tự ngược lại. Tôi nhận thấy điều này sau khi được thực hiện. Tôi đã sẵn sàng để giết một con mèo con, nhưng tôi đã sửa nó ngay bây giờ.

Điều này không còn ngắn nữa, nhưng tôi tin rằng làm cho nó không đáng tin và ngắn là một trong những nhiệm vụ khó khăn. Tôi đã chủ yếu sử dụng lại một trong những bài nộp golf thực tế của mình, nhưng trong bài này tôi sẽ nói ngôn ngữ thứ hai thực sự khó phát hiện.

Nếu ông chủ phát hiện ra điều này, tôi thực sự bỏ việc, bởi vì tôi sẽ không bao giờ có thể bí mật lăng mạ anh ta và nếu tôi không thể làm điều đó, thì sao?

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

Uốn và phá vỡ các quy tắc:

• Tôi đang sử dụng từ "the" trong đó, nhưng nó không phải là "the" được in. Nó có thể không hợp lệ về mặt kỹ thuật, tôi sẽ để OP quyết định xem các quy tắc có nghiêm ngặt đối với thử thách tiền thưởng hay không. Nếu vậy, thì nó là như vậy.
• Trạng thái quy tắc Tôi không thể sử dụng một số từ nhất định, nhưng chúng tôi đọc từ trái sang phải, vì vậy tôi cho rằng các từ được viết theo chiều dọc là hợp lệ.
• Tôi không biết làm thế nào tôi vẫn có được công việc này, nhìn thấy những điều khủng khiếp tôi viết trong các bình luận. Ý tôi là: câu đố, thật sao?

Mathicala / Ruby, 115 106 byte

Phần Mathicala được lấy cảm hứng một chút từ sự đệ trình của Peter Olson, nhưng phần đa âm với Ruby thì phức tạp hơn một chút ở đây.

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

Ruby hoạt động, bởi vì hai người #nhận xét tất cả mọi thứ đó là Mathematica. Lý do tại sao Mathicala hoạt động thú vị hơn một chút. Mã tôi muốn thực thi là:

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

Nhưng đó không phải là Ruby hợp lệ, vì vậy tôi cần thêm một #nơi nào đó. #là tham số của Mathicala cho các hàm ẩn danh. Vì vậy, tôi đặt #ở phía trước, nhân số đối số với kết quả của If. Vâng, nó sẽ nhân nó với một chuỗi , bất kể điều đó có nghĩa là gì. Sau đó, tôi biến nó thành một hàm ẩn danh &và gọi nó ngay lập tức bằng đối số 1. Chà, Mathematica đủ thông minh để biết rằng phép nhân với 1 luôn là danh tính và chỉ xuất ra chuỗi. Sau đó, mã Ruby chỉ đơn giản là đưa vào một bình luận khối.

C (Gửi tiền thưởng)

Phiên bản C là một trình kiểm tra chính, mảng đầu vào ở trên cùng. Thử đoán xem ngôn ngữ mang lại kết quả gì If the boss finds this, I quit.(Không phải là khoảng trắng).

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

Ngôn ngữ khác:

Brainfuck . Chạy nó dưới dạng brainfuck chỉ với một số đầu vào sẽ cho ra chuỗi thích hợp. Bất kỳ nhiều hơn một đầu vào và bạn sẽ phải đảm bảo đầu vào cho chương trình brainfuck là byte rỗng.

Perl / Befunge-93 (108 106 110 )

Trình thứ hai của tôi, chỉ vì. Cũng sử dụng các biểu thức thông thường. Tôi cá là có một lựa chọn tốt hơn Perl, ví dụ như Octave, nhưng tôi không thể tìm ra cách in có điều kiện một cách ngắn gọn.

Tôi đang lạm dụng quy tắc cho chuỗi được in vì tôi đang tránh đảo chữ bằng cách chia chuỗi thành nhiều chuỗi.

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

Số để kiểm tra được lấy từ stdin.

• Chỉnh sửa: Tôi đã vô tình viết "của tôi" thay vì "the", sửa nó tốn 1 byte.
• Chỉnh sửa: sử dụng ifthay vì unlesslưu 4 byte.
• Chỉnh sửa: Quên về "the", tách một byte cũng có giá +2 byte.

Lua / PBrain (Brainf thủ tục * ck) - 813

Heh ... Xin lỗi, bị cuốn vào việc cố gắng trở nên ranh ma. PBrain giống như BF, nhưng nó cho phép bạn kích hoạt và xác định các khối mã BF có thể sử dụng lại. Việc sử dụng là hoàn toàn không cần thiết.

--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 Byte (69 không tính bình luận)

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

Điều này sử dụng một thuật toán rất đơn giản (tức là không hiệu quả). Khi chạy với rot13 (có thể không phải là ngôn ngữ lập trình), nó sẽ tạo ra câu bắt buộc (cùng với các câu vô nghĩa khác).

Phần tồi tệ nhất là các ý kiến ​​nêu rõ và dù sao cũng khá vô dụng.

Đây là một polyglot theo một cách khác, bằng cách chứa cả tiếng Anh và "Esperanto". Tôi hy vọng ông chủ không phải là một polyglot.

05AB1E / Jelly , 28 byte

Không phải một, mà là HAI ngôn ngữ chơi gôn!

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

Giải thích trong 05AB1E:

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

Giải thích về 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."

Hãy thử trực tuyến! (Jelly) Hãy thử trực tuyến! (05AB1E)

Python, 403 byte

Điều này là dành cho các thách thức tiền thưởng. Các ý kiến ​​không được tính vào 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"

Các thử nghiệm ở dưới cùng của mã in:

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

Số nguyên tối đa mà tôi xác định (mi) ẩn bí mật. Nếu được chuyển đổi thành hex, biểu thị chữ cái ASCII của mỗi hai chữ số hex tạo thành "Nếu ông chủ tìm thấy điều này, tôi sẽ bỏ." Phần lén lút đang sử dụng chức năng chr. Nếu ông chủ biết những gì nó làm và đang xem xét đủ cẩn thận, ông sẽ biết rằng mã ẩn một thông điệp bí mật. Tuy nhiên tôi đã che giấu điều đó một chút và cung cấp đủ lời giải thích cho toàn bộ số nguyên tối đa để hy vọng đảm bảo với ông chủ rằng đó là một phần hợp pháp của chương trình

Lưu ý rằng đối với hầu hết các tham số, nó hoạt động giống như ông chủ muốn, nhưng nếu đầu vào không phải là số nguyên hoặc số nào đó lớn hơn mi, p sẽ trả về lỗi chứa chuỗi ẩn. Tôi có thể đã thực hiện một cuộc gọi in bên trong chức năng, nhưng tôi nghĩ rằng nó sẽ trông thật hơn nếu nó được trả lại.

C # - 288

Chắc chắn không phải là ngắn nhất, nhưng nó có thể vượt qua nhiều ông chủ:

 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;

Một phiên bản có thể đọc được:

            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;