แม้คุณจะประท้วงคุณก็ถูกเจ้านายของคุณทำงานกับโปรแกรมที่ใช้เลขจำนวนเต็มเดียวที่ไม่ได้ลงนามเป็นอินพุตและพิมพ์สตริง "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])

ระบุตัวเลขที่สำคัญกับงูหลาม 2ได้รับการเป็นคุณเป็นปัญหากับงูหลาม 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 เป็นตัวระบุหมายเลขเฉพาะ Python 2 มีไข่อีสเตอร์)

ได้โปรดแก้ตัวภาษาอังกฤษของฉันด้วยข้อความช่วยเหลือ! ;)

และฉันใช้คำว่า "ออกจาก" แต่อย่างใดฉันต้องอธิบายเมื่อโปรแกรมของฉันสิ้นสุดลง ;)

การส่งโบนัส (C / C ++ 11)

การทดสอบแบบดั้งเดิมโดยใช้วิธีการที่ไร้เดียงสาเป็นสิ่งที่สำคัญมาก นั่นเป็นเหตุผลที่ฉันคิดค้นวิธีสุ่มไร้เดียงสาแบบใหม่! การทดสอบนี้มีดังนี้:

1. เลือกจำนวนเต็มใด ๆdที่สุ่ม ก็จะต้องไม่น้อยกว่า 2 sqrt(n)คนและมีขนาดใหญ่กว่าน้อยกว่า
2. ถ้าdเป็นตัวหารของn , not primeเอาท์พุท
3. ถ้าเราทำการทดสอบ20sqrt(n)ครั้งนี้เอาท์พุทprimeมิฉะนั้นทำซ้ำ

หากตัวเลขนั้นประกอบกันแสดงว่ามีความน่าจะเป็นน้อยมากเท่านั้น (ประมาณ 10 ^-9 ) ที่มันไม่ทำงาน แน่นอนฉันไม่เชื่อว่าตัวสร้างหมายเลข C / C ++ หลอกเทียมมีประสิทธิภาพเพียงพอ นั่นเป็นเหตุผลที่ฉันใช้LFSR กำเนิด 256 บิตของฉันเอง!

#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_rangeชนิดเป็นชนิดเริ่มต้น C, intที่ เมื่อเรา "ลอง" เพื่อคูณตัวแปรนี้ด้วย 1.11111 ใน C มันจะได้รับ "ไม่ได้ตั้งใจ" zeroed ในระหว่างการหารด้วย 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 ที่นี่และจาวาสคริปต์ที่นี่

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

ฉันว่ามันใกล้เคียงกับโซลูชั่น Mathematica อย่างน่าตกใจซึ่งหลังจากนั้นมีการตรวจสอบตัวเลขในตัว

แก้ไข:ขอบคุณ Peter ที่บันทึกอีกสองหกไบต์!

นี่คือรายละเอียดบางส่วน:

• สิ่งแรกที่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}#";

โซลูชันก่อนหน้าของฉันมีการออกแบบอย่างมีนัยสำคัญมากเกินไป อันนี้เป็นแรงบันดาลใจอย่างมากจากวิธีการแก้ปัญหาของ Martin Büttnerรวมถึงการตระหนักว่า#bytesวิธีการนี้สามารถใช้บล็อกได้

มันทำงานยังไง?

อักขระความคิดเห็นของรูบี้ ( #) เป็นตัวดำเนินการยกกำลังใน CJam ดังนั้นเราจะต้องมีอย่างน้อยสองตัวเลขในสแต็กก่อนที่เราจะเริ่มต้น แต่สองตัวเลขเปลือย ( 0 0) เป็นข้อผิดพลาดทางไวยากรณ์ใน Ruby หนึ่งคือดี แต่และเป็นประโยชน์ตัวเลข Ruby สามารถมีขีดล่างเป็นตัวคั่น ( 1_234) _เป็นผู้ดำเนินการซ้ำซ้อนของ CJam ดังนั้นเราจึงจำเป็นต้องปรากฏสองครั้ง ( ;;) เมื่อเราอยู่ในความคิดเห็น limpอ่านบรรทัดจากอินพุตมาตรฐานแปลงเป็นเลขจำนวนเต็มดึงข้อมูลนั้นและผลักดันว่าเป็นจำนวนเฉพาะหรือไม่

ในการเข้าสู่โหมด Ruby เราเปิดสตริงและดำเนินการต่อไปยังบรรทัดถัดไปเพื่อให้เราไม่ได้อยู่ในความคิดเห็นของ Ruby อีกต่อไป (ดังนั้นบรรทัดใหม่นั้นมีความสำคัญและต้องนับ) อักขระแต่ละตัวของข้อความนั้นถอดรหัสและพิมพ์แล้วเราจะเริ่มความคิดเห็น Ruby อีกอันเพื่อให้เราสามารถปิดสตริง CJam ได้อย่างปลอดภัยก่อนที่จะเปิดมัน สิ่งที่เหลืออยู่ในสแต็กคืออินพุตนั้นเป็นไพร์มหรือไม่ซึ่งจะถูกพิมพ์เมื่อสิ้นสุดโปรแกรม CJam

CJam / Whitespace 353 ตัวอักษร (25 ความหมายเมื่อพิมพ์)

กำหนดลักษณะซ่อนเร้นของความท้าทายและความจริงที่ว่าเจ้านายจะได้รับการพิมพ์โปรแกรมของเราเพื่อนับตัวละครที่ฉันหยิบข้อเสนอแนะในการดำเนินการแก้ปัญหาที่เกี่ยวข้องกับช่องว่าง

ตรงกันข้ามกับการยืนยันก่อนหน้าของฉันว่าโปรแกรม Whitespace ที่สั้นที่สุดที่เป็นไปได้ซึ่งพิมพ์ว่า "หากหัวหน้าพบสิ่งนี้ฉันจะเลิก" จะเป็น 372 ตัวอักษรตัวนี้ทำใน 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)

แก้ไข:เดิมฉันลืมพิมพ์ประโยคจริง ๆ แล้วสังเกตว่ามันจะพิมพ์ในลำดับย้อนกลับ ฉันสังเกตสิ่งนี้หลังจากทำเสร็จแล้ว ฉันพร้อมที่จะฆ่าลูกแมวแล้ว แต่ตอนนี้ฉันซ่อมได้แล้ว

มันไม่สั้นอีกต่อไป แต่ฉันเชื่อว่าการทำให้มันไม่เป็นมงคลและสั้นเป็นหนึ่งในงานที่ยาก ฉันได้นำมาใช้ใหม่หนึ่งในผลงานตีกอล์ฟจริงของฉัน แต่ในครั้งนี้ฉันจะบอกว่าภาษาที่สองยากที่จะมองเห็น

ถ้าเจ้านายพบสิ่งนี้ฉันจะเลิกเพราะฉันจะไม่สามารถดูถูกเขาอย่างลับ ๆ และถ้าฉันทำอย่างนั้นไม่ได้ประเด็นคืออะไร?

# ^ 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}#*)

ทับทิมใช้งานได้เพราะทั้งสอง#แสดงความคิดเห็นทุกอย่างที่เป็น Mathematica เหตุผลที่ Mathematica ใช้งานได้น่าสนใจมากกว่านี้ รหัสที่ฉันต้องการใช้งานคือ:

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

แต่นั่นไม่ถูกต้อง Ruby ดังนั้นฉันต้องเพิ่ม#ที่ไหนสักแห่ง #เป็นพารามิเตอร์ของ Mathematica สำหรับฟังก์ชั่นที่ไม่ระบุชื่อ ดังนั้นผมจึงใส่ที่ด้านหน้าซึ่งคูณอาร์กิวเมนต์ที่มีผลมาจากการที่# Ifใช่มันจะคูณด้วยสตริง , สิ่งที่หมายถึง แล้วฉันจะเปิดนี้เป็นฟังก์ชั่นที่ไม่ระบุชื่อด้วยและเรียกว่าทันทีที่มีการโต้แย้ง& 1Mathematica ฉลาดพอที่จะรู้ว่าการคูณด้วย 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 ใช้สิ่งนี้เป็น brainfuck โดยมีเพียงหนึ่งหมายเลขอินพุตเท่านั้นที่จะส่งออกสตริงที่เหมาะสม มีอินพุตมากกว่าหนึ่งรายการและคุณจะต้องตรวจสอบให้แน่ใจว่าอินพุตของโปรแกรม brainfuck มีค่าเป็นไบต์ว่าง

Perl / Befunge-93 (108 106 110 )

การส่งครั้งที่สองของฉันเพียงเพราะ ยังใช้นิพจน์ทั่วไป ฉันเดิมพันว่ามีตัวเลือกที่ดีกว่า Perl เช่น Octave แต่ฉันไม่สามารถหาวิธีพิมพ์แบบมีเงื่อนไขได้ในเวลาสั้น ๆ

ฉันกำลังใช้กฎที่ผิดเพื่อให้สายที่จะพิมพ์ขณะที่ฉันกำลังหลีกเลี่ยง anagrams โดยแยกออกเป็นหลายสาย

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

หมายเลขที่จะตรวจสอบนำมาจาก stdin

• แก้ไข:ฉันเขียนคำว่า "ของฉัน" แทน "the" โดยไม่ได้ตั้งใจแก้ไขด้วยค่า +1 ไบต์
• แก้ไข:ใช้ifแทนการunlessบันทึก 4 ไบต์
• แก้ไข:ลืมเกี่ยวกับ "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 Bytes (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;