Protestolarınıza rağmen, patronunuz tarafından giriş olarak tek bir imzasız tamsayı alan ve bu tamsayı asal ise "asal" değilse "asal" dizesini basan bir program üzerinde çalışmaya başladınız. Ortaya çıkan program kısa olduğu sürece, bunu hangi dilde yapacağınızı seçebilirsiniz; Patronunuz düşük karakter sayısını çok takdir ediyor. ( Kaynak kodu yazdırdıktan sonra karakterleri manuel olarak sayar.)

Yani onu almak en iyisi, en düşük karakter sayısı kazanır.

Eğlenceli kısmı

Bu sadece seninle aramızda, ama programın başka bir dilde de geçerli olmalı. Yine de bu dilde, "Patron bunu bulursa istifa ediyorum" dizesini basmalıdır. Patronunuzun, 17 ya da 18 yaşına kadar sayıp saymadığını unutmaya devam ederken, kodu tekrar tekrar okurken gizli bir hakaret olmadığını anladığından emin olun. Bu nedenle kodun bir bölümünde “patronun bu işi bıraktığını” söyleyen kelimelerin hiçbirini kullanamazsınız ve bu 5 kelimenin anagramlarını kullanamazsınız.

Bir ödül yarattığım bonus mücadelesi

Aslında öyle görünen bir program yaz, eğitimsiz göze ilk soruyu çözüyor ve gereksiz karakterler içermiyor gibi görünüyor. Bu, açıkçası hiçbir şeye katkıda bulunmayan yorumları ve kod bölümlerini içerir. İdeal olarak, bir meslekten olmayan kişi programınızın aslında yönetilemez olmadan mümkün olduğu kadar kısa olduğuna inanacaktır. Burada yararlı bir yorum ve orada olsa da tamam.

Bonus yarışması için kurallar biraz daha gevşektir, kolayca ölçülebilir ölçütlere göre değerlendirilmek yerine, programınız bana (ve tabii ki seçmenlere) nasıl geldiği konusunda daha fazla değerlendirilecektir.

Bu ödülü haketmek için en çok giriş yapan yargıç olacağım.

Düzenle:

Patronunuzdan birkaç dakika geçtikten sonra, meslektaşlarınızdan biri onun için bir karakter sayma programı yazdı. Böylece görünür olmayan karakterler bile karakter sayınıza göre sayılır.

CJam ( GolfScript ), 60 59 bayt

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

1 byte kapalı golf için @mnbvmar için teşekkürler!

Nasıl çalışır (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. ";

Çevrimiçi deneyin!

Nasıl çalışır (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.

Çevrimiçi deneyin!

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

Asal sayılar tanımlar Python 2 ile sıkıntı içine var olsun 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])

Python 2 veya Python 3 ile deneyin ! (Rollerin üzerindeki golf versiyonunun aksine değiştirildi: Python 3, asal sayı tanımlayıcısıdır. Python 2, Paskalya yumurtasını içerir.)

Lütfen, kötü İngilizce’mizi yardım metninde bulunun! ;)

Ve ben "bırak" kelimesini kullanıyorum. Ancak bir şekilde programımın ne zaman sona erdiğini açıklamam gerekiyor. ;)

Bonus teslimi (C / C ++ 11)

Her zamanki saf yöntemi kullanarak primallik testi çok yaygın. Bu yüzden yepyeni bir randomize naif yöntem icat ettim! Bu test aşağıdaki gibidir:

1. Herhangi bir tamsayı d'yi rastgele seçin . 2'den küçük ve biraz daha büyük olmamalıdır sqrt(n).
2. Eğer d bir bölen bir n , çıkış not prime.
3. Bu sınama 20sqrt(n)sürelerini yaptıysak , çıktı prime, aksi halde tekrar eder.

Sayı kompozit ise, çalışmaması için çok az bir olasılık (yaklaşık 10 ^-9 ) vardır. Tabii ki, C / C ++ yalancı sayı üreticisinin yeterince güçlü olduğuna inanmıyorum. Bu yüzden kendi 256-bit LFSR jeneratörümü kullanıyorum !

#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 düzgün çalışıyor. Ancak, C derleyicisi n> 2 için hatalı bir program çıkarıyor gibi görünüyor ...

Not : C'nin -lmbaşarılı bir şekilde derlenmesi için seçeneğinin (bağlantı matematik kitaplığı) gerekli olduğunu unutmayın .

max_rangeDeğişkene bakın . C ++ 11 anahtar sözcüğü autobir "eşleme türü" olarak çözülür - bu durumda double. Bununla birlikte, C'de değişken değiştirici (olduğu gibi static) olarak tanımlanır - türü tanımlamaz. Böylece max_rangetür, varsayılan bir C türüdür int. Bu değişkeni 1.11111 ile çarpmayı "denediğimizde, C" de "istemeden" 100000 ile bölme sırasında sıfırlanır. İçsel duruma geçtikten sonra yanlış bir rasgele sayı aralığı üretilir ve ikilinin çıktısını alarak LFSR oluşturulur. tohum dökümü. Bu "yanlışlıkla" mesajı. Eğer patron bunu bulursa, istifa ediyorum. \ N

Aşağıdaki hatalı çıkışı bulursanız:

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

yanlış, sadece uygun fprintfsatırı kaldırın .

Mathematica / Brainfuck, 260

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

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

Burada Golfscript'i ve Javascript'i deneyin .

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

Şaşırtıcı bir şekilde, asal sayılar için yerleşik bir denetime sahip olan Mathematica çözümlerine yakın olduğunu söyleyebilirim.

Düzenleme: Peter iki altı bayt başka kaydettiğiniz için teşekkürler !

İşte bazı detaylar:

• Birincisi 1.gerekli, çünkü aşağıdaki //Javascript'te bir yorum, ancak Golfscript'te iki kez bölme gerçekleştiriyor. Yığında hiçbir şey yoksa, bu hata verir, bu yüzden iki sayı vermemiz gerekir. Bu arada, 1.Javascript'te tamamen geçerli bir sözdizimidir ve sadece göz ardı edilir.
• "…"{(}%dizeyi alır, karakter kod değerlerini birer birer azaltır ve dizge olarak iter. Bu, basmamız gereken dizgeyle sonuçlanır.
• ' Golfscript'te varsayılan olarak birkaç satırın üzerine uzanan ve aşağıdaki Javascript’in yalnızca dizeye konmasına neden olan bir dize başlatır.
• Sonraki, asal sayıları normal ifadelerle saptamak için biraz iyi bilinen bir yaklaşım kullanan Javascript kodudur.
• ';#'çok satırlı dizgiyi Golfscript'te kapatır, atar ve sonra çizginin geri kalanını yok sayar. Javascript'te, bu basitçe yoksayılacak bir dize değişmezidir.

C ++ / C99 / C90 - 248

Kod C90'da iyi çalışır, ancak C99 / C ++ ile başka bir şey gösterebilir.

Netlik için un-golfed:

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

Bu nasıl çalışır: C90 tek satırlık yorumları tanımadığından, sorun dizesi artık sıfır ile çarpılmaz.

CJam / Ruby, 132 95 91 87

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

Önceki çözümüm önemli ölçüde fazla tasarlandı; Bu, Martin Büttner'ın çözümünden esinlenerek, #bytesyöntemin görünüşte bir engel alabileceği idrakını da içeriyordu .

O nasıl çalışır?

Ruby'nin yorum karakteri ( #), CJam'daki üstelleştirme işlecidir, bu nedenle başlamadan önce yığında en az iki sayıya ihtiyacımız olacak, ancak iki çıplak sayı ( 0 0) Ruby'de bir sözdizimi hatasıdır. Bunlardan biri gayet iyi ve yararlı bir şekilde, Ruby sayıları ayırıcılar ( 1_234) olarak alt çizgiler içerebilir . _CJam’ın çoğaltma operatörü olduğundan, ;;yorumun içine girdikten sonra iki kez ( ) basmamız gerekir . limpstandart girdiden bir satır okur, bir tam sayıya dönüştürür, çıkarır ve asal olup olmadığını gösterir.

Ruby moduna girmek için bir dize açıp bir sonraki satıra geçiyoruz, böylece artık Ruby yorumunda değiliz (bu nedenle, yeni satır önemlidir ve sayılmalıdır). İletinin her karakteri kod çözülür ve yazdırılır ve ardından bir başka Ruby yorumu başlatırız; böylece onu açmadan önce CJam dizesini güvenle kapatabiliriz. Yığında kalan şey, girişin asıl olup olmadığı ve CJam programının sonlandırılması üzerine basılmış olması.

CJam / Whitespace, 353 (basıldığında 25 anlamlı) karakter

Mücadelenin temel niteliği ve patronun karakterleri saymak için programlarımızı basacağı gerçeği göz önüne alındığında, Whitespace'i içeren bir çözüm yapma önerisini kabul ettim .

Daha önceki iddiamımın aksine, mümkün olan en kısa Boşluk programının "Patron bunu bulursa, çıkarım" yazdığını iddia ediyorum. 372 karakter olur, bu 330'da yapar. Buradaki hile, copyher zaman çok daha büyük olacak ve böylece daha fazla boşluk gerektiren tüm ASCII değerlerini zorlamak yerine tekrar karakterleri yığının herhangi bir yerinden toplama yöntemini kullanmaktır. ve kodlanacak sekmeler. İşte meraklı için programın sahte montaj gösterimi:

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

Bonus Ödül Gönderimi (Perl / B? F? N? E-? 3)

Düzenleme: Ben aslında cümleyi yazdırmayı unuttum ve sonra ters sırada yazacağını fark ettim. Bunu yaptıktan sonra farkettim . Bir yavru kedi öldürmeye hazırdım, ama şimdi tamir ettim.

Artık hiçbir şekilde kısa değil, ama onu şüpheci ve kısa yapmanın zor bir işin cehennem olduğuna inanıyorum. En çok golf oynadıklarımın bir tanesini yeniden kullandım, ancak bu bölümde ikinci dilin tespit edilmesinin çok zor olduğunu söyleyebilirim.

Eğer patron bunu bulursa, gerçekten bırakıyorum, çünkü gizlice ona hakaret edemeyeceğim ve bunu yapamazsam ne anlamı var?

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

Kuralların Eğilmesi ve Yıkılması :

• Orada "" kelimesini kullanıyorum, ama basılan "kelimesi" değil. Teknik olarak geçersiz olabilir, OP'nin kuralların bonus mücadelesi için bu kadar katı olup olmadığına karar vermesine izin vereceğim. Eğer öyleyse, öyleyse öyle olsun.
• Kurallar, belirli kelimeleri kullanamayacağımı ancak soldan sağa okuduğumuzu belirtir, bu yüzden dikey olarak yazılmış kelimelerin geçerli olduğunu varsayırım.
• Yorumlara yazdığım korkunç şeyleri görerek, bu işe nasıl devam ettiğimi bilmiyorum. Yani: bilmeceler, gerçekten mi?

Mathematica / Ruby, 115 106 bayt

Mathematica bölümü, Peter Olson'ın gönderiminden biraz esinlenmişti, ancak Ruby ile yapılan çok parçalanma burada biraz daha ayrıntılı.

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

Ruby çalışıyor, çünkü ikisi #Mathematica olan her şeyi yorumluyor. Mathematica'nın çalışmasının nedeni biraz daha ilginç. Çalıştırmak istediğim kod:

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

Ama bu geçerli bir Ruby değil, o yüzden bir #yere eklemem gerekiyor. #Mathematica'nın adsız işlevler için parametresidir. Ben öne koydum #, bu argümanı sonucun sonucuyla çarpar If. Evet, bunun anlamı ne olursa olsun, bir dizeyle çarpılacaktır . Sonra bunu anonim bir işleve dönüştürürüm &ve hemen argümanla çağırırım 1. Peki, Mathematica, 1 ile çarpmanın her zaman kimlik olduğunu ve yalnızca dizgeyi çıkardığını bilecek kadar zekidir . Daha sonra, Ruby kodu basitçe bir blok yorumda bulunur.

C (Bonus Gönderme)

C versiyonu bir ana denetleyici, üst kısımdaki giriş dizisidir. Hangi dilin geldiğini tahmin etmeye çalışın If the boss finds this, I quit.(Boşluk değil).

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

Diğer dil:

Brainfuck . Bunu sadece bir giriş numarasına sahip beyin fırtınası olarak çalıştırmak , uygun dizgeyi çıkarır. Birden fazla giriş varsa, beyin tıklatma programına girişin boş bayt olduğundan emin olmanız gerekir.

Perl / Befunge-93 (108 106 110 )

İkinci sunumum, çünkü. Ayrıca düzenli ifadeler kullanır. İddiaya girerim Perl'den daha iyi bir seçim vardır, örneğin Octave, ancak koşullu olarak nasıl kısa bir şekilde basılacağını çözemedim.

Anagramlardan birkaç dizgeye bölünerek kaçınılması nedeniyle dizgenin basılması kuralını kötüye kullanıyorum.

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

Kontrol edilecek numara stdin'den alınmıştır.

• Düzenleme: Yanlışlıkla "1" yerine "benim" yazdım, +1 bayta mal oldu.
• Düzenleme: kullanarak ifyerine unlesskaydedilen 4 bayt.
• Düzenleme: "," 'yı unuttum, bir tanesini + 2 bayt olarak ayırın.

Lua / PBrain (işlemsel Brainf * ck) - 813

Heh ... Üzgünüm, alçakgönüllü olmaya çalışırken yakalandı. PBrain aynı BF gibidir, ancak tekrar kullanılabilir BF kod bloklarını tetiklemenizi ve tanımlamanızı sağlar. Kullanımı tamamen gereksizdi.

--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 Bayt (69 yorum sayılmıyor)

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

Bu çok basit (yani verimsiz) bir algoritma kullanır. Rot13 ile çalıştırıldığında (muhtemelen bir programlama dili değil), gerekli cümleyi üretir (diğer saçmalıklarla birlikte).

En kötü yanı, yorumların açıkça anlaşılması ve yine de oldukça yararsız olmasıdır.

Bu, hem İngilizce hem de “Esperanto” içeren başka bir şekilde çokgendir. İnşallah patron çok polyglot değildir.

05AB1E / Jelly , 28 bayt

Bir değil, İKİ golf dili!

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

05AB1E’deki açıklama:

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

Jelly'te Açıklama:

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

Çevrimiçi deneyin! (Jelly) Çevrimiçi deneyin! (05AB1E)

Python, 403 bayt

Bu bonus mücadelesi için tasarlanmıştır. Yorumlar bytecount'a sayılmaz.

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

Kodun altındaki testler yazdır:

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

Tanımladığım bu tam sayı (mi) sırrı gizler. Eğer hex'e dönüştürülürse, hex'in her iki hanesinin ASCII harf gösterimi “Patron bunu bulursa istifa ediyorum” yapar. Sinsi kısmı chr işlevini kullanıyor. Eğer patron bunun ne yaptığını biliyor ve yeterince dikkatle bakıyorsa, kodun gizli bir mesajı sakladığını bilecektir. Ancak, patronun programın meşru bir parçası olduğunu umduğumda garanti altına almak için tüm tamsayı meselesine biraz açıklama getirdim ve yeterince açıklama yaptım.

Patronun istediği gibi çalıştığını gösteren çoğu parametre için, ancak giriş bir tamsayı değilse veya sayı bir şekilde mi'dan büyükse, p gizli dizgiyi içeren hatayı döndürür. Fonksiyonun içine bir baskı çağrısı koyabilirdim, ancak iade edilirse daha gerçekçi görüneceğini düşündüm.

C # - 288

Kesinlikle en kısa değil, ama birçok patron tarafından geçebilir:

 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;

Okunabilir bir sürüm:

            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;