विभाजन की लकीर

31

हम kएक संख्या की विभाज्यता लकीर nको सबसे छोटे गैर-ऋणात्मक पूर्णांक के रूप में परिभाषित कर सकते हैं, जो kकि n+kविभाज्य नहीं है k+1।

चुनौती

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

उदाहरण:

n=13:
13 is divisible by 1 
14 is divisible by 2 
15 is divisible by 3 
16 is divisible by 4 
17 is not divisible by 5

द डिविसिबिली स्ट्रीक ऑफ 13है4

n=120:
120 is divisible by 1 
121 is not divisible by 2

द डिविसिबिली स्ट्रीक ऑफ 120है1

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

n      DS
2      1
3      2
4      1
5      2
6      1
7      3
8      1
9      2
10     1
2521   10

अधिक परीक्षण मामलों को यहां पाया जा सकता है ।

टिप्पणियाँ

नियम

  • आप मान सकते हैं कि इनपुट 1 से अधिक है।

स्कोरिंग

कोड-गोल्फ : सबसे कम स्कोर के साथ सबमिशन जीतता है।

code-golf  number  division 
— ओलिवर
स्रोत
मेरा सुझाव है कि "सबसे छोटा सकारात्मक पूर्णांक" को "सबसे छोटा गैर-पूर्णांक पूर्णांक" में बदलना। यह चुनौती को बिल्कुल भी नहीं बदलता है, लेकिन वर्तमान विवरण के साथ, इसका तात्पर्य है कि हमें 1 से विभाज्यता की जांच करने की आवश्यकता नहीं है (जिसे हमें तकनीकी रूप से इसकी आवश्यकता नहीं है)। या तो, या आप विवरण से 1 जांच द्वारा विभाजन को हटा सकते हैं।
— तेहपर्स
सबसे छोटा धनात्मक पूर्णांक 1 है, और k + 12 है, जहां kसबसे छोटा धनात्मक पूर्णांक है। निपिक के लिए क्षमा करें।
— तेहर्स
क्या यह सबसे छोटा kनहीं है जो विभाजित नहीं होता है n-1?
— पाओलो एम्बरमन
@ Pa @loEbermann n=7जहां लें k=3: n-1द्वारा विभाज्य है k।
— ओलिवर
आह, मैं चूक गया +1।
— पाओलो एबरमन

जवाबों:

17

जावा 8, 44 42 41 39 बाइट्स

पार किया 44 अभी भी नियमित है 44 ;;

n->{int r=0;for(;~-n%--r<1;);return~r;}

-2 बाइट्स थैंक्स टू @LeakyNun ।
-1 बाइट @ थैंथलॉकर को धन्यवाद ।
-2 बाइट्स @ नवीन को धन्यवाद ।

स्पष्टीकरण:

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

n->{                 // Method with integer as parameter and return-type
  int r=0;           //  Result-integer (starting at 0)
  for(;~-n%--r<1;);  //  Loop as long as `n-1` is divisible by `r-1`
                     //   (after we've first decreased `r` by 1 every iteration)
  return~r;          //  Return `-r-1` as result integer
}                    // End of method
— केविन क्रूज़सेन
स्रोत
1
— लीकी नून
1
41 बाइट्स सिर्फ लीकेन के सुझाव से एक बाइट का मुंडन।
— TheLethalCoder
2
— नेवई
3

क्यूबिक्स , 17 बाइट्स

)uUqI1%?;)qUO(;/@

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

Cubified

    ) u
    U q
I 1 % ? ; ) q U
O ( ; / @ . . .
    . .
    . .
  • I1 इनपुट और भाजक के साथ स्टैक सेटअप करें
  • %? मॉड और परीक्षण करें
    • ;)qU)uqUयदि 0 परिणाम और वेतन वृद्धि इनपुट और भाजक को हटा दें। वापस आने के लिए रास्ते के बारे में एक चक्कर%
    • /;(O@ यदि 0 नहीं है, तो ड्रॉप रिजल्ट, डिस्क्रिमेंट डिवाइसर, आउटपुट और एग्जिट

देखो इसे चलाते हैं

— मिकट
स्रोत
2

स्विफ्ट 4 , 56 बाइट्स

यह पूर्ण फ़ंक्शन है f, जिसमें पूर्णांक पैरामीटर होता iहै जो आउटपुट प्रिंट करता है।

func f(i:Int){var k=0;while(i-1)%(k+1)<1{k+=1};print(k)}

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

स्विफ्ट 4 , 56 बाइट्स

यह एक अनाम फ़ंक्शन है, जो परिणाम देता है।

{var k=0;while($0-1)%(k+1)<1{k+=1};return k}as(Int)->Int

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

टेस्ट सूट की जाँच करें!

— मिस्टर एक्सकोडर
स्रोत
2

डीसी , 28 बाइट्स

1si[1+dli1+dsi%0=M]dsMxli1-p

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

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

— brhfl
स्रोत
2

जे, 17 बाइट्स

[:{.@I.>:@i.|i.+]

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

मुझे लगता है कि अभी भी यहां गोल्फ के लिए जगह है।

स्पष्टीकरण (अपुष्ट)

[: {.@I. >:@i. | i. + ]
                 i. + ]  Range [n,2n)
                 i.       Range [0,n)
                    +     Added to each
                      ]   n
         >:@i. | i. + ]  Divisibility test
         >:@i.            Range [1,n+1)
               |          Modulo (in J, the arguments are reversed)
                 i. + ]   Range [n,2n)
    {.@I.                Get the index of the first non-divisible
       I.                 Indices of non-zero values
    {.                    Head

टोपी ( [:) यह सुनिश्चित करने के लिए है कि जे अंतिम क्रिया का इलाज नहीं करता है ({.@I. हुक के हिस्से के रूप ) का ।

इस उत्तर के बारे में केवल एक ही प्रकार की अजीब बात यह है कि I.वास्तव में प्रत्येक गैर-शून्य संख्या के सूचकांक को उस संख्या के मूल्य के रूप में कई बार दोहराता है। जैसे

   I. 0 1 0 2 3
1 3 3 4 4 4

लेकिन इससे कोई फर्क नहीं पड़ता कि हम पहला इंडेक्स वैसे भी चाहते हैं (और चूंकि i.एक आरोही रेंज देता है, हमें पता है कि पहला इंडेक्स सबसे छोटा मूल्य होगा)।

अंत में, यहां एक बहुत ही छोटा सा प्रमाण है कि यह केवल चेक अप डिवीजन की जांच करने के लिए वैध है n।

हम विभाज्यता की जांच करना शुरू करते हैं 1 | n, इसलिए यह मानते हुए कि यह लकीर बहुत दूर तक जाती है, एक बार जब हम nहमारे पास विभाजन की जाँच करने के लिए पहुँच जाते हैं n | 2n - 1जो कभी भी सच नहीं होगा ( 2n - 1 ≡ n - 1 (mod n))। इसलिए, लकीर वहीं खत्म हो जाएगी।

— गोभी
स्रोत
2

x86 मशीन कोड, 16 बाइट्स

49                 dec    ecx        ; decrement argument
31 FF              xor    edi, edi   ; zero counter

                Loop:
47                 inc    edi        ; increment counter
89 C8              mov    eax, ecx   ; copy argument to EAX for division
99                 cdq               ; use 1-byte CDQ with unsigned to zero EDX
F7 FF              idiv   edi        ; EDX:EAX / counter
85 D2              test   edx, edx   ; test remainder
74 F6              jz     Loop       ; keep looping if remainder == 0

4F                 dec    edi        ; decrement counter
97                 xchg   eax, edi   ; move counter into EAX for return
C3                 ret               ;  (use 1-byte XCHG instead of 2-byte MOV)

उपरोक्त फ़ंक्शन रजिस्टर nमें , एकल पैरामीटर लेता है ECX। यह इसकी विभाज्यता लकीर की गणना करता है k, और EAXरजिस्टर के माध्यम से देता है । यह 32-बिट फास्टकल कॉलिंग कन्वेंशन के अनुरूप है , इसलिए यह Microsoft या Gnu कंपाइलर्स का उपयोग करके C कोड से आसानी से कॉल करने योग्य है।

तर्क बहुत सरल है: यह सिर्फ 1 से शुरू होने वाला पुनरावृत्त परीक्षण करता है। यह कार्यात्मक रूप से यहां के अधिकांश अन्य उत्तरों के समान है, लेकिन आकार के लिए हाथ से अनुकूलित है। वहाँ अच्छा 1-बाइट निर्देश के बहुत सारे, सहित INC, DEC, CDQ, औरXCHG । विभाजन के लिए कठोर कोडेड ऑपरेंड्स हमें थोड़ा चोट पहुंचाते हैं, लेकिन बहुत अधिक नहीं।

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

— कोडी ग्रे
स्रोत
2

PHP , 34 बाइट्स

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

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

काफी सरल। प्रत्येक मान को बढ़ाते हुए प्रत्येक लूप के विभाजन (मॉड) को चेक करता है, जब संख्या विभाज्य नहीं होती है तो आउटपुट।

— Xanderhall
स्रोत
1

SOGL V0.12 , 8 बाइट्स

]e.-ē⁴I\

यह कोशिश करो!

ऐसी भाषा के लिए बुरा नहीं है जो पूरी तरह से अलग तरह की चुनौतियों के लिए बनी है।

स्पष्टीकरण:

]         do .. while top of the stack is truthy
 e          push the variable E contents, by default user input
  .-        subtract the input from it
    ē       push the value of the variable E and then increase the variable
     ⁴      duplicate the item below one in the stack
      I     increase it
       \    test if divides
            if it does divide, then the loop restarts, if not, outputs POP which is `e-input`
— dzaima
स्रोत
1

गणितज्ञ, 40 बाइट्स

Min@Complement[Range@#,Divisors[#-1]-1]&

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

गणितीय दृष्टिकोण, n + k k + 1 से विभाज्य है यदि और केवल यदि n-1 k + 1 से विभाज्य है। और n-1 n से विभाज्य नहीं है, इसलिए Range@#पर्याप्त संख्या है।

मूल रूप से मैं उपयोग करने का इरादा रखता हूं Min@Complement[Range@#,Divisors[#-1]]-1&, लेकिन यह भी काम करता है।

— user202729
स्रोत
जब मैं tio से सबमिशन का उपयोग करता हूं तो कैप्चा क्यों दिखाई देता है?
— user202729
1
क्योंकि आपने टाइप किया (कॉपी-एंड-पेस्ट) यह बहुत जल्दी। यह TIO के बारे में नहीं है।
— लीक
1

जूलिया 0.6.0 (47 बाइट्स) (38 बाइट्स)

n->(i=1;while isinteger(n/i) i+=1;n+=1 end;i-1)

n->(i=1;while n%i<1 i+=1;n+=1end;i-1)

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

9 बाइट्स काट दिए गए थे

— Goysa
स्रोत
2
आम तौर पर एक "ऑनलाइन प्रयास करें" लिंक लोगों को हेडर, फुटर और तर्कों के कुछ संयोजन को परिभाषित करके कोड की कोशिश करने की अनुमति देता है , जिसका अर्थ है कि प्ले बटन दबाने से आउटपुट मिलता है।
— पीटर टेलर
@PeterTaylor एक शुद्ध अनुमान के अनुसार, मैंने इसे इस तरह चलाने की कोशिश की , और मेरे आश्चर्य के लिए यह काम किया। मैं ओपी को परीक्षण योग्य संस्करण के साथ संपादित करने की सलाह देता हूं।
— श्री एक्सकोडर
46 बाइट्स (एक स्थान को हटाते हुए):n->(i=1;while isinteger(n/i) i+=1;n+=1end;i-1)
— श्री एक्सकोडर
एक और शुद्ध अनुमान है कि इसे 38 बाइट्स में नीचे किया जा सकता है:n->(i=1;while n%i<1 i+=1;n+=1end;i-1)
— श्री एक्सकोडर
@PeterTaylor क्षमा करें इसे भूल गए!
— गोयसा
1

Batch, 70 bytes

@set/an=%1-1,i=0
:l
@set/ai+=1,r=n%%~i
@if %r%==0 goto l
@echo %i%

All this is doing is finding the largest i such that LCM(1..i) divides n-1.

— Neil
स्रोत
1

एसीटो , 28 27 बाइट्स

[;`%
I)@]
iIk2I(D(
rk[(&Xpu

अगर मुझे बाहर नहीं जाना है तो मैं एक बाइट बचा सकता हूं।

स्पष्टीकरण:

हम तीन स्टैक का उपयोग करते हैं: बाएं स्टैक 2 पर शुरू होने वाला एक काउंटर रखता है, दाईं ओर दी गई संख्या (या इसके वेतन वृद्धि) रखती है, केंद्र स्टैक का उपयोग मोडुलो संचालन करने के लिए किया जाता है। हम, निश्चित रूप से, एक स्टैक में सब कुछ कर सकते हैं, लेकिन इस तरह हम बाहरी स्टैक को "चिपचिपा" होने के लिए सेट कर सकते हैं (मान जो पॉपप किए गए हैं वे वास्तव में हटाए नहीं गए हैं) और खुद को कई दोहराव संचालन बचा सकते हैं। यहाँ विधि विस्तार से है:

एक पूर्णांक पढ़ें, इसे बढ़ाएं, वर्तमान स्टैक को चिपचिपा बनाएं, और स्टैक को बाईं ओर रखें (और खुद को) "स्थानांतरित करें":

iI
rk[

बाईं ओर एक और स्टैक पर जाएं, शाब्दिक 2 को धक्का दें, इस स्टैक को भी चिपचिपा बनाएं। कोड में इस स्थिति को याद रखें ( @), और फिर से केंद्र स्टैक के लिए एक मान और "ले जाएँ"।

  @]
  k2
   (

अब हम परीक्षण करते हैं: क्या शीर्ष दो नंबरों का मोडुलो 0 नहीं है? यदि ऐसा है, तो अंत में कूदें, अन्यथा दाईं ओर एक स्टैक पर जाएं, वेतन वृद्धि करें, और मान को और हमें बीच में धकेलें। फिर बाएं स्टैक पर जाएं, इसे बढ़ाएं, और उस चिह्न पर वापस जाएं जिसे हमने पहले सेट किया था।

[;`%
I)
    I(
    &

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

      D(
     Xpu
— L3viathan
स्रोत
1

एफ #, 86 बाइट्स 84 बाइट्स

let s n = 
    let rec c n1 d r=if n1%d=0 then c(n1+1)(d+1)(r+1)else r
    c n 1 0

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

संपादित करें: ओलिवर से -2 वर्ण

— व्लादिस्लाव खापिन
स्रोत
PPCG में आपका स्वागत है! क्या आपके कार्यक्रम में गतिरोध है? आप टीआईओ का उपयोग कर सकते हैं , जिसमें एक ऑनलाइन एफ # इंटरप्रेटर है। इसके अलावा, व्हाट्सएप को हटा सकते हैं r = if?
— ओलिवर
1
@ ओलिवर धन्यवाद, मैंने TIO के लिंक को बदल दिया, इसलिए अब आप वास्तव में इसका परीक्षण करने के लिए तर्क पारित कर सकते हैं। :)
— व्लादिस्लाव खापिन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.