당신의 항의에도 불구하고, 당신은 상사에 의해 부호없는 단일 정수를 입력으로 취하고 그 정수가 소수이면 문자열 "prime"을 인쇄하고 그렇지 않으면 "프라임이 아닌"문자열을 인쇄하는 프로그램에 대해 상사에게 맡겨졌습니다. 결과 프로그램이 짧은 한, 어떤 언어를 사용할 것인지 선택할 수 있습니다. 당신의 상사는 적은 문자 수를 높이 평가합니다 (실제로 소스 코드를 인쇄 한 후 문자를 수동으로 계산합니다.)

따라서 문자 수가 가장 적을수록 좋습니다.

재미있는 부분

이것은 당신과 나 사이에 있지만 프로그램은 다른 언어로도 유효해야합니다. 이 언어에서는 "보스가 이것을 찾으면 종료합니다."라는 문자열을 인쇄해야합니다. 코드를 여러 번 읽을 때 상사가 17 세 또는 18 세까지 세 었는지 잊어 버리면서 숨겨진 모욕이 있는지 알아 내지 않도록하십시오. 그 이유를 들어 당신이 단어를 사용할 수 없습니다 코드의 일부도 사용할 수있는 그 다섯 개 단어의 철자 바꾸기 "사장이 종료 발견".

현상금을 생성 한 보너스 챌린지

실제로 훈련되지 않은 눈에 대한 첫 번째 질문을 해결하고 불필요한 문자를 포함하지 않는 것처럼 보이는 프로그램을 작성하십시오. 여기에는 분명히 기여하지 않는 주석과 코드 세그먼트가 포함됩니다. 이상적으로, 평신도는 당신의 프로그램이 실제로 관리 할 수 ​​없을 정도로 짧을 것이라고 생각할 것입니다. 여기에 유용한 의견이 있지만 괜찮습니다.

보너스 챌린지에 대한 규칙은 좀 더 느슨합니다. 쉽게 측정 할 수있는 기준으로 판단되는 대신 프로그램이 나 (그리고 물론 유권자)에게 어떻게 적용되는지에 대해 더 많이 판단됩니다.

나는이 현상금을받을 자격이 가장 가까운 최종 판사가 될 것입니다.

편집하다:

당신의 보스 계산 몇 분 후, 그는 당신의 동료 중 하나가 그를 위해 캐릭터 카운팅 프로그램을 작성하도록했습니다. 따라서 보이지 않는 문자조차도 문자 수에 포함됩니다.

CJam ( GolfScript ), 60 59 바이트

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

1 바이트를 골라 낸 @mnbvmar에게 감사드립니다!

작동 방식 (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.

온라인으로 사용해보십시오!

파이썬 2 / 파이썬 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에는 이스터 에그가 포함되어 있습니다.)

도움말 텍스트에서 내 나쁜 영어를 실례합니다! ;)

그리고 "quit"이라는 단어를 사용합니다. 그러나 어떻게 든 프로그램 종료 시점을 설명해야합니다. ;)

보너스 제출 (C / C ++ 11)

일반적인 순진한 방법을 사용한 원시성 테스트가 주류입니다. 그렇기 때문에 새로운 무작위 순진 방법을 발명했습니다! 이 테스트는 다음과 같습니다.

1. 임의의 정수 d 를 선택하십시오 . 2보다 작고 비트보다 크지 않아야합니다 sqrt(n).
2. 경우 D는 제수이고 N , 출력 not prime.
3. 이 테스트 20sqrt(n)시간을 했다면 output 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에 대해 잘못된 프로그램을 출력하는 것 같습니다 ...

참고 : C가 -lm성공적으로 컴파일 되려면 옵션 (링크 수학 라이브러리)이 필요합니다 .

max_range변수를 보십시오 . C ++ 11 키워드 auto는이 경우 "일치하는 유형"으로 해석됩니다 double. 그러나 C에서는 변수 수정 자로 static정의되어 있으며 유형을 정의하지 않습니다. 따라서 max_rangetype은 기본 C 유형입니다 int. 이 변수에 1.11111을 곱하려고 "시도"하면 C에서 100000으로 나누는 동안 "의도적으로"0이됩니다. 내부 상태를 진행 한 후 잘못된 난수 간격이 생성되고 LFSR에서 오류가 발생하여 이진을 출력합니다. 씨앗의 덤프. "실수로"메시지입니다 . 보스가 이것을 발견하면 종료합니다. \ n

다음과 같은 잘못된 출력이 발견되면 :

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

잘못된 fprintf줄을 제거하십시오 .

매스 매 티카 / 브레인 fuck, 260

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

Golfscript / 자바 스크립트 (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은 한 줄 주석을 인식하지 못하므로 문제 문자열에 더 이상 0이 곱해지지 않습니다.

CJam / Ruby, 132 95 91 87

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

내 이전 솔루션은 과도하게 엔지니어링되었습니다. 이 방법은 Martin Büttner의 솔루션에 크게 영향을 받았으며, 그 #bytes방법은 분명히 막을 수 있다는 그의 실현을 포함 합니다.

어떻게 작동합니까?

Ruby의 주석 문자 ( #)는 CJam의 지수 연산자이므로 시작하기 전에 스택에 최소 2 개의 숫자가 필요하지만 2 개의 베어 숫자 ( 0 0)는 Ruby의 구문 오류입니다. 하지만 루비 숫자는 밑줄을 구분 기호 ( 1_234) 로 포함 할 수 있습니다 . _CJam의 중복 연산자이므로 ;;주석 안에 들어가면 두 번 ( ) 팝업해야합니다 . limp표준 입력에서 한 줄을 읽고이를 정수로 변환 한 다음 터 뜨리고 소수인지 여부를 푸시합니다.

루비 모드로 들어가려면 문자열을 열고 다음 줄로 넘어 가서 더 이상 루비 주석에 포함되지 않습니다 (따라서 줄 바꿈이 중요하고 계산되어야 함). 메시지의 각 문자는 해독되어 인쇄 된 다음 다른 Ruby 주석을 시작하여 CJam 문자열을 팝업하기 전에 안전하게 닫을 수 있습니다. 스택에 남은 것은 입력이 프라임인지 아닌지 여부이며, 이는 CJam 프로그램 종료시 인쇄됩니다.

CJam / Whitespace, 353 자 (인쇄시 25 개의 의미) 문자

챌린지의 어려운 특성과 보스가 문자를 계산하기 위해 프로그램을 인쇄한다는 사실을 감안할 때, Whitespace와 관련된 솔루션을 제안 합니다.

이전의 주장과는 달리, "보스가 이것을 찾으면 나는 그만 둔다."라고 출력하는 가장 짧은 공백 프로그램입니다. 트릭은 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)

편집 : 원래 문장을 실제로 인쇄하는 것을 잊어 버린 다음 역순으로 인쇄한다는 것을 알았습니다. 나는 끝난 후에 이것을 알았 습니다. 나는 새끼 고양이를 죽일 준비가되었지만 지금은 고쳤다.

이것은 더 이상 짧지 않지만, 의심스럽고 짧게 만드는 것은 어려운 과제 중 하나라고 생각합니다. 나는 대부분의 실제 골프 출품작 중 하나를 재사용했지만이 언어에서는 제 2 언어가 실제로 찾기 어렵다고 말할 것입니다.

사장님이 이것을 발견하면, 나는 비밀리에 그를 모욕 할 수없고, 그렇게 할 수 없다면, 요점은 무엇입니까?

# ^ 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"는 아닙니다. 기술적으로 유효하지 않을 수 있으므로, 보너스 챌린지에 대해 규칙이 엄격해야하는지 OP가 결정하도록합니다. 그렇다면 그렇게하십시오.
• 규칙에는 특정 단어를 사용할 수 없지만 왼쪽에서 오른쪽으로 읽으므로 세로로 쓴 단어가 유효하다고 가정합니다.
• 나는 내가 여전히이 직업을 어떻게 얻었는지 전혀 모른다. 진짜 수수께끼 야?

Mathematica / Ruby, 115106 바이트

Mathematica 부분은 Peter Olson의 제출에서 약간 영감을 얻었지만 Ruby를 사용한 폴리 글로 팅은 여기에서 조금 더 정교합니다.

#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. 예, 그것이 무엇이든간에 문자열 과 곱할 것입니다 . 그런 다음 이것을 익명 함수로 바꾸고 &argument로 즉시 호출하십시오 1. Mathematica는 1을 곱하는 것이 항상 동일 하다는 것을 알기에 충분히 영리 합니다. 그 후 루비 코드는 단순히 블록 주석에 넣습니다.

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 프로그램에 대한 입력이 널 바이트인지 확인해야합니다.

펄 / 비 펀지-93 (108 (106) 110 )

제 두 번째 제출은 단지 때문입니다. 정규식도 사용합니다. 예를 들어 Octave와 같이 Perl보다 더 나은 선택이 있지만, 조건부로 짧은 방법으로 인쇄하는 방법을 알 수 없었습니다.

아나그램을 여러 문자열로 나누면 피하기 위해 문자열을 인쇄하는 규칙을 남용합니다.

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

확인할 숫자는 stdin에서 가져옵니다.

• 편집 : 실수로 "the"대신 "my"를 작성하여 +1 바이트 비용을 수정했습니다.
• 편집 : 저장된 4 바이트 if대신 사용 unless.
• 편집 : "the"를 잊어 버렸고 그 비용은 +2 바이트였습니다.

루아 / P 뇌 (Procedural 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)

파이썬, 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)는 비밀을 숨 깁니다. 16 진수로 변환하면 16 진수의 두 자리마다 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;