Mimo twojego protestu szef został zmuszony do pracy nad programem, który przyjmuje jedną liczbę całkowitą bez znaku jako dane wejściowe i wypisuje ciąg „liczba pierwsza”, jeśli ta liczba całkowita jest liczbą pierwszą, a „nie liczba pierwsza”, jeśli nie jest. Możesz wybrać język, w którym to robisz, o ile wynikowy program jest krótki; twój szef bardzo docenia niską liczbę postaci. (W rzeczywistości ręcznie policzy znaki po wydrukowaniu kodu źródłowego.)

Więc lepiej się do tego zabrać, wygrywa najmniejsza liczba postaci.

Część zabawy

To tylko między tobą a mną, ale twój program powinien być również ważny w innym języku. W tym języku powinien jednak wypisać ciąg „Jeśli szef to znajdzie, wychodzę”. Upewnij się, że twój szef nie odkrywa, że ​​istnieje ukryta zniewaga podczas czytania kodu w kółko, ponieważ ciągle zapomina, czy do tej pory policzył do 17 czy 18 lat. Z tego powodu nie możesz używać żadnego słowa w „szef znajduje to wyjście” w części kodu, ani nie możesz używać ani anagramów tych 5 słów.

Bonusowe wyzwanie, za które stworzyłem nagrodę

Napisz program, który faktycznie wygląda tak, że rozwiązuje pierwsze pytanie dla niewprawnego oka i nie zawiera niepotrzebnych znaków. Obejmuje to komentarze i segmenty kodu, które oczywiście nic nie wnoszą. W idealnym przypadku laik wierzyłby, że twój program jest tak krótki, jak to tylko możliwe, bez niemożności zarządzania. Pomocny komentarz tutaj i tam jest w porządku.

Zasady wyzwania premiowego są nieco luźniejsze, zamiast oceniać je na podstawie łatwych do zmierzenia kryteriów, twój program będzie oceniany bardziej na podstawie tego, jak się do mnie zbliży (i oczywiście wyborców)

Będę ostatecznym sędzią, którego zgłoszenie najbliżej zasłuży na tę nagrodę.

Edytować:

Po kilku minutach liczenia szefa kazał jednemu z twoich kolegów napisać dla niego program liczenia znaków. Zatem nawet niewidoczne postacie liczą się do twojej postaci.

CJam ( GolfScript ), 60 59 bajtów

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

Dzięki @mnbvmar za grę w golfa na 1 bajcie!

Jak to działa (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. ";

Wypróbuj online!

Jak to działa (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.

Wypróbuj 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])

Identyfikuje liczby pierwsze w Pythonie 2 , wpadasz w kłopoty z Pythonem 3 .

Premia

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

Wypróbuj z Python 2 lub Python 3 ! (W przeciwieństwie do wersji golfowej powyżej zmienione role: Python 3 jest identyfikatorem liczby pierwszej. Python 2 zawiera pisankę).

Proszę wybaczyć mój zły angielski w tekście pomocy! ;)

I używam słowa „rzucić”. Ale w jakiś sposób muszę opisać, kiedy mój program się zakończy. ;)

Przekazanie premii (C / C ++ 11)

Testowanie pierwszorzędności przy użyciu zwykłej naiwnej metody jest tak powszechne. Właśnie dlatego wymyśliłem zupełnie nową randomizowaną naiwną metodę! Ten test jest następujący:

1. Wybierz dowolną liczbę całkowitą d losowo. Nie może być mniejszy niż 2 i większy niż nieco więcej niż sqrt(n).
2. Jeśli d jest dzielnikiem n , wyjście not prime.
3. Jeśli wykonaliśmy ten 20sqrt(n)czas testu , wyjdź prime, w przeciwnym razie powtórz.

Jeśli liczba jest złożona, prawdopodobieństwo , że nie zadziała , jest bardzo małe (około ^10–9 ). Oczywiście nie wierzę, że generator liczb pseudolosowych C / C ++ jest wystarczająco mocny. Dlatego używam własnego 256-bitowego generatora LFSR !

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/* A 256-bit linear feedback shift register generating pseudorandom
 * numbers (its period is 2^256 - 1).
 */
struct LFSRGenerator {
    unsigned seed[8];
};

void lfsr_init_generator(struct LFSRGenerator *gen){
    gen->seed[0] = 0xE840CC92; gen->seed[1] = 0xC440CAD0;
    gen->seed[2] = 0x40E6E6DE; gen->seed[3] = 0xC8DCD2CC;
    gen->seed[4] = 0xD0E840E6; gen->seed[5] = 0x4058E6D2;
    gen->seed[6] = 0xEAE24092; gen->seed[7] = 0x145CE8D2;
}
void lfsr_proceed(struct LFSRGenerator *gen){
    // LFSR taps are x^256, x^254, x^251 and x^246
    unsigned new_bit =
        ((gen->seed[7]>>0)^(gen->seed[7]>>2)^
         (gen->seed[7]>>5)^(gen->seed[7]>>10)) & 1;

    // shift seed right
    gen->seed[7] >>= 1;
    int cell;
    for(cell = 6; cell >= 0; cell--){
        gen->seed[cell+1] |= ((gen->seed[cell]&1)<<31);
        gen->seed[cell] >>= 1;
    }
    gen->seed[0] |= (new_bit<<31);  // put new bit
}
void lfsr_error(struct LFSRGenerator *gen){
    fprintf(stderr, "Error! Developer info:\n");

    int cell;
    for(cell = 0; cell < 8; cell++){
        unsigned val = gen->seed[cell];
        putc((char)(val&0xFF), stderr); val >>= 8;
        putc((char)(val&0xFF), stderr); val >>= 8;
        putc((char)(val&0xFF), stderr); val >>= 8;
        putc((char)(val&0xFF), stderr);
    }
    putc('\n', stderr);
    exit(1);
}
int lfsr_get_num(struct LFSRGenerator *gen, int min_val, int max_val){
    lfsr_proceed(gen);
    int mod_num = max_val-min_val+1;   // = number of possible results
    if(mod_num <= 0)
        lfsr_error(gen);

    // take 6 first cells and compute them mod 'modNum'
    unsigned long long result = 0;
    int cell;
    for(cell = 5; cell >= 0; cell--){
        result = ((result << 32) | gen->seed[cell]) % mod_num;
    }
    return (int)result + min_val;
}

/**********************************************************************/



void end_not_prime(){
    printf("not prime\n");
    exit(0);
}
void end_prime(){
    printf("prime\n");
    exit(0);
}



int main(){ 
    int number;
    struct LFSRGenerator gen;
    lfsr_init_generator(&gen);


    printf("Provide a number to check its primality: ");
    scanf("%d", &number);

    if(number <= 1){
        end_not_prime();
    }
    if(number == 2){
        end_prime();
    }

    // just to make sure:
    //  * make 20*sqrt(n) tests
    //  * generate random divisors from 2 to 111111/100000 * sqrt(n)
    //      (in case max range doesn't include sqrt(n)
    auto num_checks = (int)floor(sqrt(number)*20);
    auto max_range = sqrt(number);
    max_range /= 100000;
    max_range *= 111111;
    max_range = floor(max_range+0.5);

    while(num_checks--){
        int rnd_div = lfsr_get_num(&gen, 2, max_range);
        if(number % rnd_div == 0){
            end_not_prime();
        }
    }
    end_prime();
}

C ++ 11 działa poprawnie. Wydaje się jednak, że kompilator C wydaje wadliwy program dla n> 2 ...

Uwaga : pamiętaj, że C potrzebuje -lmopcji (biblioteka matematyczna linków), aby się kompilować.

Spójrz na max_rangezmienną. Słowo kluczowe C ++ 11 jest autotłumaczone na „pasujący typ” - w tym przypadku double. Jednak w C jest zdefiniowany jako modyfikator zmiennej (jak staticjest) - nie definiuje typu. Tak więc max_rangetyp to domyślny typ C, to jest int. Kiedy „próbujemy” pomnożyć tę zmienną przez 1.11111, w C zostaje ona „niezamierzona” zerowana podczas dzielenia przez 100000. Otrzymujemy niepoprawny przedział liczb losowych do wygenerowania, a LFSR po przejściu do stanu wewnętrznego generuje błąd, generując binarny zrzut nasion. To „przypadkowo” Wiadomość Jeśli szef to znajdzie, wychodzę. \ N

Jeśli znajdziesz następujące wadliwe dane wyjściowe:

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

niepoprawnie, po prostu usuń odpowiedni fprintfwiersz.

Mathematica / Brainfuck, 260

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

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

Wypróbuj Golfscript tutaj i JavaScript tutaj .

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

Powiedziałbym, że jest szokująco blisko tych rozwiązań Mathematica, które mają wbudowane sprawdzanie liczb pierwszych.

Edycja: Dzięki Peterowi za zapisanie kolejnych dwóch sześciu bajtów!

Oto kilka szczegółów:

• Pierwszy 1.jest potrzebny, ponieważ poniżej //jest komentarz w JavaScript, ale wykonuje dwukrotnie podział w Golfscript. Spowoduje to błąd, jeśli na stosie nie ma nic, więc musimy podać dwie liczby. Nawiasem mówiąc, 1.jest to całkowicie poprawna składnia w JavaScript i zostanie po prostu zignorowana.
• "…"{(}%bierze ciąg, zmniejsza ich wartości kodu znakowego o jeden i wypycha go jako ciąg. To powoduje, że musimy wydrukować ciąg.
• ' uruchamia ciąg w Golfscript, który domyślnie rozciąga się na kilka wierszy, powodując, że poniższy JavaScript jest wstawiany tylko do ciągu
• Dalej jest kod JavaScript, który wykorzystuje dość dobrze znane podejście do wykrywania liczb pierwszych za pomocą wyrażeń regularnych.
• ';#'zamyka ciąg wieloliniowy w Golfscript, odrzuca go, a następnie ignoruje resztę wiersza. W Javascript jest to po prostu literał ciągu, który zostanie zignorowany.

C ++ / C99 / C90 - 248

Kod będzie działał ładnie w C90, ale może pokazywać coś jeszcze w C99 / C ++.

Bez golfa dla przejrzystości:

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

Jak to działa: Ponieważ C90 nie rozpoznaje komentarzy jednowierszowych, ciąg problemu nie jest już mnożony przez zero.

CJam / Ruby, 132 95 91 87

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

Moje poprzednie rozwiązanie było znacznie przeprojektowane; ten był w dużej mierze zainspirowany rozwiązaniem Martina Büttnera, w tym jego zdaniem sobie sprawy, że #bytesmetoda może najwyraźniej zrobić blok.

Jak to działa?

Komentarz Ruby ( #) jest operatorem potęgowania w CJam, więc zanim zaczniemy, będziemy potrzebować co najmniej dwóch liczb na stosie, ale dwie puste liczby ( 0 0) to błąd składniowy w Ruby. Jedna jest w porządku i, pomocne, liczby Ruby mogą zawierać znaki podkreślenia jako separatory ( 1_234). _jest operatorem duplikacji CJam, więc musimy wstawić dwukrotnie ( ;;), gdy znajdziemy się w komentarzu. limpodczytuje wiersz ze standardowego wejścia, konwertuje go na liczbę całkowitą, wyskakuje i wypycha, czy jest liczbą pierwszą.

Aby przejść do trybu Ruby, otwieramy ciąg i przechodzimy do następnego wiersza, abyśmy nie byli już w komentarzu Ruby (dlatego nowa linia jest znacząca i należy ją policzyć). Każdy znak wiadomości jest dekodowany i drukowany, a następnie rozpoczynamy kolejny komentarz Ruby, abyśmy mogli bezpiecznie zamknąć ciąg CJam przed jego usunięciem. To, co zostało na stosie, to to, czy dane wejściowe były pierwsze, które są drukowane po zakończeniu programu CJam.

CJam / Whitespace, 353 (25 znaczących po wydrukowaniu) znaków

Biorąc pod uwagę niedoceniany charakter wyzwania i fakt, że szef będzie drukował nasze programy w celu policzenia postaci, podjąłem sugestię zrobienia rozwiązania z udziałem Whitespace .

W przeciwieństwie do mojego poprzedniego twierdzenia, że ​​najkrótszy możliwy program do białych znaków, który wypisuje „Jeśli szef to znajdzie, rezygnuję”. miałby 372 znaków, ten robi to w 330. Sztuczka polega na tym, aby użyć copyinstrukcji, aby wyrywać powtarzające się znaki z jakiegoś miejsca na stosie, zamiast wypychać wszystkie wartości ASCII, które zawsze będą znacznie większe i dlatego wymagają więcej spacji i tabulatory do zakodowania. Oto pseudo-montażowa reprezentacja programu dla ciekawskich:

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

Zgłoszenie nagrody premiowej (Perl / B? F? N? E-? 3)

Edycja: Pierwotnie zapomniałem wydrukować zdanie, a potem zauważyłem, że wydrukuje je w odwrotnej kolejności. Zauważyłem to po zakończeniu . Byłem gotowy zabić kotka, ale teraz go naprawiłem.

Nie jest to już w żaden sposób krótkie, ale uważam, że uczynienie go podejrzliwym i krótkim jest jednym piekielnie trudnym zadaniem. Przeważnie ponownie wykorzystałem jedną z moich rzeczywistych propozycji golfowych, ale w tym jednym powiedziałbym, że drugi język jest naprawdę trudny do zauważenia.

Jeśli szef to znajdzie, naprawdę rezygnuję, ponieważ nigdy nie będę w stanie potajemnie go obrazić, a jeśli nie mogę tego zrobić, jaki jest sens?

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

Gięcie i łamanie zasad:

• Używam tam słowa „the”, ale nie drukuje się „the”. Może to być technicznie nieważne, pozwolę PO zdecydować, czy reguły muszą być tak surowe w przypadku wyzwania bonusowego. Jeśli tak, to niech tak będzie.
• Reguły mówią, że nie mogę używać niektórych słów, ale czytamy od lewej do prawej, więc zakładam, że słowa zapisane pionowo są prawidłowe.
• Nie mam pojęcia, jak dostałem tę pracę, widząc okropne rzeczy, które piszę w komentarzach. Mam na myśli: zagadki, naprawdę?

Mathematica / Ruby, 115 106 bajtów

Część Mathematica została nieco zainspirowana poddaniem się Petera Olsona, ale poliglota z Ruby jest tutaj nieco bardziej rozbudowana.

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

Ruby działa, ponieważ oboje #komentują wszystko, co Mathematica. Powód, dla którego działa Mathematica, jest nieco bardziej interesujący. Kod, który chcę wykonać to:

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

Ale to nie jest poprawne, Ruby, więc muszę coś dodać #. #jest parametrem Mathematica dla funkcji anonimowych. Stawiam więc #z przodu, co zwielokrotnia argument przez wynik If. Tak, pomnoży to przez łańcuch , cokolwiek to znaczy. Następnie zamieniam to w anonimową funkcję &i wywołuję ją natychmiast z argumentem 1. Cóż, Mathematica jest na tyle sprytna, by wiedzieć, że mnożenie przez 1 jest zawsze tożsamością i wyprowadza tylko ciąg. Następnie kod Ruby jest po prostu wstawiany w komentarzu blokowym.

C (przesłanie bonusu)

Wersja C to sprawdzanie liczb pierwszych, tablica wejściowa u góry. Spróbuj zgadnąć, jaki język daje If the boss finds this, I quit.(to nie jest biała spacja).

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

Inny język:

Brainfuck . Uruchamianie tego jako bzdura z tylko jednym numerem wejściowym spowoduje wyświetlenie odpowiedniego ciągu. Dowolne więcej niż jedno wejście, a będziesz musiał upewnić się, że dane wejściowe do programu pieprzenia mózgu są zerowe bajty.

Perl / Befunge-93 (108 106 110 )

Moje drugie zgłoszenie, tylko dlatego, że. Używa również wyrażeń regularnych. Założę się, że jest lepszy wybór niż Perl, na przykład Octave, ale nie mogłem wymyślić, jak drukować warunkowo w skrócie.

Nadużywam reguły drukowania łańcucha, ponieważ unikam anagramów, dzieląc go na kilka łańcuchów.

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

Numer do sprawdzenia pochodzi ze standardowego wejścia.

• Edycja: Przypadkowo napisałem „moje” zamiast „”, a naprawa tego kosztowała +1 bajt.
• Edycja: używając ifzamiast unlesszapisanych 4 bajtów.
• Edycja: zapomniałem o „the”, podzielenie go również kosztowało +2 bajty.

Lua / PBrain (proceduralny Brainf * ck) - 813

Heh ... Przepraszam, że złapałem się na próbach przebiegłości. PBrain jest jak BF, ale umożliwia wyzwalanie i definiowanie bloków kodu BF wielokrotnego użytku. Jego użycie było całkowicie niepotrzebne.

--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 bajtów (69 nie licząc komentarzy)

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

Wykorzystuje to bardzo prosty (tzn. Nieefektywny) algorytm. Po uruchomieniu z rot13 (prawdopodobnie nie językiem programowania), generuje wymagane zdanie (wraz z innymi nonsensami).

Najgorsze jest to, że komentarze stwierdzają oczywistość i są zupełnie bezużyteczne.

To jest poliglotka w inny sposób, zawierająca zarówno angielski, jak i „esperanto”. Mam nadzieję, że sam szef nie jest poliglotą.

05AB1E / galaretka , 28 bajtów

Nie jeden, ale DWA języki gry w golfa!

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

Objaśnienie w 05AB1E:

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

Objaśnienie w galarecie:

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

Wypróbuj online! (Galaretka) Wypróbuj online! (05AB1E)

Python, 403 bajty

Jest to przeznaczone na wyzwanie premiowe. Komentarze nie liczą się do bajtecount.

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

Testy na dole kodu drukują:

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

Ta maksymalna liczba całkowita, którą zdefiniowałem (mi), ukrywa sekret. W przypadku konwersji na szesnastkową reprezentacja liter ASCII co dwie cyfry heksadecymalnej powoduje „Jeśli szef to znajdzie, wychodzę”. Podstępna część korzysta z funkcji chr. Jeśli szef wie, co to robi i szuka wystarczająco uważnie, będzie wiedział, że kod ukrywa tajną wiadomość. Jednak trochę to zaciemniłem i podałem wystarczające wyjaśnienie całej wartości maksymalnej liczby całkowitej, aby, mam nadzieję, zapewnić szefa, że ​​jest to uzasadniona część programu

Zauważ, że dla większości parametrów działa tak, jak chce szef, ale jeśli wejście nie jest liczbą całkowitą lub liczba jest jakoś większa niż mi, p zwraca błąd zawierający ukryty ciąg. Mogłem wstawić wywołanie drukowania do funkcji, ale pomyślałem, że wyglądałoby bardziej realnie, gdyby zostało zwrócone.

C # - 288

Z pewnością nie najkrótszy, ale może minąć wielu bossów:

 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;

Czytelna wersja:

            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;