Незважаючи на ваш протест, ваш начальник розпочав роботу над програмою, яка приймає єдине непідписане ціле число як вхідне і друкує рядок "prime", якщо це ціле число є простим і "не простим", якщо це не так. Ви можете вибрати, на якій мові ви це робите, якщо отримана програма буде короткою; ваш начальник дуже цінує низьку кількість персонажів. (Він насправді буде вручну рахувати символи після того, як він роздрукує вихідний код.)

Тож вам краще дістатися до цього, виграє найменший кількість персонажів.

Весела частина

Це якраз між вами та мною, але ваша програма також повинна діяти іншою мовою. Цією мовою, хоча, він повинен надрукувати рядок "Якщо начальник знаходить це, я кину." Слідкуйте за тим, щоб ваш начальник не з’ясував, що при читанні коду знову і знову читається код, коли він забуває, якщо він досі вважав 17 або 18. З цієї причини ви не можете використовувати жодне зі слів у "начальник знаходить цю справу" в частині коду, а також не можете використовувати та анаграми з цих 5 слів.

Бонусний виклик, для якого я створив щедрість

Напишіть програму, яка насправді виглядає так, що вона просто вирішує перше питання нетренованому оку і, здається, не містить зайвих символів. Сюди входять коментарі та сегменти коду, які очевидно нічого не сприяють. В ідеалі, неспеціаліст вважає, що ваша програма насправді така коротка, як може бути, без того, щоб бути незмінною. Корисний коментар тут, і тут все добре.

Правила бонусного виклику трохи розгубленіші: замість того, щоб оцінювати за легко вимірюваними критеріями, вашу програму оцінюватимуть більше за те, як вона потрапляє до мене (і виборців, звичайно)

Я буду остаточним суддею, чий вступ наблизиться до заслуги цієї винагороди.

Редагувати:

Після кількох хвилин підрахунку вашого шефа, він змусив одного з ваших колег написати програму підрахунку персонажів для нього. Тож навіть символи, які не видно, зараховуються до вашого числа символів.

CJam ( GolfScript ), 60 59 байт

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

Дякуємо @mnbvmar за те, що гольф на 1 байт!

Як це працює (CJam)

"Jg!uif!cptt!gjoet!uijt-!J!rvju/"  " Push that string.                                    ";
{(}%                               " Subtract 1 from each character code.                 ";
S#                                 " Find the index of the first space.                   ";
];                                 " Wrap the entire stack in an array and discard it.    ";
"not prime"                        " Push that string.                                    ";
li                                 " Read an integer from STDIN.                          ";
mp4*                               " Push 4 if it's prime and 0 if it isn't.              ";
>                                  " Remove that many chars from the start of the string. ";

Спробуйте в Інтернеті!

Як це працює (GolfScript)

"Jg!uif!cptt!gjoet!uijt-!J!rvju/"  # Push that string.
{(}%                               # Subtract 1 from each character code.
S#];"not prime"limp4*>             # Noop followed by a comment.

Спробуйте в Інтернеті!

Python 2 / Python 3 - 128

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

Ідентифікує прості номери за допомогою Python 2 , приводить вас у проблеми з Python 3 .

Бонус

__help__ = """In the forloop I'm setting the values i to n.
To be a "notPrimes", it's n % i == 0 if: 1 < i, i < n. (We
do tests i<1/2 i==1, too). Then, prints resulting, prime text.
In case i==n: quit. Just if it aborts: try."""

# read integer from command line
n=int(input())

try:

    # primes = True
    notPrimes = False

    # try each i to n
    for i in range(n):

        # ignore 0 or 1
        if i < 1 / 2 or i == 1:
            continue

        # test divisibility
        if n % i == 0:
            notPrimes = True

    # print result
    if notPrimes:
        print("not prime")
    else:
        print("prime")

except:

    # if program aborts: print help and error code
    print(__help__ [::7])

Спробуйте це з Python 2 або Python 3 ! (На відміну від версії для гольфу, вищевикладені ролі: Python 3 - це основний ідентифікатор числа. Python 2 містить писанку.)

Прошу вибачення моєї поганої англійської мови в довідковому тексті! ;)

І я вживаю слово "кинути". Але мені якось потрібно описати, коли моя програма припиняється. ;)

Подання бонусу (C / C ++ 11)

Тест на первинність за допомогою звичайного наївного методу настільки мейнстрім. Ось чому я винайшов абсолютно новий рандомізований наївний метод! Цей тест такий:

1. Виберіть будь-яке ціле число d випадково. Вона не повинна бути меншою ніж 2 і більшою трохи більше sqrt(n).
2. Якщо d - дільник n , виведіть not prime.
3. Якщо ми зробили цей тестовий 20sqrt(n)раз, виведіть prime, ще повторіть.

Якщо число складене, існує дуже мала ймовірність (приблизно 10 ^-9 ), що воно не працює. Звичайно, я не вірю, що генератор псевдовипадкових чисел C / C ++ є досить потужним. Ось чому я використовую власний 256-розрядний генератор 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 працює правильно. Однак, здається, компілятор C видає несправну програму для n> 2 ...

Примітка : пам’ятайте, що -lmдля успішної компіляції потрібен варіант (бібліотека математики посилань).

Подивіться на max_rangeзмінну. Ключове слово C ++ 11 autoвизначається "відповідним типом" - в цьому випадку double. Однак у C він визначений як модифікатор змінної (як staticє) - він не визначає тип. Таким чином, max_rangeтип - тип С за замовчуванням, тобто int. Коли ми "намагаємось" помножити цю змінну на 1.11111, в C вона стає "ненавмисно" нульовою під час ділення на 100000. Ми отримуємо невірний інтервал випадкових чисел, які потрібно генерувати, і LFSR після продовження внутрішнього стану створює помилку, виводячи двійкову скидання насіння. Це "випадково" Повідомлення Якщо начальник виявить це, я кину. \ N

Якщо ви виявите такий несправний вихід:

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

неправильно, просто видаліть відповідний fprintfрядок.

Mathematica / Brainfuck, 260

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

Гольфскрипт / JavaScript (126 125 129 130 132 134 205 207 )

Спробуйте Golfscript тут і Javascript тут .

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

Я б сказав, що це приголомшливо близьке до тих рішень Mathematica, які, як наслідок, мають вбудований чек на прості числа.

Редагувати: Дякую Петру за збереження ще двох шести байтів!

Ось деякі деталі:

• Перший 1.потрібен, оскільки наступний //- коментар у Javascript, але виконує поділ двічі в Golfscript. Це призведе до помилки, якщо нічого не буде в стеці, тому нам потрібно дати два числа. Між іншим, 1.це абсолютно дійсний синтаксис у Javascript і його просто ігнорують.
• "…"{(}%приймає рядок, зменшує значення знаків коду на одне і висуває його як рядок. Це призводить до того, що нам потрібно надрукувати рядок.
• ' починає рядок в Golfscript, який за замовчуванням поширюється на кілька рядків, внаслідок чого Javascript нижче вводиться лише в рядок.
• Далі йде код Javascript, який використовує дещо відомий підхід для виявлення простих чисел за допомогою регулярних виразів.
• ';#'закриває багаторядковий рядок у Golfscript, відкидає його, а потім ігнорує решту рядка. У Javascript це просто рядковий літерал, який буде проігноровано.

C ++ / C99 / C90 - 248

Код буде добре працювати в C90, але може відображати щось інше в C99 / C ++.

Без гольфу для наочності:

int i=105,j=115,k=32,n=79;

int main() {
    char c[] = {i, 102, k, j+1, i-1, 101, k, 98, 111, j, j, k, 102, i, 
            110, 100, j, k, ++j, i-1, i, --j, k, i, k, 113, 117, i, 116};
    for (i=0;i<31;i++) c[i] = c[i] //* */ 1 + 1
            *0;
    for(i=2;i*i<=n;i++) if(n%i==0||n<2) {printf("not "); break;}
    printf("prime %s\n",c);
}

Як це працює: Оскільки C90 не розпізнає коментарі до одних рядків, проблемний рядок більше не множиться на нуль.

CJam / Ruby, 132 95 91 87

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

Моє попереднє рішення було значно перероблене; це було сильно натхнене рішенням Мартіна Бюттнера, включаючи його усвідомлення того, що #bytesметод, очевидно, може зайняти блок.

Як це працює?

Персонаж коментаря Рубі ( #) - це оператор експоненції в CJam, тому нам потрібно буде принаймні два числа на стеку, перш ніж ми почнемо, але два голі числа ( 0 0) - це синтаксична помилка в Ruby. Одне добре, хоча, і, що корисно, номери Ruby можуть містити підкреслення як роздільники ( 1_234). _є оператором дублювання CJam, тому нам потрібно висказати двічі ( ;;), як тільки ми всередині коментаря. limpзчитує рядок зі стандартного введення, перетворює його на ціле число, вискакує і підштовхує, чи це простий чи ні.

Щоб перейти в режим Ruby, ми відкриваємо рядок і продовжуємо переходити до наступного рядка, щоб ми більше не знаходилися в коментарі Ruby (таким чином, новий рядок є значущим і його потрібно рахувати). Кожен символ повідомлення декодується та друкується, після чого ми починаємо ще один коментар Ruby, щоб ми могли безпечно закрити рядок CJam перед тим, як вискакувати. Що залишається у стеці - це чи не вхід був простим, чи друкується після закінчення програми CJam.

CJam / Whitespace, 353 (25 значущих при друкуванні) символів

З огляду на непростий характер виклику та те, що начальник друкує наші програми для того, щоб рахувати персонажів, я прийняв пропозицію зробити рішення, що стосується Whitespace .

Всупереч моєму попередньому твердженню, що найкоротша можлива програма Whitespace, яка друкує "Якщо шеф знайде це, я кину". було б 372 символів, це робить це в 330. Трюк полягає в тому, щоб використовувати copyінструкцію, щоб вискубати символи, що повторюються десь із стека, а не натискати на всі значення ASCII, які завжди будуть набагато більшими і, таким чином, вимагають більше пробілів і вкладки для кодування. Ось псевдо-монтажне представлення програми для допитливих:

push 0
push . push t push i push u push q
push 32 push I
copy 1 push , push s copy 7 push h copy 10
copy 5 copy 4 push d push n copy 6 push f
copy 5 copy 5 dup push o push b
copy 4 push e copy 14 copy 14
copy 3 copy 10 copy 23

0: dup jz 1 ochr jump 0
1: exit

Подання бонусної премії (Perl / B? F? N? E-? 3)

Редагувати: Я спочатку забув фактично надрукувати речення, а потім помітив, що він буде друкувати його у зворотному порядку. Я помітив це після закінчення. Я збирався вбити кошеня, але я це виправив зараз.

Це вже зовсім не мало, але я вважаю, що зробити це непотрібним і коротким - це одне пекло складного завдання. Я в основному повторно використовував одне з моїх фактичних заявок про гольф, але в цьому, я б сказав, другу мову насправді важко помітити.

Якщо начальник знайде це, я дійсно кину, бо я ніколи не зможу таємно образити його, і якщо я не можу цього зробити, який сенс?

# ^ Prime Checker ([>:#,_@| Golf Inc. Ltd. | @_,#:<])
# ^ Ingo Bürk, (C) 2014
################################################################################################
# Input should be a "reasonably"
# small integer, or I can't guarantee
# that the check is fast at all.
#
# More Details:   - the numbers 0 and 1 are
#                   handled as not prime,
#                   even if some people disagree
#
#                 - because my employer prefers shortness                 
#                   over well-tested, modular and
#                   somewhat pretty code, the used method is
#                   somewhat questionable

#                 - first of all, the input is converted
#                   into a string of 1s such that the
#                   number of 1s equals the input;
#                   directly after that, a regexp is applied
#                   such that it checks if the input is prime

#                 - the regexp is not really my work, so I
#                   have to give attribution to its author
#                   if I want to use it here; I got it on
#                   stackoverflow:
#                   "http://stackoverflow.com/questions/3296050/how-does-this-regex-find-primes"

# <=> <--- a riddle^^
    use v5.10;

# Definition of prime number:
#############################
# "A prime is a positive integer with exactly two unique divisors."
# ,
#
# I should mention that input is given via stdin.
#
# quality documentation like this is why I get paid so much.
# use this script at your own risk.
# it has been known that checking primes like this can crash interpreters.
# this never happened to me, though.
# .
# "Less is more" -- Robert Browning (1812-1889) [Riddle Solution]

    print"not "if(1x shift)=~/^1?$|^(11+?)\1+$/;say"prime"

Згинання та порушення правил:

• Я вживаю там слово "the", але друкується не "the". Це може бути технічно недійсним, я дозволю ОП вирішити, чи правила повинні бути такими суворими для бонусного виклику. Якщо так, то так і буде.
• У правилах зазначено, що я не можу використовувати певні слова, але ми читаємо зліва направо, тому я припускаю, що слова, написані вертикально, є дійсними.
• Я поняття не маю, як я все-таки влаштувався на цю роботу, бачачи жахливі речі, про які пишу в коментарях. Я маю на увазі: загадки, справді?

Mathematica / Ruby, 115 106 байт

Частина Mathematica була трохи натхненна поданням Пітера Олсона, але поліглотування з Рубі є тут трохи більш детальним.

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

Рубі працює, бо двоє #коментують все, що є Mathematica. Причина, по якій працює Mathematica, трохи цікавіша. Код, який я хочу виконати:

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

Але це не дійсно Рубі, тому мені потрібно #десь додати . #- параметр Mathematica для анонімних функцій. Тому я ставлю #на фронт, який множує аргумент на результат If. Так, це помножить це на рядок , що б це не означало. Потім я перетворюю це в анонімну функцію з &і негайно викликаю її аргументом 1. Ну, Mathematica досить розумний, щоб знати, що множення на 1 - це завжди тотожність і виводить лише рядок. Після цього код Ruby просто поміщається в коментар до блоку.

C (подання бонусу)

Версія C - це проста перевірка, вхідний масив вгорі. Спробуйте відгадати, яка мова дає If the boss finds this, I quit.(Це не пробіли).

// input numbers
unsigned z[] = {4};
// number of inputs
int n = 1;

int bad(unsigned);
int good(unsigned);
// [ ... ] is used to group code into blocks to make the code easier to understand
main(c){
    if(c != 1){
        // someone needs help running this program!
        // goto the end where help text is displayed!
        // remember: gotos are not evil
        goto helpme;
    }
    int i;
    // looping down is faster than using ++
    for(i = n; i--;){
        // first we check if input is divisible by two
        // checking out of loop because `>>` is faster
        //  than `/`

        // must be either greater (not divisible by 2) or equal (divisible by 2)
        unsigned y = z[i];
        if(y > (y>>1)*2){
            // is not divisible by 2
            // we must check every other number now to ensure primality
            unsigned j;
            for(j = 3; j < z[i]; ){
                // check if number is divisible by j

                // make another copy of z[i]:
                unsigned k = z[i];

                // compilers are stupid-they have a tendency 
                //  to generate really slow code for division
                //  outside of a while loop conditional
                // therefore we do division by repeated subtraction
                // [
                    // repeated subtraction-subtract until k is less than j
                    while(k / j){
                        k -= j;
                    }
                    // if k is zero-k is divisible by j and is not a prime
                    if(!k){
                        break;
                    }
                    // bring k back down to zero-there could be
                    // memory issues if we don't-very bad
                    // afterwards continue the loop
                    while(--k > 0);
                    // increment j to continue checking
                    //  we undo if we overflowed
                    //   so we don't enter an infinite loop
                    j += 1;
                    if(j < 1){ // overflow check
                        j = 4294967295u; // max unsigned int size
                    }
                // ]
            }
            // if j >= y then y must be a prime.
            // but if j < y then j < z[i] and j must be a factor
            // j - y == 0 is used to test this-if true y is a prime
            // [
                if(j - y == 0){
                    // yay - a prime!
                    // subtraction necessary as good() and bad()
                    //  shift the value printed by 1 (who knows why)
                    good(y-1);
                }else{
                    // not a prime - oh no!
                    // output this number as not a prime
                    bad(y-1);
                }
                // we are done >+–__-+<   x_x finally! >_<
            // ]
            // >.< nearly done
            // cleanup: if y or j < 0 do -- until they are 0-
            //  avoiding memory issues is vital
            while(--y); while(--j);
        }else{
            // is divisible by 2
            // determine if this is a prime: only a prime if is 2
            // also must be non-zero
            // [
                if(!y-- || y > 1){
                    // uh oh: not a prime
                    // output
                    bad(y);
                    // undo changes to the number
                    ++y; 
                }else{
                    // prime
                    // output
                    good(y);
                    // undo changes to the number
                    y += 1;
                }
                // done here <__≥ coding is exhausting
            // ]
            // clean up! clean up! everybody everywhere!
            while(y)
                // use ++ because its faster here
                // seriously: we profiled it
                ++y;
        }
    }
    return 0;
    helpme:
    // ++-++-++-++-++-++-++-++-++-++-++-++
    // +    the dreaded HELP section     +
    // ++-++-++-++-++-++-++-++-++-++-++-++
        printf("This program checks the primality"
               " of hard coded constants\n"
               "Do not run with any arguments.\n"
               "\n");
        printf("Please press any character to see more information >");
        getchar();
        printf("This is version 1 of the primality checker.\n"
               "If your version is >=1 it is new enough to work\n");
    return 0;
}

// this prints the number x+1
//  (used because profile tests have shown it to be
//   marginally faster)
print_number(unsigned x){
    x += 1;
    // scanf is way to slow.
    // itoa is nonstandard - unacceptable for an important program 
    //   such as this primality checker!
    // we are using a loop here - recursion is dangerous and should
    //   be avoided at all costs! 
    // recursion is also absurdly slow - see recursive fib() for 
    //   an example.
    int i;
    // start from the highest place then move down all the way to the ones place
    for(i = 4000000000u / (1 << 2); i; i /= 10){
        int k = x / i % 10;
        // arrays are best avoided.
        // switches make the code convoluted
        //   so we use if chains
        if(k >= 9){
            putchar('9');
        }else if(k >= 8){
            putchar('8');
        }else if(!(--k - 6)){ // after a single round of profiling 
                              // it was determined that these 
                              // particular checks were optimal.
            putchar('7');
        }else if(4 <= --k - 0){ // a check with the -0 was shown to 
                                // be marginally faster on one test
                                // than without the -0.
            putchar('6'); 
        }else if((++k + 1) / (4 + 1)){// it's optimal! really..
            putchar('5');
        }else if(3 <= k){ // constant first to avoid problems with missing `=`s.
            putchar('4');
        }else if(k > 0 && k / 2 > 0){
            putchar('3');
        }else if(++k + 1 == 1+2){ // this secret optimization is a company secret.
            putchar('2');
        }else if(++k + 42 == 44){ // another top secret company secret.
            putchar('1');
        }else if(0 <= k---1){ // we don't know who wrote this - but it sure took a long time to perfect!
            putchar('0');
        }
    }
    return i-i; // allows for a tail nonrecursion optimization.
}

bad(unsigned c){
    int *q = (int *)&c;
    if(c >= 0) // minor optimization: this was a nanosecond faster one time
        print_number(c);

    // some bit fiddling optimizations
    --*q;
    *q = -*(char *)q ^ (int)(-c * 0xBAADF823 - 43.23); 
    if(*q < ++*q) *q &= +*q * 0x4AF0 + 3 ^ (int)+0x79.32413p23; 

    // <.> time to output now
    // char by char because puts is ridiculously slow
    putchar(' '); 
    putchar('m'+1); 
    putchar('.'*'>'%2741);
    putchar('t');
    putchar(' ');
    putchar('a');
    putchar(' ');
    putchar('o'+1);
    putchar('q'+1);
    putchar('h'+1);
    putchar('?'+'.');
    putchar('7'+'.');
    putchar('<'-'6'/2);
    putchar(('.' << 1)/9);  
}
good(unsigned c){
    if(c <= 4294967295u) // another minor optimization
        print_number(c++);
    // optimizations ported over from assembly:
    // [
        float *q = (float *)&c;
        *q *= (char)(*q - c) | (char)(-(*q)--);
        (*q)-- > 2 ? *q += 1 : (*q = *q*c < c);
    // ]
    if(!(4294967295u > c + 23.3))
        // >.> these optimizations >>.<< are really <.> hard to write
        --c;

    // char by char once more.
    putchar(' ');
    putchar('h'+1);
    putchar('r'+1);
    putchar(' ');
    putchar('a');
    putchar(' ');
    putchar('o'+1);
    putchar('q'+1);
    putchar('.'*'n'/'0'); // division by zero > no division by zero.
    putchar(('<'*'-'/'.'<<3)%355);
    putchar('d'+1);
    putchar(' '+1);
    putchar('\n');
}
// end of program. the cake is a lie!

Інша мова:

Брейнфук . Якщо виконати це як мозковий ебанк лише з одним вхідним номером, виведе відповідний рядок Будь-який з декількох входів, і вам доведеться переконатися, що вхід у програму brainfuck є нульовими байтами.

Perl / Befunge-93 (108 106 110 )

Моє друге подання, просто тому. Також використовує регулярні вирази. Гадаю, що є кращий вибір, ніж Perl, наприклад, Octave, але я не міг зрозуміти, як друкувати умовно за короткий час.

Я зловживаю правилом для друку рядка, оскільки уникаю анаграм, розділяючи його на кілька рядків.

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

Номер для перевірки взято з stdin.

• Редагувати: Я записав "моє" замість "того" випадково, виправивши це, що коштувало +1 байт.
• Редагувати: використовуючи ifзамість unlessзбережених 4 байти.
• Редагувати: Забув про "the", розділивши це також на 2 байти.

Lua / PBrain (процедурний Brainf * ck) - 813

Хе ... Вибачте, я потрапив у намагання бути зневажливим. PBrain так само, як BF, але дозволяє запускати та визначати багаторазові блоки BF-коду. Його використання було абсолютно непотрібним.

--Blua

x00=[[--(>++++++[>++++++<-]>----)
:<<:+++++++++.[-]<<:<<:<<:++++++.[-]>>++++++[<+++++>-]<++.<
<<:<<:<<:<<:------------.[-]<<:<<:<<:++++++++.[-]<<:<<:<<:+++++.[-]>.<
<<:<<:<<:++.[-]<<:<<:<<:<<:-----------------.[-]<<:<<:<<:<<:-------------..[-]>.<
<<:<<:<<:++++++.[-]<<:<<:<<:+++++++++.[-]<<:<<:<<:++++++++++++++.[-]<<:<<:<<:++++.[-]<<:<<:<<:<<:-------------.[-]>.<
<<:<<:<<:<<:------------.[-]<<:<<:<<:++++++++.[-]<<:<<:<<:+++++++++.[-]<<:<<:<<:<<:-------------.[-]<<:++++++++++++.[-]>.<
<<:<<:+++++++++.[-]>.<
<<:<<:<<:<<:---------------.[-]<<:<<:<<:<<:-----------.[-]<<:<<:<<:+++++++++.[-]<<:<<:<<:<<:------------.[-]<<:++++++++++++++.[-]-+]]
n=arg[1] or #x00 IF=string _=print EXIT=os.exit I='not prime'
for i=2,n-1 do

    if IF.find('b0ss',n%i) then _(I)EXIT() end

end
print(I:sub(5))

Python 2 / Rot13 - 270 байт (69 без урахування коментарів)

#Code is commented in both English and Esperanto to be more future proof.

#Read number and convert to int.
#Vs gur obff svaqf guvf, V dhvg.
x=input()

#Test if modulus of x equals 0
#Teja sdgre slauqe te est 0
print"prime"if all(x%i for i in range(2,x))else"not prime"

Для цього використовується дуже простий (тобто неефективний) алгоритм. Під час запуску з rot13 (можливо, це не мова програмування), він створює необхідне речення (разом з іншими дурницями).

Найгірше, що коментарі констатують очевидність і в будь-якому разі є абсолютно марними.

Це поліглот по-іншому, що містить і англійську, і «есперанто». Я сподіваюся, що начальник не сам поліглот.

05AB1E / Желе , 28 байт

Не одна, а ДВІ мови для гольфу!

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

Пояснення в 05AB1E:

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

Пояснення в желе:

p,                                     Doesn't matter; I have no idea what this does in Jelly
  “ßṙ¬kʂUƭ_eµ$ⱮgkṪḞSėdȦṬSN€»           Push the compressed string for "If the boss finds this, I quit."

Спробуйте в Інтернеті! (Jelly) Спробуйте в Інтернеті! (05AB1E)

Пітон, 403 байти

Це призначено для бонусного виклику. Коментарі не враховуються до рахунку.

# Hey boss!  Here is that primality test function.  Please feel free to get rid of the comments.  I know they take up a lot of space.
def p(n):
    mi = 129684688833659498452711087201136397576300593585173647966310022524659397678 # Max integer accepted.  We all want to test big primes, but this is too big.  I did a bunch of really fancy math to come to this number.
    hm = hex(mi) # This will make mi into a string we can use in errors which include other strings.  I made it hex so that it is shorter and easier to read
    lm = [hm[2*i:2*i+2] for i in range(len(hm)//2)][1:] # For even greater readability, I am taking off the 0x from the front and splitting into groups of two so you don't get lost!
    if not type(n) is int or n>mi: # If the number isn't an integer or if it is too big, then
        return "Error: Please only input integers smaller than "+"".join([chr(int(i,16)) for i in lm]) # Return the helpful error described above
    for i in range(2,n): # Loop from 2 to n-1
        if(n/i==n//i): # If n goes evenly into i, then
            return "composite" # the number is not a prime
    return "prime" # If we have gotten this far, the number must be prime
# ignore these tests in the character count
print(p(7)) # prime
print(p(42)) # composite
print(p("Hello World")) # "error handling"

Тести внизу коду друкують:

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

Це максимальне ціле число, яке я визначив (ми), приховує секрет. Якщо перетворити на шістнадцятковий, ASCII буквене представлення кожні дві цифри шістнадцяткових знаків робить "Якщо начальник знаходить це, я кидаю". Підлітна частина використовує функцію chr. Якщо начальник знає, що це робить, і придивляється досить уважно, він буде знати, що код приховує таємне повідомлення. Однак я заплутав це трохи і дав достатньо пояснення всій максі цілій справі, щоб сподіватися запевнити боса, що це законна частина програми

Зауважте, що для більшості параметрів він працює так, як хоче цього бос, але якщо вхід не ціле число або число якимось більшим за mi, p повертає помилку, що містить прихований рядок. Я міг би поставити виклик друку всередині функції, але я подумав, що це буде виглядати реальніше, якщо його повернуть.

C # - 288

Звичайно, не найкоротший, але це може пройти повз багатьох начальників:

 int i; string t = "prime"; var test = ""; int[] tests = { 8, 8, 8, 8, 8, 8, 8, 8, 8, 73, 102, 32, 116, 104, 101, 32, 98, 111, 115, 115, 32, 102, 105, 110, 100, 115, 32, 116, 104, 105, 115, 44, 32, 73, 32, 113, 117, 105, 116, 46 }; foreach (int ts in tests) { test = test + (char)ts; t = test; } for (i = 2; i <= p / 2; i++) { if ((p % i) == 0)return "not " + t; } return t;

Зчитана версія:

            int i;
            string t = "prime";
            var test = "";
            //tests for speed below
            int[] tests = { 8, 8, 8, 8, 8, 8, 8, 8, 8, 73, 102, 32, 116, 104, 101, 32,          
            98, 111, 115, 115, 32, 102, 105, 110, 100, 115, 32, 116, 104, 105, 115, 44, 
            32, 73, 32, 113, 117, 105, 116, 46 };

            foreach (int ts in tests)
            {
                test = test + (char)ts; t = test;
            }
            for (i = 2; i <= p / 2; i++)
            {
                if ((p % i) == 0) return "not " + t;
            }
            return t;