Несмотря на ваш протест, ваш начальник заставил вас работать над программой, которая принимает в качестве входных данных одно целое число без знака и печатает строку «простое число», если это целое число простое, и «не простое», если это не так. Вы можете выбрать, на каком языке вы это делаете, если полученная программа короткая; Ваш босс очень ценит низкое количество персонажей. (На самом деле он будет подсчитывать символы вручную после распечатки исходного кода.)

Так что вам лучше добраться до этого, победит наименьшее количество персонажей.

Забавная часть

Это только между вами и мной, но ваша программа должна быть действительной на другом языке. На этом языке, однако, он должен напечатать строку «Если босс найдет это, я уйду». Убедитесь, что ваш начальник не обнаруживает скрытого оскорбления при чтении кода снова и снова, так как он постоянно забывает, считал ли он до 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для успешной компиляции C нужна опция (link math library).

Посмотри на max_rangeпеременную. Ключевое слово C ++ 11 autoпреобразуется в «соответствующий тип» - в данном случае double. Однако в Си это определяется как модификатор переменной (как staticесть) - он не определяет тип. Таким образом, max_rangeтип является типом C по умолчанию, то есть 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"](*++++++++++[>+++>++++>+++++++>++++++++++>+++++++++++<<<<<-]>>>+++.>++.<<<++.>>>>++++++.<++.---.<<<.>>>---.>-----.++++..<<<<.>>>++++.+++.>-----.<-----.>+++++.<<<<.>>>>+.<++++.+.>-.<<<++++.<.>>.<<.>>>>--.++++.<.>-.<<<++.*)

Golfscript / Javascript (126 125 129 130 132 134 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метод, очевидно, может занять блок.

Как это работает?

#Символ комментария в Ruby ( ) является оператором возведения в степень в CJam, поэтому нам потребуется по крайней мере два числа в стеке, прежде чем мы начнем, но два пустых числа ( 0 0) - это синтаксическая ошибка в Ruby. Впрочем, все хорошо, и, что полезно, числа Ruby могут содержать подчеркивания в качестве разделителей ( 1_234). _является оператором дублирования CJam, поэтому нам нужно дважды щелкнуть ( ;;), как только мы окажемся внутри комментария. limpчитает строку из стандартного ввода, преобразует ее в целое число, выдает ее и показывает, является ли она простой.

Чтобы перейти в режим Ruby, мы открываем строку и переходим к следующей строке, чтобы мы больше не были в комментарии Ruby (таким образом, символ новой строки является значимым и должен учитываться). Каждый символ сообщения декодируется и печатается, а затем мы запускаем еще один комментарий Ruby, чтобы можно было безопасно закрыть строку CJam перед ее извлечением. То, что осталось в стеке, это то, был ли ввод простым, что печатается после завершения программы CJam.

CJam / Пробелы, 353 (25 значащих при печати) символов

Учитывая закулисный характер задачи и тот факт, что начальник будет печатать наши программы, чтобы подсчитать количество символов, я решил предложить решение с использованием пробелов .

Вопреки моему предыдущему утверждению, что самая короткая из возможных программ Whitespace выводит: «Если босс обнаружит это, я ухожу». было бы 372 символа, этот делает это в 330. Хитрость заключается в том, чтобы использовать copyинструкцию для извлечения повторяющихся символов где-то в стеке, а не выдвигать все значения ASCII, которые всегда будут намного больше и, следовательно, требуют больше пробелов и вкладки для кодирования. Вот псевдо-ассемблерное представление программы для любопытных:

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

0: dup jz 1 ochr jump 0
1: exit

Предоставление бонусного приза (Perl / B? F? N? E-? 3)

Редактировать: я изначально забыл распечатать предложение, а затем заметил, что оно будет напечатано в обратном порядке. Я заметил это после того, как сделано. Я был готов убить котенка, но я исправил это сейчас.

Это уже ни в коем случае не коротко, но я считаю, что сделать его незаметным и коротким - это чертовски трудная задача. Я в основном повторно использовал одно из моих настоящих представлений о гольфе, но в этом я бы сказал, что второй язык действительно трудно определить.

Если босс обнаружит это, я действительно уйду, потому что я никогда не смогу тайно оскорбить его, и если я не могу этого сделать, какой смысл?

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

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

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

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

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

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

Изгиб и нарушение правил:

• Я использую там слово «the», но это не «the», которое печатается. Это может быть технически недействительным, я позволю ОП решить, должны ли правила быть такими строгими для бонуса. Если так, то пусть будет так.
• Правила гласят, что я не могу использовать определенные слова, но мы читаем слева направо, поэтому я предполагаю, что слова, написанные вертикально, действительны.
• Я понятия не имею, как я все еще получил эту работу, видя ужасные вещи, которые я пишу в комментариях. Я имею в виду: загадки, правда?

Mathematica / Ruby, 115 106 байт

Часть Mathematica была слегка вдохновлена ​​представлением Питера Олсона, но полиглотинг с Руби здесь немного более сложен.

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

Ruby работает, потому что они #комментируют все, что есть Mathematica. Причина, по которой Mathematica работает, немного интереснее. Код, который я хочу выполнить:

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

Но это не валидный Ruby, поэтому мне нужно добавить #куда-нибудь. #является параметром 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 . Выполнение этого как brainfuck только с одним входным номером выведет соответствующую строку. Любое более одного ввода, и вы должны убедиться, что входные данные для программы 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"

Номер для проверки берется из стандартного ввода.

• Редактировать: я написал «мой» вместо «случайно», исправляя это стоило +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."

Попробуйте онлайн! (Желе) Попробуйте онлайн! (05AB1E)

Python, 403 байта

Это предназначено для бонусного вызова. Комментарии не учитываются.

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

Тесты внизу кода печатают:

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

Это максимальное целое число, которое я определил (mi), скрывает секрет. При преобразовании в шестнадцатеричное представление буквы ASCII каждых двух цифр шестнадцатеричного слова дает «Если босс обнаружит это, я ухожу». Подлая часть использует функцию chr. Если босс знает, что он делает, и смотрит достаточно внимательно, он будет знать, что код скрывает секретное сообщение. Тем не менее, я немного запутал это и дал достаточно объяснения всему макс целочисленному, чтобы, надеюсь, заверить босса, что это законная часть программы.

Обратите внимание, что для большинства параметров это работает так, как хочет босс, но если ввод не является целым числом или число каким-то образом больше, чем mi, p возвращает ошибку, содержащую скрытую строку. Я мог бы сделать вызов функции печати внутри функции, но я думал, что это будет выглядеть более реальным, если он будет возвращен.

C # - 288

Конечно, не самый короткий, но он может пройти мимо многих боссов:

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

Читаемая версия:

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

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