यह चुनौती काफी सरल है कि यह मूल रूप से शीर्षक में है: आपको एक सकारात्मक पूर्णांक एन दिया गया है और आपको सबसे छोटा सकारात्मक पूर्णांक वापस करना चाहिए जो कि एन का भाजक नहीं है ।

एक उदाहरण: N = 24 के भाजक हैं 1, 2, 3, 4, 6, 8, 12, 24। सबसे छोटा धनात्मक पूर्णांक जो उस सूची में नहीं है 5 है , इसलिए इसका परिणाम आपके समाधान को खोजना चाहिए।

यह OEIS अनुक्रम A007978 है ।

नियम

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

परीक्षण के मामलों

पहले 100 शब्द हैं:

2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 
3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 
2, 3, 2, 4, 2, 3, 2, 3, 2, 7, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 
3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 5, 2, 3, 2, 3

विशेष रूप से, सुनिश्चित करें कि आपका उत्तर इनपुट 1 और 2 के लिए काम करता है, जिस स्थिति में परिणाम इनपुट से बड़ा है।

और कुछ बड़े परीक्षण मामलों के लिए:

N          f(N)
1234567    2
12252240   19
232792560  23

code-golf number-theory

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

मैंने सैंपल आउटपुट स्ट्रिंग को संख्याओं के वेक्टर में बदल दिया, और महसूस किया कि यदि आप इसे 24 कॉलम भर में प्रारूपित करते हैं, तो यह बहुत ही दोहराव है, केवल अजीब विचलन को छोड़कर।

— कैरिजिनेट

यह समझ में आता है, 24 0 मॉड 2, 3 और 4 है, इसलिए केवल अंतर उन कॉलमों में होगा जहां नंबर> 4 हैं। यह चौड़ाई 120 पर और भी अधिक दोहराई जाती है।

— कैलकुलेटरफैनलाइन

18

गणितज्ञ, 19 बाइट्स (UTF-8 एन्कोडिंग)

1//.x_/;x∣#:>x+1&

गैर-पूर्णांक पूर्णांक तर्क लेने और एक सकारात्मक पूर्णांक वापस करने का कार्य करें। आधे रास्ते के बारे में ऊर्ध्वाधर बार वास्तव में तीन-बाइट चरित्र U + 2223 है, जो कि मैथेमेटा में विभाज्यता संबंध को दर्शाता है। स्पष्टीकरण:

1                   Starting with 1,
 //.                apply the following rule until it stops mattering:
    x_                if you see a number x
      /;x∣#           such that x divides the function argument,
           :>x+1      replace it with x+1.
                &   Cool, that's a function.

जोड़ने के लिए संपादित: ngenisis बताते हैं कि //.डिफ़ॉल्ट रूप से, अधिकतम 65536 बार पुनरावृति करेगा। इसलिए यह कार्यान्वयन 1 से 65538 (विशेष रूप से, सबसे अधिक 28436 अंकों वाले सभी नंबरों पर) के पूर्णांक के कम से कम सामान्य गुणकों के लिए काम करता है, लेकिन तकनीकी रूप से सभी नंबरों के लिए नहीं। एक जगह ले सकता है x//.yके साथ ReplaceRepeated[x,y,MaxIterations->∞]34 अतिरिक्त बाइट्स की कीमत पर इस दोष को ठीक करने, लेकिन स्पष्ट रूप से।

— ग्रेग मार्टिन
स्रोत

का उपयोग किए बिना पाश करने के लिए बहुत दिलचस्प तरीके से For, While, आदि

— ngenisis

5

मैंने इसे इस साइट से सीखा है! मैं निश्चित रूप से यहां होने से गणितज्ञों के बारे में अधिक जानने का आनंद ले रहा हूं (क्या मैं अपने टाइमशीट पर इसे सही ठहरा सकता हूं ...?)।

— ग्रेग मार्टिन

3

यह गणितज्ञ O_o

— मामा फन रोल

2

बड़े अक्षरों और कोष्ठक को मूर्ख बनाने की कमी न होने दें;)

— ग्रेग मार्टिन

1

वास्तव में केवल 28436 अंक ।

— user202729

14

अजगर, 3 बाइट्स

f%Q

मूल रूप से, fकोड को तब तक लूप करता है जब तक %QT( Q % Tजहां Tपुनरावृत्ति चर है) सत्य है।

इसे यहाँ ऑनलाइन आज़माएँ।

— busukxuan
स्रोत

2

समस्या को देखा, यह उत्तर दिया, इसे पोस्ट करने के लिए यहां आया, तुम्हारा पाया। बहुत बढ़िया!

— isaacg

मैंने इसे लिखा और अपने बारे में भयानक महसूस किया: .V1In%Qb0bBआपका उत्तर देखा, और अब इतना भयानक नहीं लग रहा था।

— जॉन रेड

@ जोहड़ लोल, मुझे लगता है कि आपको अपने आप को पायथ में अंतर्निहित के साथ परिचित करने की आवश्यकता है।

— बुसुकुआन

14

जावास्क्रिप्ट (ईएस 6), 25 23 बाइट्स

f=(n,k)=>n%k?k:f(n,-~k)

नोट: यहां एक दिलचस्प बात यह है कि kपैरामीटर को पहले पुनरावृत्ति पर प्रारंभिक निहिलो शुरू किया गया है। यह काम करता है क्योंकि n % undefinedहै NaN(falsy की उम्मीद के रूप में) और -~undefinedके बराबर होती है 1। अगले पुनरावृत्तियों पर, -~kअनिवार्य रूप से इसके बराबर है k+1।

परीक्षा

कोड स्निपेट दिखाएं

f=(n,k)=>n%k?k:f(n,-~k)

// first 100 terms
for(i = 1, list = []; i <= 100; i++) {
  list.push(f(i));
}
console.log(list.join(' '));

// larger test cases
console.log(f(1234567));
console.log(f(12252240));
console.log(f(232792560));

स्निपेट का विस्तार करें

— Arnauld
स्रोत

बिल्कुल वही जो मुझे मिला। मुझे आश्चर्य होगा कि अगर कुछ भी संभव है

— ETHproductions

@ETHproductions दूसरे विचार में, एक छोटा है। :-)

— अरनौल

5

उम। वो… उह… वाह।

— ETHproductions

13

पायथन, 43 36 35 बाइट्स

f=lambda n,d=2:d*(n%d>0)or f(n,d+1)

— orlp
स्रोत

13

हेक्सागोनी , 12 बाइट्स

\\)?}'@{!%.}

Embiggened:

   \ \ )
  ? } ' @
 { ! % . }
  . . . .
   . . .

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

— सोक
स्रोत

2

यह Hexagony, अच्छा काम के लिए एक बहुत ही प्रभावशाली स्कोर है!

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

11

आर, 28 बाइट्स

बहुत सीधा, कुछ भी नहीं फैंसी। स्टडिन से इनपुट लेता है, Tजब तक कि iमोड्यूलो Tनॉनजरो न हो जाए

i=scan()
while(!i%%T)T=T+1
T

यदि आप कुछ अधिक फैंसी चाहते हैं, तो 29 बाइट्स के लिए निम्नलिखित है :

i=scan()
match(0,!i%%1:(i+1))

व्याख्या की:

i=scan(): iस्टडिन से पढ़ें ।

1:(i+1): से सभी पूर्णांकों उत्पन्न 1करने के लिए i+1( +1के मामलों के लिए लेखांकन 1और 2)।

i%%1:(i+1) : हमारी सूची में हर नंबर के इनपुट को मोडुलो।

!i%%1:(i+1): परिणामी सूची को हटा दें; इस परोक्ष, एक तार्किक प्रकार में बदल देता है ऐसा है कि 0है FALSEऔर अशून्य है TRUE। उपेक्षा करने के बाद, TRUEमूल्य बन जाते हैं FALSEऔर इसके विपरीत। अब, सभी गैर-मूल मानों को कोडित किया गया है FALSE।

match(0,!i%%1:(i+1)): 0हमारी सूची के पहले उदाहरण का सूचकांक लौटाएँ । 0है FALSE, तो यह पहले के सूचकांक रिटर्न FALSEसूची है, जो सापेक्ष आपरेशन से पहले अशून्य मान है में। चूंकि हमारी मूल सूची शुरू हुई थी 1, इसलिए सूचकांक सबसे छोटे गैर-भाजक के मूल्य के बराबर है।

— rturnbull
स्रोत

अच्छा लगा, बस उपयोग करने का सुझाव देना चाहता था which.min, लेकिन फिर मैंने संपादन देखा और ऐसा लगता है कि matchयह एक समान काम करता है।

— JAD

2

इसके अलावा, लूप Tसे पहले इसे परिभाषित करने की आवश्यकता को सहेजते हुए, अच्छी चाल while।

— JAD

@JarkoDubbeldam धन्यवाद! मैं वेक्टर दृष्टिकोण के लिए दृष्टिकोण की तुलना में कम होने का रास्ता नहीं खोज सकता while, जो ठीक है क्योंकि यह बड़े एन के लिए बहुत स्मृति-गहन है। Tचाल उन व्यवहारों में से एक है जो गोल्फ के लिए महान है लेकिन वास्तविक प्रोग्रामिंग के लिए बिल्कुल भयानक है। (और निश्चित रूप से आप Fभी जरूरत पड़ने पर उपयोग कर सकते हैं 0।)

— rturnbull

आप 1 के बजाय 0: i + 1 का उपयोग करके दो बाइट्स बचा सकते हैं: (i + 1) हालांकि मुझे यकीन नहीं है कि यह %% ऑपरेटर के साथ कैसे खेलता है।

— एंटोनी-सैक

@ एंटोइन-सैक दुर्भाग्य से, %%पूर्वता खत्म कर लेता है +, इसलिए पैरेंस अभी भी आवश्यक हैं: (0:i+1)बाइट्स की समान संख्या के साथ 1:(i+1)। मेरे पास वास्तव में पूर्व था, लेकिन बाद में इसे बदल दिया क्योंकि यह पढ़ना आसान है।

— rturnbull

10

हास्केल, 26 बाइट्स

f n=until((>0).mod n)(+1)1

हर कोई भूल जाता है until!

— XNOR
स्रोत

9

ब्रेकीलॉग , 10 बाइट्स

~{=#>:A'*}

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

यह Fatalize के मूल समाधान के समान (लेकिन इससे कम) के समान था। घातक के बाद से एक अलग एल्गोरिथ्म में स्विच किया गया है जो एक अलग विधि के माध्यम से इस के साथ संबंध रखता है, इसलिए मैं इसे खुद को समझाने जा रहा हूं:

~{=#>:A'*}
~{       }    inverse of the following function:
  =           try possible values for the input, if it's unbound
   #>         the input is a positive integer
     :A'*     there is no A for which the input times A is the output

जब हम "इनपुट" और "आउटपुट" को स्वैप करके फ़ंक्शन को उलटा करते हैं, तो हमें एक उचित उचित एल्गोरिथ्म मिलता है (बस एक अजीब तरीके से व्यक्त किया गया है): "संभव सकारात्मक पूर्णांकों का प्रयास करें, उनके प्राकृतिक क्रम में (अर्थात 1 ऊपर की ओर), जब तक आप नहीं मिलते। इनपुट का उत्पादन करने के लिए किसी भी चीज से गुणा नहीं किया जा सकता है "। जब तक सभी इनपुट ज्ञात नहीं हो जाते, तब तक Brachylog फ़्लोटिंग-पॉइंट गणना नहीं करता है, इसलिए यह केवल पूर्णांक A पर विचार करेगा।

1

ऐसा करने के बारे में कभी नहीं सोचा, यह साफ है!

— घातक

8

ब्रेकीलॉग , 11 10 बाइट्स

,.=:?r'%0'

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

व्याख्या

,.=           Assign an integer to the output
 . :?r'%0     Input mod Output ≠ 0
        0'    Output ≠ 0

— Fatalize
स्रोत

8

गाय, 174 बाइट्स

oomMOOMMMmoOmoOmoOMMMmOomOoMoOMMMmoOmoOmoOMMMmOoMOOmoO
MOomoOMoOmOoMOOmoOmoomoOMOOmOoMoOmoOMOomoomOomOoMOOmOo
moomoOMOomoomoOmoOMOOmOomOomOomOoOOMOOOMOomOOmoomOomOo
mOomOomOomoo

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

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

कोड टूटना

oom                          ;Read input into [0].
MOO                          ;Loop while [0].  We never change [0], so the program only terminates forcibly after a print.
  MMMmoOmoOmoOMMMmOomOo      ; Copy [0] to [3] and navigate to [1].
  MoOMMMmoOmoOmoOMMM         ; Increment [1], and copy it to [4]
  mOo                        ; Navigate back to [3].
  MOO                        ; Modulus algorithm.  Direct port of brainfuck algorithm.
    moOMOomoOMoOmOo
    MOO
      moO
    moo
    moO
    MOO
      mOoMoOmoOMOo
    moo
    mOomOo
    MOO
      mOo
    moo
    moOMOo
  moo                        ; End modulus algorithm.
  moOmoO                     ; Navigate to [5].  This contains our modulus.
  MOO                        ; Only perform these operations if [5] is non-zero -- i.e. [0] % [1] != 0
    mOomOomOomOoOOMOOOMOomOO ;  Navigate to [1], print its contents, then error out.
  moo                        ; End condition
  mOomOomOomOomOo            ; Since we're still running, [0] % [1] == 0, so navigate back to [0] and try again.
moo                          ;End main loop.

व्याख्या

कोड पहले पूर्णांक को [0] में पढ़ता है। मुख्य लूप का प्रत्येक पुनरावृत्ति (26 के माध्यम से लाइनें 2) वेतन वृद्धि [1], फिर मापांक एल्गोरिथ्म के लिए आवश्यक सभी चीजों को कॉपी करता है, जो इसके परिणाम को [5] में फैलाता है। यदि [5] में कोई मूल्य है, तो [1] वह संख्या है जिसे हमें प्रिंट करने की आवश्यकता है। हम इसे प्रिंट करते हैं, और फिर प्रोग्राम को मजबूर करते हैं।

चूँकि एक ब्रेनफ़ॉक व्युत्पन्न है, इसलिए यह उसी तरह से काम करता है जिस तरह से ब्रेनफ़ॉक संचालित होता है - टेप की अनंत पट्टी, आप बाएं या दाएं, बढ़ या घट सकते हैं, और "लूप" कर सकते हैं, जबकि वर्तमान टेप मान गैर-शून्य है। Brainfuck के अलावा, COW उपयोगी सुविधाओं के एक जोड़े के साथ आता है।

(0) moo -- Equivalent to ]
(1) mOo -- Equivalent to <
(2) moO -- Equivalent to >
(3) mOO -- No equivalent.  Evaluate current tape value as instruction from this list.
(4) Moo -- If tape is 0, equivalent to ,; if tape is non-zero, equivalent to .
(5) MOo -- Equivalent to -
(6) MoO -- Equivalent to +
(7) MOO -- Equivalent to [
(8) OOO -- No equivalent.  Set tape (positive or negative) to 0
(9) MMM -- No equivalent.  If register is empty, copy tape to register.  If register is non-empty, paste register to tape and clear register.
(10) OOM -- No equivalent.  Print an integer from tape to STDOUT
(11) oom -- No equivalent.  Read an integer from STDIN and store it on tape

ब्याज यहाँ के वास्तविक बिंदु, अनुदेश 3 है mOO। दुभाषिया वर्तमान टेप मूल्य को पढ़ता है, और उस टेप मूल्य के आधार पर एक निर्देश निष्पादित करता है। यदि मान 0 से कम है, 11 से अधिक है, या 3 के बराबर है, तो दुभाषिया कार्यक्रम को समाप्त करता है। एक बार हमारे गैर-विभाजक मिल जाने के बाद, हम इसे मुख्य लूप (और पूरी तरह से कार्यक्रम) के त्वरित-गंदे बल के रूप में उपयोग कर सकते हैं। हमें केवल अपना नंबर प्रिंट करना है, स्पष्ट [1] (साथ OOO), इसे -1 के साथ घटाएं MOo, और फिर निर्देश -1 निष्पादित करें mOOजिसके माध्यम से कार्यक्रम समाप्त होता है।

इस कार्यक्रम के लिए टेप ही इस प्रकार है:

[0]  -- Read-in integer from STDIN.
[1]  -- Current divisor to test
[2]  -- Placeholder for modulus algorithm
[3]  -- Temporary copy of [0] for use for modulus algorithm
[4]  -- Temporary copy of [1] for use for modulus algorithm
[5]  -- Placeholder for modulus algorithm.  Location of remainder at end of loop.
[6]  -- Placeholder for modulus algorithm
[7]  -- Placeholder for modulus algorithm

मापांक एल्गोरिथ्म स्वाभाविक रूप से [2], [3], [6], और [7] ऑपरेशन के अंत में साफ़ करता है। [4] की सामग्री लाइन ४ पर रजिस्टर पेस्ट के साथ अधिलेखित हो जाती है, और [५] शून्य होती है जब [०] [१] से विभाज्य होता है, इसलिए हमें इसे खाली नहीं करना पड़ता है। यदि [५] गैर-शून्य है, तो हम लाइन २३ पर बल-त्याग करते हैं, इसलिए हमें इसके बारे में चिंता करने की आवश्यकता नहीं है।

— गेब्रियल बेनामी
स्रोत

7

05AB1E , 7 बाइट्स

Xµ¹NÖ_½

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

व्याख्या

Xµ       # run until counter is 1
  ¹      # push input
   N     # push iteration counter
    Ö_   # push input % iteration counter != 0
      ½  # if true, increase counter
         # output last iteration

— Emigna
स्रोत

अच्छा, मैं सोच रहा था कि आप इसे 05AB1E में कैसे बनाएंगे।

— मैजिक ऑक्टोपस Urn

7

जेली , 5 बाइट्स

1%@#Ḣ

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

स्पष्टीकरण:

1%@#Ḣ
1  #      Find the first … numbers, counting up from 1, such that
 %@       dividing those numbers into … gives a truthy remainder
    Ḣ     then return the first

यह एक भयावह दुरुपयोग है #; इस कार्यक्रम में बहुत सारे ऑपरेटर हैं, लेकिन लापता ऑपरेटरों के एक टन। #वास्तव में 1किसी कारण से स्पष्ट रूप से दिया जाना चाहता है (अन्यथा यह इनपुट को डिफ़ॉल्ट करने की कोशिश करता है); हालाँकि, प्रोग्राम के इनपुट में डिफ़ॉल्ट रूप से निर्दिष्ट अन्य सभी चीजें नहीं हैं। (उदाहरण के लिए, यदि आप 24 को इनपुट के रूप में देते हैं, तो यह प्रोग्राम पहले 24 नंबर को ढूंढता है जो 24 को विभाजित नहीं करता है, फिर पहला लौटाता है; तरह-तरह का बेकार, लेकिन यह काम करता है।)

धिक्कार है आपको जेली! अजगर आज आपको पीटता है! : डी

— जॉन रेड

एएससीआईआई-केवल:2%@1#

— एरिक आउटोलॉफ़र

7

सी, 32 35 बाइट्स

i;f(x){for(i=1;x%++i<1;);return i;}

संपादित करें: i=1लूप में जोड़ा गया

प्रयोग

main(c,v)char**v;{printf("%d",f(atoi(*++v)));}

पूर्ण कार्यक्रम संस्करण, 64 बाइट्स:

main(c,v)char**v;{*++v;for(c=1;atoi(*v)%++c<1;);printf("%d",c);}

— जियाकोमो गारबेलो
स्रोत

6

सी #, 39 37 बाइट्स

n=>{int i=0;while(n%++i<1);return i;}

मार्टिन को धन्यवाद दो बाइट्स बचाया!

— अल्फी गुडाकरे
स्रोत

मुझे पसंद है जबकि ((n% ++ i)); बेहतर है लेकिन निश्चित रूप से, यह कोड गोल्फ है और 1 बाइट 1 बाइट है।

— जॉन हैमिल्टन 12

क्या वह काम करता है? मुझे नहीं पता था कि 0 का मूल्यांकन स्वचालित रूप से गलत है

— अल्फी गुडाक्रे

आह, मैंने इसे C ++ में आज़माया, हाँ यह C # के साथ काम नहीं करता है।

— जॉन हैमिल्टन

6

पर्ल, 19 बाइट्स

कोड + -pध्वज के 18 बाइट्स ।

$_=$_%++$.?$.:redo

इसे चलाने के लिए:

perl -pE '$_=$_%++$.?$.:redo' <<< 12252240

बहुत विस्तृत विवरण नहीं:
- $.एक विशेष चर है जिसका डिफ़ॉल्ट मान पिछले फ़ाइलखंड की वर्तमान लाइन संख्या है (यहाँ स्टड), इसलिए इनपुट की पहली पंक्ति को पढ़ने के बाद, यह 1 पर सेट होता है
- $_इनपुट रखता है और इसे संक्षेप में मुद्रित किया जाता है अंत में ( -pझंडे के लिए धन्यवाद )।
- redo(उस संदर्भ में) का मानना है कि कार्यक्रम एक लूप में है और वर्तमान पुनरावृत्ति को फिर से करें (केवल $.अलग हो जाएगा क्योंकि यह वृद्धि हुई है)।
- इसलिए अगर हमें सबसे छोटी संख्या (संग्रहीत $.) मिली जो विभाजित नहीं होती है $_, तो हम $_इसे सेट करते हैं, अन्यथा, हम अगले नंबर (धन्यवाद redo) के लिए प्रयास करते हैं ।

— बापू
स्रोत

6

ऑक्टेव / MATLAB, 26 24 बाइट्स

@(n)find(mod(n,1:n+1),1)

find(...,1)1पहले तर्क में वेक्टर के पहले गैर-अक्ष तत्व का सूचकांक ( -based) देता है। पहला तर्क [n mod 1, n mod 2, n mod 3, n mod 4,...,n mod (n+1)]यह है कि हमें +1सूचकांक में जोड़ना होगा, क्योंकि हम परीक्षण करना शुरू करते हैं 1। धन्यवाद -2 बाइट्स के लिए @Giuseppe

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

— flawr
स्रोत

@(n)find(mod(n,1:n+1),1)छोटा है, है ना?

— ग्यूसेप

यह वास्तव में है, धन्यवाद!

— दोष

5

जेली , 6 बाइट्स

%R;‘TḢ

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

स्पष्टीकरण:

                                               Assume 24 is our N
 R      Generate all numbers from 1 to N         [1, 2, 3, 4 .., 24]
  ;‘    Attach N+1 to that list (for cases 1,2)  [1, 2, 3, 4 .., 25]
%       And modulo-divide our input by it
        Yields a list with the remainder         [0, 0, 0, 0, 4 ...]
    T   Return all thruthy indexes               [5, 7, ...]
     Ḣ  Takes the first element of that list -->  5

— steenbergh
स्रोत

मैं जेली नहीं जानता, लेकिन क्या आप रेंज उत्पन्न करने से पहले एन को बढ़ाकर एक बाइट बचा सकते हैं?

— एमिगा

मैं या तो जेली पता @Emigna नहीं;) मैं नहीं दिख रहा है कि कैसे: incrementing यह पहले भी एन 1 के खिलाफ सापेक्ष परीक्षण बनाता है, या शेष बढ़ती जाती [1, 1, 1, 1, 5, ...]।

— steenbergh

ओह समझा। मैंने सोचा था कि एन% रेंज (1, एन + 1) करना संभव हो सकता है, लेकिन अगर यह दोनों उदाहरणों में एन को बढ़ाता है तो यह अच्छा नहीं है।

— एमिगा

5

पर्ल 6 , 17 बाइट्स

{first $_%*,1..*}

कोशिश करो

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  # return the first value
  first

  # where the block's argument ｢$_｣ modulus the current value ｢*｣
  # doesn't return 0 ( WhateverCode lambda )
  $_ % *,
  # ( ｢$_ !%% *｣ would be the right way to write it )

  # from 1 to Whatever
  1 .. *
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

5

05AB1E , 6 बाइट्स

ÌL¹ÑK¬

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

इसके अलावा, यह "लिंक!" ... Kinda ...

ÌL     # Push [1..n+2]
  ¹Ñ   # Push divisors of n.
    K¬ # Push a without characters of b, and take first item.

— जादू ऑक्टोपस Urn
स्रोत

@Zgarb ने उस भाग को याद किया, प्रारंभिक वेतन वृद्धि 2 समस्या को हल करती है।

— मैजिक ऑक्टोपस Urn

1

अच्छा! मैं हमेशा यह भूल जाता हूं कि 05ab1e का एक विभाजक कार्य है :)

— Emigna

5

जेली , 5 बाइट्स

‘ḍ€i0

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

यह काम किस प्रकार करता है

‘ḍ€i0  Main link. Argument: n

‘      Increment; yield n+1.
 ḍ€    Divisible each; test 1, ..., n+1 for divisibility by n.
   i0  Find the first index of 0.

— डेनिस
स्रोत

4

पायथन 2.7.9, 32 बाइट्स

f=lambda n,d=1:n%d>0or-~f(n,d+1)

Ideone पर परीक्षण

पुनरावर्ती संभावित गैर-भाजक को गिनता है d। यह पुनरावर्ती रूप से उत्पादन की तुलना में वृद्धि को कम करने के लिए कम है d। की एक 1बूलियन द्वारा प्राप्त की जाती है True, जो बराबर होती है 1, लेकिन चूंकि d==1हमेशा एक भाजक होता है, इसलिए आउटपुट हमेशा एक संख्या में बदल जाता है।

पाइथन 2.7.9 का उपयोग अनुमति देने के लिए किया जाता है 0or। 2.7.10 से शुरू होने वाले संस्करण 0orएक अष्टक संख्या की शुरुआत के रूप में पार्स करने का प्रयास करेंगे और एक सिंटैक्स त्रुटि दी जाएगी। इसे आइडोन पर देखें ।

— XNOR
स्रोत

3

दरअसल , 7 बाइट्स

;÷@uR-m

इसे ऑनलाइन आज़माएं! (ध्यान दें: यह बहुत धीमा समाधान है, और बड़े परीक्षण मामलों के लिए लंबा समय लगेगा)

स्पष्टीकरण:

;÷@uR-m
;÷       duplicate N, divisors
  @uR    range(1, N+2)
     -   set difference (values in [1, N+1] that are not divisors of N)
      m  minimum

— मेगो
स्रोत

3

हास्केल , 29 बाइट्स

f n=[k|k<-[2..],mod n k>0]!!0

अभिव्यक्ति [k|k<-[2..]]बस एक अनंत सूची बनाती है [2,3,4,5,...]। इस शर्त के साथ mod n k>0हम केवल kसूची में उन लोगों को अनुमति देते हैं जो विभाजित नहीं करते हैं n। !!0केवल सूची में प्रविष्टि (इंडेक्स में प्रविष्टि 0) पहले प्रविष्टि को वापस लाती है ।

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

— flawr
स्रोत

3

दिल्लोग एपीएल , 8 बाइट्स

1⍳⍨0≠⍳|⊢

1⍳⍨ पहले सच की स्थिति

0≠ के शून्य मान

⍳|विभाजित होने पर 1 ... N का विभाजन रहता है

⊢ एन

TryAPL ऑनलाइन!

नोट: यह 1 और 2 के लिए काम करता है क्योंकि 1⍳⍨अगर कोई नहीं मिला है तो उसके तर्क की लंबाई 1 + है।

— एडम
स्रोत

3

जूलिया, 28 बाइट्स

N->findfirst(x->N%x>0,1:N+2)

नोट: चूँकि 1:N+2मेमोरी को आवंटित नहीं किया गया है, इसलिए बड़े Ns के लिए कोई मेमोरी
प्रॉब्लम नहीं है - @flawr N+2मेरे लिए कुछ बाइट्स सेव करें
- @ मार्टिन के सुझाव ने 1 बाइट्स को बचाया

— rahnema1
स्रोत

3

QBIC , 14 बाइट्स

:[a+1|~a%b|_Xb

स्पष्टीकरण:

:      Read the first cmd line param as a number, called 'a'
[a+1|  FOR (b=1 ; b <= a+1; b++) <-- a+1 for cases a = 1 or 2
~a%b   IF A modulo B ( == 0, implicit)
|_Xb   THEN exit the program, printing b
       [IF and FOR implicitly closed by QBIC]

— steenbergh
स्रोत

3

PHP, 30 बाइट्स

for(;$argv[1]%++$i<1;);echo$i;

यदि -rविकल्प के साथ कंसोल से चलाया जाता है (thx @ @ ais523 पर)

php -r 'for(;$argv[1]%++$i<1;);echo$i;' 232792560

32 बाइट्स

<?for(;$argv[1]%++$i<1;);echo$i;

1 बाइट निकालने के लिए @manatwork को धन्यवाद

33 बाइट्स (मूल)

<?for(;$argv[1]%++$i==0;);echo$i;

— आर्थर श्वेदा
स्रोत

3

IIRC, को <?आपकी बाइट काउंट का हिस्सा नहीं बनना है (क्योंकि PHP में कमांड-लाइन मोड है जिसके लिए इसकी आवश्यकता नहीं है)।

3

पुरानी चाल: के <1बजाय की तुलना करें ==0।

— मैनटवर्क

डैंग। मैं पहुँच गया for(;!($argv[1]%$i);$i++);echo$i;। तुम्हारा मेरा स्वाभाविक विकास है। यह मेरा उत्थान है!

— इस्माइल मिगुएल

3

क्यूबिक्स , 14 12 बाइट्स

I2/L/);?%<@O

2 बाइट्स बचाकर मिकी को धन्यवाद।

कोशिश करो

व्याख्या

घन रूप में, कोड है:

    I 2
    / L
/ ) ; ? % < @ O
. . . . . . . .
    . .
    . .

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

— स्मृति सहायक
स्रोत

I2/L/);?%<@Oकम बाइट्स के एक जोड़े के लिए। समान सामान्य प्रक्रिया, बस अलग-अलग पथ

— मिकी 39

2

> <> , 15 +3 = 18 बाइट्स

1\n;
?\1+:{:}$%

इनपुट प्रोग्राम स्टैक पर होने की उम्मीद है, इसलिए -vध्वज के लिए +3 बाइट्स । इसे ऑनलाइन आज़माएं!

— सोक
स्रोत

2

जेलिफ़िश , 12 10 बाइट्स

p\~~|1
 >i

STDIN से इनपुट लेता है और STDOUT को आउटपुट देता है। इसे ऑनलाइन आज़माएं!

मार्टिन एंडर ने 2 बाइट बचाए, धन्यवाद!

व्याख्या

 \~~|
 >i

यह हिस्सा एक फ़ंक्शन है जो इसकी परिभाषा में इनपुट मूल्य का उपयोग करता है।

~|

इस ~-सेल को एक फ़ंक्शन दिया जाता है, इसलिए यह अपने तर्कों को फ़्लिप करता है: इसका बाइनरी फ़ंक्शन "लेफ्ट लॉजिक मोडुलो ( |सही तर्क) " पैदा करता है । जेलिफ़िश में अंतर्निहित मॉडुलो फ़ंक्शन रिवर्स ऑर्डर में अपने तर्क देता है।

  ~~|
  i

इस ~-सेल को एक मान और एक फ़ंक्शन दिया जाता है, इसलिए यह आंशिक अनुप्रयोग करता है: यह बाइनरी फ़ंक्शन "इनपुट ( i) मोडुलो राइट तर्क" का उत्पादन करता है । आइए उस फ़ंक्शन को कॉल करें f ।

 \~~|
 >i

\सेल दो कार्य दिया जाता है, तो यह यात्रा करता है: यह एकल समारोह "वेतन वृद्धि (पैदा करता है >), जब तक समारोह च पिछले और वर्तमान मूल्यों के लिए लागू एक truthy (अशून्य) परिणाम देता है, तो वर्तमान मान"। इसका अर्थ है कि जब तक यह इनपुट विभाजित नहीं करता तब तक तर्क बढ़ जाता है।

p\~~|1
 >i

अंत में, हम इस फ़ंक्शन को प्रारंभिक मूल्य पर लागू करते हैं 1और परिणाम को प्रिंट करते हैं p।

— Zgarb
स्रोत

सबसे छोटी संख्या ज्ञात करें जो N को विभाजित नहीं करती है

नियम

परीक्षण के मामलों

गणितज्ञ, 19 बाइट्स (UTF-8 एन्कोडिंग)

अजगर, 3 बाइट्स

जावास्क्रिप्ट (ईएस 6), 25 23 बाइट्स

परीक्षा

पायथन, 43 36 35 बाइट्स

हेक्सागोनी , 12 बाइट्स

आर, 28 बाइट्स

हास्केल, 26 बाइट्स

ब्रेकीलॉग , 10 बाइट्स

ब्रेकीलॉग , 11 10 बाइट्स

व्याख्या

गाय, 174 बाइट्स

कोड टूटना

व्याख्या

05AB1E , 7 बाइट्स

जेली , 5 बाइट्स

सी, 32 35 बाइट्स

प्रयोग

पूर्ण कार्यक्रम संस्करण, 64 बाइट्स:

सी #, 39 37 बाइट्स

पर्ल, 19 बाइट्स

ऑक्टेव / MATLAB, 26 24 बाइट्स

जेली , 6 बाइट्स

पर्ल 6 , 17 बाइट्स

विस्तारित:

05AB1E , 6 बाइट्स

जेली , 5 बाइट्स

यह काम किस प्रकार करता है

पायथन 2.7.9, 32 बाइट्स

दरअसल , 7 बाइट्स

हास्केल , 29 बाइट्स

दिल्लोग एपीएल , 8 बाइट्स

जूलिया, 28 बाइट्स

QBIC , 14 बाइट्स

PHP, 30 बाइट्स

32 बाइट्स

33 बाइट्स (मूल)

क्यूबिक्स , 14 12 बाइट्स

व्याख्या

> <> , 15 +3 = 18 बाइट्स

जेलिफ़िश , 12 10 बाइट्स

व्याख्या