आपके विरोध के बावजूद, आपको अपने बॉस द्वारा एक ऐसे प्रोग्राम पर काम करने के लिए रखा गया है, जो एक भी अहस्ताक्षरित पूर्णांक को इनपुट के रूप में लेता है और स्ट्रिंग "प्राइम" को प्रिंट करता है यदि यह पूर्णांक प्राइम है और यदि नहीं है तो "प्राइम" है। आप चुन सकते हैं कि आप किस भाषा में ऐसा करते हैं, जब तक कि परिणामी कार्यक्रम छोटा न हो; आपका बॉस बहुत कम चरित्र गणना की सराहना करता है। ( स्रोत कोड को प्रिंट करने के बाद वह वास्तव में मैन्युअल रूप से वर्णों की गणना करेगा ।)

तो आप इसे बेहतर तरीके से प्राप्त करते हैं, सबसे कम वर्ण गणना जीत जाती है।

मज़ेदार हिस्सा

यह सिर्फ आपके और मेरे बीच का है, लेकिन आपका प्रोग्राम किसी अन्य भाषा में भी मान्य होना चाहिए। इस भाषा में हालांकि, इसे स्ट्रिंग प्रिंट करना चाहिए "यदि बॉस को यह पता चलता है, तो मैंने छोड़ दिया।" सुनिश्चित करें कि आपके बॉस को यह पता नहीं है कि कोड को बार-बार पढ़ने पर कोई छुपा हुआ अपमान है क्योंकि वह भूल जाता है कि क्या वह अब तक 17 या 18 तक गिना जाएगा। इस कारण से आप कोड के भाग में "बॉस ने इसे छोड़ दिया है" में किसी भी शब्द का उपयोग नहीं किया हो सकता है और न ही आप उन 5 शब्दों का उपयोग और अनाग्राम कर सकते हैं।

बोनस चुनौती जिसके लिए मैंने एक इनाम बनाया है

एक प्रोग्राम लिखें जो वास्तव में ऐसा लगता है कि यह अप्रशिक्षित आंख के लिए पहला प्रश्न हल करता है और इसमें अनावश्यक वर्ण शामिल नहीं हैं। इसमें टिप्पणियों और कोड के सेगमेंट शामिल हैं जो स्पष्ट रूप से कुछ भी योगदान नहीं करते हैं। आदर्श रूप से, एक आम आदमी का मानना होगा कि आपका कार्यक्रम वास्तव में उतना ही छोटा है जितना कि यह असहनीय हो सकता है। एक उपयोगी टिप्पणी यहाँ और हालांकि ठीक है।

बोनस चुनौती के नियम थोड़े ढीले हैं, आसानी से मापने योग्य मानदंडों पर निर्णय लेने के बजाय, आपके कार्यक्रम को इस बात पर अधिक आंका जाएगा कि यह मेरे लिए कैसे आता है (और निश्चित रूप से मतदाता)

मैं अंतिम जज बनूंगा, जो इस इनाम के हकदार के रूप में प्रवेश करता है।

संपादित करें:

आपके बॉस की गिनती के कुछ मिनटों के बाद, उनके पास आपका एक सहयोगी उनके लिए एक चरित्र गणना कार्यक्रम लिखता था। यहां तक कि ऐसे अक्षर भी जो आपके वर्ण गणना की ओर दिखाई नहीं दे रहे हैं।

code-golf polyglot

— overactor
स्रोत

38

खैर, व्हॉट्सएप लोगों के लिए यहां एक आसान समय होगा।

— इंगो बुर्क

10

दुर्भाग्य से, सबसे कम संभव व्हाट्सएप कार्यक्रम जो उस संदेश को प्रिंट करता है वह 372 वर्ण है।

— तीन इफ व्हिस्की

37

लेकिन बॉस इसे प्रिंट करेगा और पात्रों की गिनती करेगा। अनुगामी व्हॉट्सएप की गिनती नहीं होगी।

— जोशुआ

6

इनाम की चुनौती दिलचस्प लगती है, लेकिन इसमें कोई संदेह नहीं होगा कि एक मनमानी भाषा में "अच्छी तरह से प्रलेखित और इंडेंटेड" कार्यक्रम के साथ बहुत ही तुच्छता से जीता जाएगा (छिपे हुए व्हाट्सएप के साथ)।

— मार्टिन एंडर

5

अब तक, सभी प्रविष्टियाँ स्पष्ट रूप से गंभीर कार्यक्रम नहीं हैं (यादृच्छिक अस्पष्ट, आदि)। यह वास्तव में दिलचस्प होगा यदि किसी ने पॉलीग्लॉट बनाया (जिसमें व्हॉट्सएप शामिल नहीं है, निश्चित रूप से) जो वास्तव में पहली नज़र में उचित लग रहा था (भले ही यह वास्तव में, वास्तव में लंबा था)।

— दरवाज़े

36

सीजाम ( गोल्फस्क्रिप्ट ), 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. ";

इसे ऑनलाइन आज़माएं!

यह कैसे काम करता है (गोल्फस्क्रिप्ट)

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

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

7

+1: बॉस प्यार करने वाला है कि यह कितना छोटा है। और वह निश्चित रूप से छिपे हुए तार को नहीं देखेगा। हालांकि उन्हें प्राइम चेक देखने में भी परेशानी हो सकती है। :)

— इंगु बुर्क

6

चलो आशा है कि उनका मानना है कि छिपा स्ट्रिंग है प्रधानमंत्री की जांच।

— डेनिस

77

पायथन 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])

पायथन 2 के साथ अभाज्य संख्याओं की पहचान करता है , आप पायथन 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])

इसे पायथन 2 या पायथन 3 के साथ आज़माएं ! (परिवर्तित भूमिकाओं के ऊपर गोल्फ संस्करण के विपरीत: पायथन 3 प्रमुख संख्या पहचानकर्ता है। पायथन 2 में ईस्टर अंडा होता है।)

कृपया, मेरी खराब अंग्रेजी को मदद पाठ में बहाना! ;)

और मैं "छोड़" शब्द का उपयोग करता हूं। लेकिन किसी तरह मुझे वर्णन करने की आवश्यकता है कि मेरा कार्यक्रम कब समाप्त होगा। ;)

— फ़ाल्को
स्रोत

बाहर जाएं? रुकें? गर्भपात?

— मूविंग डक

@MooDDuck: आपका मतलब है कि मैं इनमें से एक शब्द का उपयोग कर सकता हूं? नहीं, तो यह काम नहीं करेगा। ;)

— फाल्को

क्या यह " /समस्या" है? (पूर्णांक विभाजन बनाम चल बिन्दु प्रभाग)

— HLT

2

दूसरे ने मेरे दिमाग को उड़ा दिया - जब तक मैं थोड़ा करीब नहीं देखा। ऐसा लगता है कि मैं भी कोड के बजाय टिप्पणियों को पढ़ने की आदत में पड़ गया हूं।

— प्रिमो

3

दूसरा वाला वास्तव में अच्छा है! कुडोस!

— रुबिक

66

बोनस जमा करना (C / C ++ 11)

सामान्य भोली विधि का उपयोग करके परिक्षण परीक्षण इतना मुख्यधारा है। यही कारण है कि मैंने एक नया-नया यादृच्छिक अनुभवहीन तरीका ईजाद किया है! यह परीक्षण इस प्रकार है:

किसी भी पूर्णांक चुनें घ यादृच्छिक पर। यह 2 से छोटा नहीं होना चाहिए और इससे थोड़ा अधिक होना चाहिए sqrt(n)।
यदि d n का एक भाजक है , आउटपुट not prime।
यदि हमने यह परीक्षण 20sqrt(n)समय, आउटपुट prime, और फिर से दोहराया है।

यदि संख्या समग्र है, तो केवल बहुत कम संभावना (लगभग 10 ^-9 ) है कि यह काम नहीं करता है। बेशक, मेरा मानना है कि सी / सी ++ छद्म आयामी संख्या जनरेटर पर्याप्त शक्तिशाली नहीं है। इसलिए मैं अपने 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 सही ढंग से काम करता है। हालांकि, सी संकलक n> 2 के लिए एक दोषपूर्ण कार्यक्रम आउटपुट कर रहा है ...

नोट : याद रखें कि C -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लाइन को हटा दें ।

— mnbvmar
स्रोत

4

यह बहुत आश्वस्त लगता है। थोड़ा समझाने की देखभाल करें, इसलिए मुझे अपना कंपाइलर खोदना नहीं है? :)

— कॉम्पिटिशन

ठीक है, मैंने इसे जोड़ा।

— mnbvmar 21

ये अद्भुत है!

— इंगो बुर्क

बहुत अच्छा! अब तक का सबसे अच्छा जवाब, मेरी राय में।

— CompuChip

वास्तव में प्रभावित करने वाला!

— वेन

46

गणितज्ञ / ब्रेनफक, 260

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

— पीटर ओल्सन
स्रोत

95

ओल्सन! यह कोड होने की तुलना में कई गुना अधिक लंबा है! ये सभी अप्राकृतिक प्लस क्या हैं और संकेतों से अधिक हैं? आपको बर्खास्त जाता है! नहीं, सर, मुझे लगता है कि आप पाएंगे कि मैंने नौकरी छोड़ दी है।

— लेवल रिवर सेंट

12

@steveverrill मुझे लगता है कि आपकी नौकरी छोड़ने का एक तरीका है।

— 18

42

गोल्फस्क्रिप्ट / जावास्क्रिप्ट (126 125 129 130 132 134 205 207 )

यहाँ और जावास्क्रिप्ट यहाँ आज़माएँ ।

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

मैं कहूंगा कि यह उन गणितज्ञों के समाधानों के करीब है, जो बाद में, अभाज्य संख्याओं के लिए बिल्ट-इन चेक होते हैं।

संपादित करें: एक और दो छह बाइट्स बचाने के लिए पीटर का धन्यवाद !

यहाँ कुछ विवरण है:

पहले 1.की आवश्यकता है क्योंकि निम्नलिखित //जावास्क्रिप्ट में एक टिप्पणी है, लेकिन गोल्फस्क्रिप्ट में दो बार विभाजन करता है। यदि स्टैक पर कुछ भी नहीं है, तो यह त्रुटि करेगा, इसलिए हमें इसे दो नंबर देने की आवश्यकता है। संयोग से, 1.जावास्क्रिप्ट में एक पूरी तरह से वैध वाक्यविन्यास है और इसे केवल अनदेखा किया जाएगा।
"…"{(}%स्ट्रिंग लेता है, एक-एक करके उनके वर्ण कोड मानों को घटाता है और इसे स्ट्रिंग के रूप में धकेलता है। इसके परिणामस्वरूप हमें स्ट्रिंग को प्रिंट करना होगा।
' गोल्फस्क्रिप्ट में एक स्ट्रिंग शुरू होती है जो डिफ़ॉल्ट रूप से कई लाइनों पर फैली होती है, जिससे नीचे जावास्क्रिप्ट केवल स्ट्रिंग में डाल दिया जाता है।
अगला जावास्क्रिप्ट कोड है, जो नियमित अभिव्यक्ति के माध्यम से अभाज्य संख्याओं का पता लगाने के लिए कुछ हद तक प्रसिद्ध दृष्टिकोण का उपयोग करता है।
';#'गोल्फस्क्रिप्ट में मल्टी-लाइन स्ट्रिंग को बंद कर देता है, इसे छोड़ देता है और फिर बाकी लाइन को अनदेखा कर देता है। जावास्क्रिप्ट में, यह केवल एक स्ट्रिंग शाब्दिक है जिसे अनदेखा किया जाएगा।

— इंगो बुर्क
स्रोत

1

जीएस में 1+है )। और 1 1है 1., जो मुझे संदेह है कि जेएस के रूप में खुश होगा1

— पीटर टेलर

@PeterTaylor बहुत बढ़िया, धन्यवाद! मैंने इसे शामिल किया है।

— इंगो बुर्क

1

इसके अलावा, यदि आप एक स्ट्रिंग पर कुछ मैप करते हैं तो आपको एक स्ट्रिंग मिलती है, इसलिए {)}/]""+बस हो सकता है {)}%।

— पीटर टेलर

@PeterTaylor तुम आदमी हो! :)

— इंगु बुर्क

1

@overactor उघ, यहाँ वही गलती। मुझ पर शर्म की बात है। मुझे इसे आज रात बाद में ठीक करना होगा, हालाँकि।

— इंगो बुर्क

34

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 एकल लाइन टिप्पणियों को नहीं पहचानता है, इसलिए समस्या स्ट्रिंग को शून्य से गुणा नहीं किया जाता है।

— nbubis
स्रोत

4

आपको अपने ब्रेक को जोड़ना चाहिए for। यदि आप इनपुट करते हैं तो यह "प्रधान नहीं" होता है। 6. primeशून्य और एक के लिए प्रिंट भी

— pqnet

1

आप नंबर की आपूर्ति कैसे करते हैं? इसके अलावा, एस / ब्रेक}; / तोड़;} /;)

— एंजेल

@ @Ngel - nशुरुआत में पाया जाने वाला अभाज्य संख्या निर्धारित करता है।

— nbubis

@nbubis यह अभी भी गलत तरीके primeसे शून्य और एक के लिए छपाई कर रहा है, जैसा कि पहले pqnet ने देखा था।

— wil93

21

सीजेम / रूबी, 132 95 91 87

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

मेरा पिछला समाधान काफी अधिक इंजीनियर था; यह एक मार्टिन बंटनर के समाधान से बहुत अधिक प्रेरित था, जिसमें उनका अहसास भी शामिल था कि यह #bytesविधि स्पष्ट रूप से एक ब्लॉक ले सकती है।

यह कैसे काम करता है?

रूबी का टिप्पणी चरित्र ( #) सीजेएम में प्रतिपादक ऑपरेटर है, इसलिए हमें शुरू करने से पहले स्टैक पर कम से कम दो नंबरों की आवश्यकता है, लेकिन दो नंगे नंबर ( 0 0) रूबी में एक वाक्यविन्यास त्रुटि है। एक ठीक है, हालांकि, और, सहायक रूप से, रूबी संख्या में विभाजक ( 1_234) के रूप में अंडरस्कोर हो सकते हैं । _CJam का दोहराव ऑपरेटर है, इसलिए हमें ;;टिप्पणी के अंदर आने के बाद दो बार ( ) पॉप करने की आवश्यकता है । limpमानक इनपुट से एक पंक्ति पढ़ता है, इसे एक पूर्णांक में परिवर्तित करता है, इसे पॉप करता है, और धक्का देता है कि यह प्रमुख है या नहीं।

रूबी मोड में आने के लिए, हम एक स्ट्रिंग खोलते हैं और अगली पंक्ति पर जारी रखते हैं ताकि हम अब रूबी टिप्पणी में न हों (इस प्रकार, नई पंक्ति महत्वपूर्ण है और इसे गिना जाना चाहिए)। संदेश का प्रत्येक वर्ण डीकोड और प्रिंट किया गया है, और फिर हम एक और रूबी टिप्पणी शुरू करते हैं ताकि हम इसे पॉप करने से पहले सीजेएम स्ट्रिंग को सुरक्षित रूप से बंद कर सकें। स्टैक पर जो बचा है वह इनपुट प्राइम था या नहीं, जो सीजेएम प्रोग्राम की समाप्ति पर मुद्रित हो जाता है।

CJam / व्हाट्सएप, 353 (मुद्रित होने पर 25 सार्थक)

चुनौती की कम होती प्रकृति और इस तथ्य को देखते हुए कि बॉस पात्रों की गणना करने के लिए हमारे कार्यक्रमों को प्रिंट कर रहे होंगे, मैंने व्हाट्सप से जुड़े एक समाधान को करने का सुझाव लिया ।

मेरे पिछले दावे के विपरीत कि सबसे कम संभव व्हाट्सएप कार्यक्रम जो प्रिंट करता है "यदि बॉस को यह पता चलता है, तो मैंने छोड़ दिया।" 372 वर्ण होंगे, यह 330 में करता है। चाल copyASCII मूल्यों को धकेलने के बजाय स्टैक पर कहीं से दोहराए जाने वाले वर्णों को जोड़ने के लिए निर्देश का उपयोग करना है , जो हमेशा बहुत बड़ा होने वाला होता है और इस प्रकार अधिक रिक्त स्थान की आवश्यकता होती है और सांकेतिक शब्दों में बदलना करने के लिए टैब। यहाँ उत्सुक के लिए कार्यक्रम का छद्म विधानसभा प्रतिनिधित्व है:

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

— व्हिस्की से तीन अगर
स्रोत

यह पदावनत है लेकिन यह काम करता है: ruby-doc.org/core-2.1.2/String.html#method-i-bytes

— मार्टिन

यह #charsऔर #linesसाथ ही साथ काम करता है , जिसे मुझे भविष्य की चुनौतियों के लिए ध्यान में रखना होगा।

— तीन अगर व्हिस्की

मुझे लगा कि मैंने कोशिश की charsऔर यह किसी कारण से काम नहीं आया।

— मार्टिन एंडर

आप "" के बजाय L जैसे एक चर का उपयोग कर सकते हैं, और मुझे नहीं लगता कि आपको

— aditsu

1

वास्तव में, आप limp4*"not prime">इसे और भी छोटा बनाने के लिए उपयोग कर सकते हैं

— aditsu

20

बोनस पुरस्कार प्रस्तुत (पर्ल / बी? एफ? एन? ई? 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"

नियमों का झुकना और तोड़ना :

मैं वहां "" द शब्द का उपयोग कर रहा हूं, लेकिन यह "द" नहीं है जो कि प्रिंट हो जाता है। यह तकनीकी रूप से अमान्य हो सकता है, मैं ओपी को यह तय करने दूंगा कि क्या बोनस चुनौती के लिए नियमों में यह सख्त होना चाहिए। यदि हां, तो ऐसा हो।
नियम मैं कुछ शब्दों का उपयोग नहीं कर सकता है, लेकिन हम बाएं से दाएं पढ़ते हैं, इसलिए मैं मानता हूं कि लंबित रूप से लिखे गए शब्द वैध हैं।
मुझे पता नहीं है कि मुझे अभी भी यह नौकरी कैसे मिली है, जो भयानक चीजें मैं टिप्पणियों में लिखता हूं। मेरा मतलब है: पहेलियों, वास्तव में?

— इंगो बुर्क
स्रोत

4

हाँ, बोनस इनाम के लिए एक और योग्य प्रतियोगी! :)

— फाल्को

मुझे बोनस प्रश्न के लिए अनुमति देने में कोई समस्या नहीं है। मैं इस बारे में कुछ और स्पष्टीकरण देखना चाहता हूं कि बेफ़ुंज कार्यक्रम किस तरह से काम करता है।

— overactor

@overactor धन्यवाद। मैं कल कुछ स्पष्टीकरण जोड़ सकता हूं, लेकिन यहां कोड के माध्यम से कदम रखना आपको यहां दिखाएगा कि यह कैसे काम करता है।

— इंगो बुर्क

@overactor ऐसा लगता है कि कोड कुछ 'तीर' ( ^= ऊपर ले जाएँ) का अनुसरण करता है । टिप्पणियों के कुछ अक्षरों को एक स्टैक पर रखा गया है, जो अंत में प्रिंट किया गया है, मुद्रण If the boss finds this, I quit.इनगो की प्रतिक्रिया में URL के माध्यम से उदाहरण देखें:"!dlrow olleH">:#,_@

— BlueCacti

बॉस बहुत अधिक प्रलेखन के बारे में शिकायत कर सकता है। इसमें कुछ संदिग्ध चरित्र भी हैं।

— tbodt

17

गणितज्ञ / रूबी, 115 106 बाइट्स

मैथेमेटिका भाग पीटर ओल्सन की अधीनता से थोड़ा प्रेरित था, लेकिन रूबी के साथ पॉलीग्लॉटिंग यहां थोड़ा अधिक विस्तृत है।

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

रूबी काम करती है, क्योंकि दोनों #हर चीज की टिप्पणी करते हैं जो कि गणितज्ञ है। Mathematica के काम करने का कारण थोड़ा और दिलचस्प है। जिस कोड को मैं निष्पादित करना चाहता हूं वह है:

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

लेकिन यह रूबी के लिए मान्य नहीं है, इसलिए मुझे #कहीं न कहीं जोड़ना होगा। #अनाम कार्यों के लिए गणितज्ञ का पैरामीटर है। इसलिए मैंने #सामने रखा , जो तर्क को परिणाम के साथ गुणा करता है If। हां, यह एक स्ट्रिंग के साथ गुणा करेगा , जो भी इसका मतलब है। फिर मैं इसे एक अनाम फ़ंक्शन में बदल देता हूं &और इसे तुरंत तर्क के साथ कहता हूं 1। खैर, गणितज्ञ यह जानने के लिए पर्याप्त चतुर है कि 1 से गुणा हमेशा पहचान है और केवल स्ट्रिंग को आउटपुट करता है। बाद में, रूबी कोड बस एक ब्लॉक टिप्पणी में डाल दिया है।

— मार्टिन एंडर
स्रोत

15

सी (बोनस सबमिशन)

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!

अन्य भाषा:

दिमागी फितूर । इसे केवल एक इनपुट नंबर के साथ ब्रेनफॉक के रूप में चलाने से उचित स्ट्रिंग का उत्पादन होगा। एक से अधिक इनपुट, और आपको यह सुनिश्चित करना होगा कि ब्रेनफक प्रोग्राम के लिए इनपुट शून्य बाइट्स हैं।

— es1024
स्रोत

6

हे भगवान, मुझे लगता है कि मैंने इस तरह का कोड देखा है ...

— क्रिस्टोफ़र साल्-स्टॉरगार्ड

8

@KristofferSHansen उत्पादन में नहीं, मुझे उम्मीद है ...

— es1024

1

नाइस ब्रेनफुक: डी

— वेन

14

पर्ल / बेफुज -93 (108 106 110 )

मेरा दूसरा सबमिशन, सिर्फ इसलिए। नियमित अभिव्यक्ति का भी उपयोग करता है। मैं शर्त लगाता हूं कि पर्ल की तुलना में एक बेहतर विकल्प है, उदाहरण के लिए ऑक्टेव, लेकिन मैं यह पता नहीं लगा सका कि सशर्त रूप से प्रिंट कैसे करें।

मैं स्ट्रिंग को मुद्रित करने के लिए नियम का दुरुपयोग कर रहा हूं क्योंकि मैं इसे कई तार में विभाजित करके एनाग्राम से बचा रहा हूं।

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

चेक करने का नंबर स्टड से लिया गया है।

संपादित करें: मैंने गलती से "the" के बजाय "my" लिख दिया, इसे ठीक करने में +1 बाइट खर्च हुआ।
संपादित करें: सहेजे गए 4 बाइट के ifबजाय का उपयोग करना unless।
संपादित करें: "द" के बारे में भूल गया, उस बंटवारे के साथ-साथ +2 बाइट्स।

— इंगो बुर्क
स्रोत

1

पृष्ठभूमि में fades के पास befunge। यह नोटिस करना मुश्किल है। बहुत बढ़िया।

— AndoDaan

छोटी आपत्ति, यह "अगर बॉस" के बजाय "यदि मेरे बॉस" होना चाहिए, तो यह मेरा पसंदीदा सबमिशन है हालांकि अभी तक।

— overactor

1

@overactor आह, आप सही कह रहे हैं। मैं वादा करता हूं कि यह धोखा देने का प्रयास नहीं था, मैंने एक बैठक के दौरान इसके लिए विचार होने के बाद इसे एक साथ हैक किया :) मैंने इसे ठीक किया, धन्यवाद!

— इंगो बुर्क

5

मेरा तर्क है कि बॉस कोड में पीछे के संदेश को देख सकता है।

— टिम एस।

1

अजीब तरह से मैंने सोचा कि और भी थे, लेकिन आपने एक निषिद्ध शब्द को उजागर कर दिया है: द।

— इग्बी लार्गेमैन

7

लुआ / PBrain (प्रक्रियात्मक ब्रेनफ * 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))

— AndoDaan
स्रोत

संदेश छिपाने का बहुत प्रभावी तरीका नहीं ..

— nbubis

@nbubis कैसे?

— AndoDaan

5

ठीक है, मैं सिर्फ कोड देख कर "बॉस" और "मैं छोड़ दिया" :)

— nbubis

7

@nbubis MISDIRECTION, MY GOOD MAN! एक संदिग्ध करीबी निरीक्षण के तहत स्टैंडआउट कोड सिर्फ एक मजाकिया दिखने वाला प्रिंट सशर्त (primes के लिए) साबित होगा ... यदि आप किसी के बॉस थे तो शायद आप खुद पर थोड़ा शर्मिंदा होंगे ... और फिर इसे छोड़ दें , आगे की जाँच नहीं। यह BF कोड में है। मैं आपको इस पर ध्यान देने और टिप्पणी करने के लिए पर्याप्त धन्यवाद नहीं दे सकता, rbubis।

— AndoDaan

5

मुझे प्रस्तुत करना पसंद है, लेकिन मेरा मानना है कि यह अमान्य है। आप कोड में "छोड़" का उपयोग नहीं कर सकते। हालाँकि ओपी ने केस सेंसिटिविटी के बारे में कुछ नहीं कहा, लेकिन ..

— इंगो बुर्क

7

पायथन 2 / रोट 13 - 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"

यह एक बहुत ही सरल (अर्थात अक्षम) एल्गोरिथ्म का उपयोग करता है। जब रोट 13 (यकीनन प्रोग्रामिंग भाषा नहीं) के साथ चलाया जाता है, तो यह आवश्यक वाक्य (अन्य बकवास के साथ) पैदा करता है।

सबसे बुरी बात यह है कि टिप्पणियां स्पष्ट हैं और वैसे भी काफी बेकार हैं।

यह एक अन्य तरीके से बहुभाषाविद है, जिसमें अंग्रेजी और "एस्पेरांतो" दोनों शामिल हैं। मुझे आशा है कि बॉस स्वयं बहुवचन नहीं है।

— इयान डी। स्कॉट
स्रोत

2

हम्म, निश्चित रूप से बिल्कुल भी एस्पेरांतो की तरह नहीं दिखता है।

— पाओलो एबरमन

2

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)

— MilkyWay90
स्रोत

2

पायथन, 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) गुप्त छिपाता है। यदि हेक्स में परिवर्तित किया जाता है, तो हेक्स के प्रत्येक दो अंकों का एएससीआईआई अक्षर प्रतिनिधित्व "यदि बॉस को यह पता चलता है, तो मैंने छोड़ दिया।" डरपोक हिस्सा chr फ़ंक्शन का उपयोग कर रहा है। यदि बॉस को पता है कि वह क्या करता है और ध्यान से पर्याप्त देख रहा है, तो उसे पता चलेगा कि कोड एक गुप्त संदेश छुपाता है। हालाँकि, मैंने यह माना कि थोड़ा और पूरे अधिकतम पूर्णांक की चीज़ को पर्याप्त व्याख्या प्रदान की, ताकि बॉस को यह विश्वास दिलाया जा सके कि यह कार्यक्रम का एक वैध हिस्सा है

ध्यान दें कि अधिकांश मापदंडों के लिए यह काम करता है जैसे कि बॉस इसे चाहता है, लेकिन यदि इनपुट पूर्णांक नहीं है या संख्या किसी भी तरह एमआई से बड़ी है, तो पी उस त्रुटि को छिपा देता है जिसमें छिपा हुआ स्ट्रिंग होता है। मैं फ़ंक्शन के अंदर एक प्रिंट कॉल डाल सकता था, लेकिन मुझे लगा कि अगर इसे वापस कर दिया गया तो यह अधिक वास्तविक लगेगा।

— आलू
स्रोत

क्या यह बहुविकल्पी है?

— मिल्कीवेय 90

1

सी # - 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;

— chrixbittinx
स्रोत

4

यह एक बहुभुज हालांकि है?

— ओवरएक्टर

संभवत: पॉलीग्लॉट के साथ अपनी नौकरी छोड़ दें

मज़ेदार हिस्सा

सीजाम ( गोल्फस्क्रिप्ट ), 60 59 बाइट्स

यह कैसे काम करता है (CJam)

यह कैसे काम करता है (गोल्फस्क्रिप्ट)

पायथन 2 / पायथन 3 - 128

बोनस

बोनस जमा करना (C / C ++ 11)

गणितज्ञ / ब्रेनफक, 260

गोल्फस्क्रिप्ट / जावास्क्रिप्ट (126 125 129 130 132 134 205 207 )

C ++ / C99 / C90 - 248

सीजेम / रूबी, 132 95 91 87

CJam / व्हाट्सएप, 353 (मुद्रित होने पर 25 सार्थक)

बोनस पुरस्कार प्रस्तुत (पर्ल / बी? एफ? एन? ई? 3)

नियमों का झुकना और तोड़ना :

गणितज्ञ / रूबी, 115 106 बाइट्स

सी (बोनस सबमिशन)

पर्ल / बेफुज -93 (108 106 110 )

लुआ / PBrain (प्रक्रियात्मक ब्रेनफ * ck) - 813

पायथन 2 / रोट 13 - 270 बाइट्स (69 नॉट काउंटिंग कमेंट्स)

05AB1E / जेली , 28 बाइट्स

पायथन, 403 बाइट्स

सी # - 288