Terlepas dari protes Anda, Anda telah dipekerjakan oleh atasan Anda pada sebuah program yang menggunakan bilangan bulat tak bertanda sebagai input dan mencetak string "prima" jika bilangan bulat itu prima dan "tidak prima" jika tidak. Anda dapat memilih bahasa tempat Anda melakukan ini, selama program yang dihasilkan pendek; bos Anda sangat menghargai jumlah karakter yang rendah. (Dia benar-benar akan menghitung karakter secara manual setelah dia mencetak kode sumber.)

Jadi Anda lebih baik mencapainya, jumlah karakter terendah menang.

Bagian yang menyenangkan

Ini hanya antara Anda dan saya, tetapi program Anda juga harus valid dalam bahasa lain. Dalam bahasa ini, ia seharusnya mencetak string "Jika bos menemukan ini, saya berhenti.". Pastikan bos Anda tidak menemukan ada penghinaan tersembunyi ketika membaca kode berulang-ulang karena ia terus lupa jika ia menghitung sampai 17 atau 18 sejauh ini. Untuk alasan itu Anda tidak boleh menggunakan kata apa pun dalam "bos menemukan ini berhenti" di bagian kode juga tidak dapat Anda gunakan dan anagram dari 5 kata itu.

Tantangan bonus yang saya buat untuk hadiah

Menulis program yang benar-benar terlihat seperti itu hanya memecahkan pertanyaan pertama dengan mata yang tidak terlatih dan tampaknya tidak mengandung karakter yang tidak perlu. Ini termasuk komentar dan segmen kode yang jelas tidak berkontribusi apa pun. Idealnya, orang awam akan percaya bahwa program Anda sebenarnya sesingkat mungkin tanpa menjadi tidak terkendali. Komentar yang bermanfaat di sana-sini tidak masalah.

Aturan untuk tantangan bonus sedikit lebih longgar, daripada dinilai berdasarkan kriteria yang mudah diukur, program Anda akan dinilai lebih banyak tentang bagaimana hal itu sampai kepada saya (dan pemilih tentu saja)

Saya akan menjadi hakim terakhir yang entri paling dekat dengan layak mendapatkan hadiah ini.

Sunting:

Setelah beberapa menit penghitungan bos Anda, dia meminta salah satu kolega Anda menulis program penghitungan karakter untuknya. Jadi, bahkan karakter yang tidak terlihat dihitung terhadap jumlah karakter Anda.

CJam ( GolfScript ), 60 59 byte

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

Terima kasih kepada @mnbvmar untuk bermain golf 1 byte!

Bagaimana cara kerjanya (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. ";

Cobalah online!

Bagaimana cara kerjanya (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.

Cobalah online!

Python 2 / Python 3 - 128

n=int(input())
s="Isf  tthhies ,b oIs sq ufiitn.d"
print(["not "*any([n%a<1for a in range(2,n)])+"prime",s[::2]+s[1::2]][1/2>0])

Mengidentifikasi bilangan prima dengan Python 2 , membuat Anda kesulitan dengan Python 3 .

Bonus

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

Cobalah dengan Python 2 atau Python 3 ! (Berbeda dengan versi golf di atas peran berubah: Python 3 adalah pengidentifikasi bilangan prima. Python 2 berisi telur Paskah.)

Tolong, maafkan bahasa Inggris saya yang buruk di teks bantuan! ;)

Dan saya menggunakan kata "berhenti". Tapi entah bagaimana saya perlu menjelaskan kapan program saya berakhir. ;)

Pengajuan bonus (C / C ++ 11)

Pengujian primality menggunakan metode naif yang biasa begitu mainstream. Itu sebabnya saya telah menemukan metode naif acak baru! Tes ini adalah sebagai berikut:

1. Pilih sembarang bilangan bulat d secara acak. Itu tidak boleh lebih kecil dari 2 dan lebih besar dari sedikit lebih dari sqrt(n).
2. Jika d adalah pembagi n , output not prime.
3. Jika kami membuat 20sqrt(n)waktu pengujian ini , hasilnya prime, ulangi lagi.

Jika angkanya gabungan, hanya ada sedikit kemungkinan (sekitar 10 ^-9 ) yang tidak berfungsi. Tentu saja, saya tidak percaya generator nomor pseudorandom C / C ++ cukup kuat. Itu sebabnya saya menggunakan generator LFSR 256-bit saya sendiri !

#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 bekerja dengan benar. Namun, kompiler C tampaknya mengeluarkan program yang salah untuk n> 2 ...

Catatan : ingat bahwa C membutuhkan -lmopsi (tautan perpustakaan matematika) untuk dikompilasi dengan sukses.

Lihatlah max_rangevariabel. Kata kunci C ++ 11 autoteratasi menjadi "jenis pencocokan" - dalam hal ini double. Namun, dalam C itu didefinisikan sebagai pengubah variabel (seperti apa staticadanya) - itu tidak menentukan jenis. Jadi max_rangetipe adalah tipe C default, yaitu int. Ketika kita "mencoba" untuk mengalikan variabel ini dengan 1.11111, di C itu akan "tidak sengaja" memusatkan perhatian selama pembagian dengan 100000. Kita mendapatkan interval yang salah dari angka acak yang akan dihasilkan dan LFSR setelah melanjutkan keadaan internalnya menghasilkan kesalahan, menghasilkan biner buang biji. Itu "tidak sengaja" Pesan Jika bos menemukan ini, saya berhenti. \ N

Jika Anda menemukan output salah berikut:

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

salah, cukup hapus fprintfbaris yang sesuai .

Mathematica / Brainfuck, 260

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

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

Coba Golfscript di sini dan Javascript di sini .

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

Saya akan mengatakan itu sangat dekat dengan solusi Mathematica yang, bagaimanapun, memiliki pemeriksaan bawaan untuk bilangan prima.

Sunting: Terima kasih kepada Peter karena telah menyimpan dua enam byte lagi!

Berikut beberapa detailnya:

• Yang pertama 1.diperlukan karena berikut //ini adalah komentar dalam Javascript, tetapi melakukan pembagian dua kali dalam Golfscript. Ini akan error jika tidak ada yang ada di stack, jadi kita perlu memberikannya dua angka. Kebetulan, 1.ini adalah sintaks yang benar-benar valid dalam Javascript dan hanya akan diabaikan.
• "…"{(}%mengambil string, mengurangi nilai kode karakter mereka dengan satu dan mendorongnya sebagai string. Ini menghasilkan string yang perlu kita cetak.
• ' mulai string dalam Golfscript yang secara default meluas ke beberapa baris, menyebabkan Javascript di bawah ini hanya dimasukkan ke dalam string.
• Berikutnya adalah kode Javascript, yang menggunakan pendekatan yang agak terkenal untuk mendeteksi bilangan prima melalui ekspresi reguler.
• ';#'menutup string multi-baris dalam Golfscript, membuangnya dan kemudian mengabaikan sisa baris. Dalam Javascript, ini hanyalah string literal yang akan diabaikan.

C ++ / C99 / C90 - 248

Kode akan berjalan dengan baik di C90, tetapi dapat menunjukkan sesuatu yang lain di C99 / C ++.

Hapus golf untuk kejelasan:

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

Bagaimana ini bekerja: Karena C90 tidak mengenali komentar baris tunggal, string masalah tidak lagi dikalikan dengan nol.

CJam / Ruby, 132 95 91 87

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

Solusi saya sebelumnya sangat direkayasa secara berlebihan; yang satu ini sangat terinspirasi oleh solusi Martin Büttner, termasuk kesadarannya bahwa #bytesmetode tersebut tampaknya dapat menghambat.

Bagaimana cara kerjanya?

Karakter komentar Ruby ( #) adalah operator eksponensial di CJam, jadi kita akan membutuhkan setidaknya dua angka pada stack sebelum kita mulai, tetapi dua angka telanjang ( 0 0) adalah kesalahan sintaksis dalam Ruby. Namun, satu saja baik-baik saja, dan, sangat membantu, angka-angka Ruby dapat berisi garis bawah sebagai pemisah ( 1_234). _adalah operator duplikasi CJam, jadi kita perlu pop dua kali ( ;;) setelah kita berada di dalam komentar. limpmembaca baris dari input standar, mengubahnya menjadi integer, muncul, dan mendorong apakah itu prima atau tidak.

Untuk masuk ke mode Ruby, kita membuka sebuah string dan melanjutkan ke baris berikutnya sehingga kita tidak lagi dalam komentar Ruby (dengan demikian, baris baru itu signifikan dan harus dihitung). Setiap karakter pesan diterjemahkan dan dicetak, dan kemudian kita mulai komentar Ruby lainnya sehingga kita dapat menutup string CJam dengan aman sebelum muncul. Apa yang tersisa di tumpukan adalah apakah inputnya prima, yang akan dicetak pada penghentian program CJam.

CJam / Whitespace, 353 (25 bermakna saat dicetak) karakter

Mengingat sifat tantangan yang tidak jelas, dan fakta bahwa bos akan mencetak program kami untuk menghitung karakter, saya menerima saran untuk melakukan solusi yang melibatkan Whitespace .

Bertentangan dengan pernyataan saya sebelumnya bahwa program spasi putih terpendek yang mencetak "Jika bos menemukan ini, saya berhenti." akan menjadi 372 karakter, yang ini melakukannya di 330. Caranya adalah dengan menggunakan copyinstruksi untuk memetik karakter yang berulang dari suatu tempat di stack daripada mendorong semua nilai ASCII, yang selalu akan menjadi jauh lebih besar dan karenanya membutuhkan lebih banyak ruang dan tab untuk menyandikan. Berikut ini adalah representasi pseudo-assembly program untuk yang penasaran:

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

Penyerahan Hadiah Bonus (Perl / B? F? N? E-? 3)

Sunting: Saya awalnya lupa untuk benar-benar mencetak kalimat dan kemudian menyadari itu akan mencetaknya dalam urutan terbalik. Saya perhatikan ini setelah selesai. Saya hampir siap untuk membunuh anak kucing, tetapi saya memperbaikinya sekarang.

Ini sama sekali tidak singkat, tetapi saya percaya bahwa membuatnya tidak mencurigakan dan pendek adalah tugas yang sangat sulit. Sebagian besar saya telah menggunakan kembali salah satu kiriman golf saya yang sebenarnya, tetapi dalam yang ini saya akan mengatakan bahasa kedua sangat sulit dikenali.

Jika bos menemukan ini, saya benar-benar berhenti, karena saya tidak akan pernah bisa secara diam-diam menghinanya dan jika saya tidak bisa melakukan itu, apa gunanya?

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

Membengkokkan dan Melanggar Aturan:

• Saya menggunakan kata "the" di sana, tetapi bukan "the" yang dicetak. Mungkin secara teknis tidak valid, saya akan membiarkan OP memutuskan apakah aturannya harus seketat ini untuk tantangan bonus. Jika demikian, maka jadilah itu.
• Aturan menyatakan saya tidak dapat menggunakan kata-kata tertentu, tetapi kami membaca dari kiri ke kanan, jadi saya menganggap kata-kata yang dituliskan secara vertikal adalah sah.
• Saya tidak tahu bagaimana saya masih mendapatkan pekerjaan ini, melihat hal-hal buruk yang saya tulis dalam komentar. Maksud saya: teka-teki, benarkah?

Mathematica / Ruby, 115 106 byte

Bagian Mathematica sedikit terinspirasi oleh pengajuan Peter Olson, tetapi polyglotting dengan Ruby sedikit lebih rumit di sini.

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

Ruby berfungsi, karena keduanya #mengomentari semua yang Mathematica. Alasan mengapa Mathematica bekerja sedikit lebih menarik. Kode yang ingin saya jalankan adalah:

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

Tapi itu bukan Ruby yang valid, jadi saya perlu menambahkan suatu #tempat. #adalah parameter Mathematica untuk fungsi anonim. Jadi saya letakkan #di depan, yang mengalikan argumen dengan hasil If. Ya, itu akan menggandakannya dengan string , apa pun artinya. Kemudian saya mengubahnya menjadi fungsi anonim &dan langsung menyebutnya dengan argumen 1. Yah, Mathematica cukup pintar untuk mengetahui bahwa perkalian dengan 1 selalu merupakan identitas dan hanya menghasilkan string. Setelah itu, kode Ruby cukup dimasukkan dalam komentar blok.

C (Penyerahan Bonus)

Versi C adalah pemeriksa utama, input array di bagian atas. Coba tebak bahasa apa yang dihasilkan If the boss finds this, I quit.(Ini bukan Whitespace).

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

Bahasa lainnya:

Brainfuck . Menjalankan ini sebagai brainfuck dengan hanya satu nomor input akan menampilkan string yang sesuai. Setiap lebih dari satu input, dan Anda harus memastikan input ke program brainfuck adalah nol byte.

Perl / Befunge-93 (108 106 110 )

Kiriman kedua saya, hanya karena. Juga menggunakan ekspresi reguler. Saya yakin ada pilihan yang lebih baik daripada Perl, misalnya Oktaf, tetapi saya tidak tahu cara mencetak dengan cara yang singkat.

Saya menyalahgunakan aturan untuk string yang akan dicetak karena saya menghindari anagram dengan membaginya menjadi beberapa string.

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

Nomor yang akan diperiksa diambil dari stdin.

• Sunting: Saya menulis "saya" bukannya "yang" secara tidak sengaja, memperbaikinya biayanya +1 byte.
• Sunting: menggunakan ifbukannya unless4 byte yang disimpan.
• Sunting: Lupa tentang "the", membelah itu juga berharga +2 byte.

Lua / PBrain (prosedural Brainf * ck) - 813

Heh ... Maaf, terjebak dalam usaha untuk menjadi licik. PBrain sama seperti BF, tetapi memungkinkan Anda untuk memicu dan mendefinisikan blok kode BF yang dapat digunakan kembali. Penggunaannya sama sekali tidak perlu.

--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 tidak termasuk komentar)

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

Ini menggunakan algoritma yang sangat sederhana (yaitu tidak efisien). Ketika dijalankan dengan rot13 (bisa dibilang bukan bahasa pemrograman), ia menghasilkan kalimat yang diperlukan (bersama dengan omong kosong lainnya).

Bagian terburuknya adalah bahwa komentar menyatakan yang jelas dan tidak berguna sama sekali.

Ini adalah polyglot dengan cara lain, dengan memuat bahasa Inggris dan "Esperanto." Saya harap bosnya sendiri bukan polyglot.

05AB1E / Jelly , 28 byte

Bukan satu, tapi DUA bahasa golf!

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

Penjelasan dalam 05AB1E:

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

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

Cobalah online! (Jelly) Cobalah secara online! (05AB1E)

Python, 403 byte

Ini dimaksudkan untuk tantangan bonus. Komentar tidak dihitung dengan 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"

Tes di bagian bawah kode cetak:

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

Max integer yang saya definisikan (mi) menyembunyikan rahasianya. Jika dikonversi menjadi hex, representasi surat ASCII dari setiap dua digit hex menyatakan, "Jika bos menemukan ini, saya berhenti." Bagian licik menggunakan fungsi chr. Jika bos tahu apa yang dilakukannya dan terlihat cukup hati-hati, dia akan tahu bahwa kode itu menyembunyikan pesan rahasia. Namun saya sedikit mengaburkan hal itu dan memberikan penjelasan yang cukup untuk seluruh hal integer maks untuk berharap meyakinkan bos bahwa itu adalah bagian yang sah dari program

Perhatikan bahwa untuk sebagian besar parameter berfungsi seperti yang diinginkan bos, tetapi jika input bukan bilangan bulat atau angkanya lebih besar dari mi, p mengembalikan kesalahan yang berisi string tersembunyi. Saya bisa saja memasukkan panggilan cetak ke dalam fungsi, tetapi saya pikir itu akan terlihat lebih nyata jika dikembalikan.

C # - 288

Tentu saja bukan yang terpendek, tetapi mungkin melewati banyak bos:

 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;

Versi yang dapat dibaca:

            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;