शॉटगन संख्या

45

शॉटगन संख्या बल्कि एक सरल परिभाषा लेकिन कुछ रोचक संरचना के साथ एक दृश्य है। प्राकृतिक संख्याओं से शुरू करें:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...

अब सभी संख्याओं को 2 से विभाज्य सूचक स्थानों पर ले जाएं , उन्हें जोड़े में समूहित करें, और प्रत्येक जोड़ी में संख्याओं को स्वैप करें:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, ...
   ^     ^     ^     ^      ^       ^       ^  
    <--->       <--->        <----->         <----
1, 4, 3, 2, 5, 8, 7, 6, 9, 12, 11, 10, 13, 16, ...

अब 3 से विभाज्य सूचकांकों के साथ ऐसा करें :

1, 4, 3, 2, 5, 8, 7, 6, 9, 12, 11, 10, 13, 16, ...
      ^        ^        ^           ^          
       <------>          <--------->           
1, 4, 8, 2, 5, 3, 7, 6, 10, 12, 11, 9, 13, 16, ...

और फिर 4 , 5 , 6 , और इतने पर:

1, 4, 8, 2, 5, 3, 7, 6, 10, 12, 11, 9, 13, 16, ...
1, 4, 8, 6, 5, 3, 7, 2, 10, 12, 11, 14, 13, 16, ...
1, 4, 8, 6, 12, 3, 7, 2, 10, 5, 11, 14, 13, 16, ...
1, 4, 8, 6, 12, 14, 7, 2, 10, 5, 11, 3, 13, 16, ...
...

K ऐसे चरणों के बाद , पहले k + 1 नंबर तय हो जाएंगे। तो हम शॉटगन संख्याओं के अनंत अनुक्रम को परिभाषित कर सकते हैं क्योंकि कश्मीर को अनंत तक जाने देने की सीमा है । पहले 66 नंबर हैं:

1, 4, 8, 6, 12, 14, 16, 9, 18, 20, 24, 26, 28, 22, 39, 15, 36, 35, 40, 38, 57, 34, 48, 49, 51, 44,
46, 33, 60, 77, 64, 32, 75, 56, 81, 68, 76, 58, 100, 55, 84, 111, 88, 62, 125, 70, 96, 91, 98, 95,
134, 72, 108, 82, 141, 80, 140, 92, 120, 156, 124, 94, 121, 52, 152, 145, ...

मजेदार तथ्य: केवल प्राकृतिक संख्याओं की अनुमति देकर प्राप्त किए जाने के बावजूद, इस क्रम में कोई भी अपराध नहीं है।

चुनौती

पूर्णांक को देखते हुए n > 0, nवें शॉटगन संख्या का पता लगाएं । आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेते हुए एक प्रोग्राम या फ़ंक्शन लिख सकते हैं, आउटपुट को वापस कर सकते हैं या इसे STDOUT (या निकटतम विकल्प) पर प्रिंट कर सकते हैं।

यह कोड गोल्फ है, इसलिए सबसे छोटा सबमिशन (बाइट्स में) जीतता है।

लीडरबोर्ड

यह मेरे विचार से अधिक उत्तर प्राप्त कर रहा है, साथ ही साथ कई लोग एक ही भाषा में प्रतिस्पर्धा कर रहे हैं। इसलिए यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

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

code-golf  number  sequence  permutations 
— मार्टिन एंडर
स्रोत
1
यह मजेदार तथ्य पागल है, यह एल्गोरिथ्म सभी अपराधों को अंत तक हिला देता है? या अन्य प्राकृतिक संख्याएं हैं जो भी घटित नहीं होंगी?
— डेवोन पार्सन्स
1
@DevonParsons हाँ, यह "अंत तक" सभी तरह के फेरबदल करता है। लेकिन मुझे लगता है कि अन्य नंबर भी गायब हैं। ऐसा लग रहा है 10, 21, 25और 30, या तो नहीं दिखाई देते हैं, उदाहरण के लिए।
— मार्टिन एंडर
3
यह एक परियोजना यूलर प्रश्न की तरह लगता है। मुझे नहीं लगता कि यह है ... लेकिन शायद यह होना चाहिए।
— कोरी ओगबर्न
9
सामान्य तौर पर, kवें पुनरावृत्ति पर, kसरणी में वें तत्व को 2kवें स्थान पर स्थानांतरित कर दिया जाता है , और 2kवें पुनरावृत्ति तक फिर से छुआ नहीं जाएगा , जिस समय पर यह 4kवें स्थान पर स्थानांतरित हो जाता है , विज्ञापन infinitum। एक प्राइम को तब तक ट्रांसपोज़ नहीं किया जाता है जब तक कि उसकी बारी नहीं आती है, इसलिए बोलने के लिए, इसलिए सभी प्राइम आगे बढ़ जाते हैं। लेकिन हम आसानी से निर्दोष पीड़ितों की एक सूची बना सकते हैं, जो पहले तत्व को पुनरावृत्ति 2 और प्रत्येक विषमता में ट्रांसपोज़ किया जा सकता है। सूची इस प्रकार है: 2, 3, 5, 7, 10, 11, 13, 21, 17, 19, 30, 23, 27, 25, 29, 31, 45, 42, 37, 54, 41, 43, 65, 65 ...
— थेरोफाइल
3
@ शर्लक 9 किया! यदि अनुमोदित किया जाता है, तो यह https://oeis.org/A266679 होगा । नववर्ष की शुभकामना!
— थियोफाइल 18

जवाबों:

5

पायथ, १ ९ २२

u-G*H^_!%GH/GHrhQ2Q

@ पीटरटायलर के गोल्फस्क्रिप्ट उत्तर का एक काफी भोला कार्यान्वयन ।

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

यह उसी चाल का उपयोग करता है जबकि थोड़ी देर के लूप को एक मोड़ में बदलने के लिए जैसा कि नीचे अन्य पायथ प्रोग्राम है।

u+G**H!%GHty%/GH2rhQ2Q

@ Sp3000 के एल्गोरिथ्म की एक भोली प्रति पायथ में अनुवादित।

आप इसे यहाँ ऑनलाइन आज़मा सकते हैं

लूप का अनुकरण करने के लिए कम (अजगर का नाम गुना के लिए) का उपयोग करता है। यह range(input, 2)प्यूथ के लिए बाहर काम करता है , जिसमें पर गणना करता है range(2, input)[::-1]। अन्य Pyth से संबंधित golfs का इस्तेमाल किया जाता notहै के बजाय <2और का उपयोग कर y'सांख्यिक तर्कों के मूल्य को दोगुना करने की विधा छिपा रहा है।

— फ्राइअमईएग्गमैन को दर्शाता है
स्रोत
21

> <>, 52 45 बाइट्स

Esolangs पृष्ठ के लिए> <>

i:&&:&1-?vn;
2*1-*+20.>:&:&%1(&:&*{:}&:1-&,2%

चारों ओर नकल और चलती तत्वों की एक बहुत है, कई modulo और गुणन की जरूरत के लिए धन्यवाद। तर्क बिल्कुल मेरे पायथन समाधान के समान है ।

STDIN से एक कोड बिंदु के माध्यम से इनपुट लेता है , जैसे "!" = 33 -> 75।

— Sp3000
स्रोत
10
और आपको सबसे अजीब इनपुट प्रारूप के लिए पुरस्कार मिला: P
— Caridorc
+1 वैसे भी, चिंता न करें :)
— कारिडोरक
@ Sp3000 IMO इसे केवल एक के रूप में गिनना चाहिए
— SuperJedi224
@ SuperJedi224 वास्तव में, इस मेटा पोस्ट के अनुसार स्पष्ट -vरूप से तीन के रूप में गिना जाता है: /
— Sp3000
17

पायथन 2, 58 बाइट्स

i=n=input()
while~-i:n+=(n%i<1)*i*(n/i%2*2-1);i-=1
print n

अन्य उत्तरों में से अधिकांश की तरह, विचार यह है कि पीछे की ओर काम करना है।

चलो कदम k+1कदम कहते हैं i, ताकि कदम पर iसभी गुणकों की iअदला-बदली हो। हमें दो सरल टिप्पणियों की आवश्यकता है:

  • यदि विभाज्य है , तो nसरणी में स्थिति केवल चरण में स्वैप की जाती है ,ini
  • यह बताने के लिए कि क्या आप स्वैप में कम संख्या या उच्च संख्या हैं, को देखें n/i mod 2। यदि यह 1 है तो आप निम्न संख्या (और स्वैप करेंगे), अन्यथा आप उच्च संख्या हैं (और नीचे स्वैप करेंगे)।

यह हमें पीछे की ओर काम करने के लिए एक एल्गोरिथ्म देता है। आइए इसे 6 के साथ आज़माएं, अंतिम चरण (चरण i = 6) से शुरू :

Step 6: Position 6 swaps with position 12 (6 is divisible by 6, 6/6 = 1 == 1 mod 2)

तो अब हम जानते हैं कि संख्या 12 स्थिति से आई है। तब:

Step 5: No swap (12 not divisible by 5)
Step 4: Position 12 swaps with position 16 (12 is divisible by 4, 12/4 = 3 == 1 mod 2)

तो अब हम जानते हैं कि यह 16 से पहले आया था। आखिरकार:

Step 3: No swap (16 not divisible by 3)
Step 2: Position 16 swaps with position 14 (16 divisible by 2, 16/2 = 8 == 0 mod 2)

चूंकि यह पहला चरण है (याद रखें k+1), हम कर रहे हैं और संख्या जो कि स्थिति 6 में समाप्त होती है मूल रूप से स्थिति 14 से आती है, यानी 6 वीं बन्दूक संख्या 14 है।

तो अब अजगर स्पष्टीकरण के लिए:

i=n=input()             Read input, and store into i (step) and n (position)
while~-i:               while i-1 != 0:, or since we're descending with i this is just while i>1:
  n+=                   Add to the current position...
    (n%i<1)*            1* whatever's next if n is divisible by i, otherwise 0* (i.e. nothing)
    i*                  How many positions n might go up/down
    (n/i%2*2-1)         n/i%2 tell us higher/lower, *2-1 maps 0 or 1 to -1 (down) or +1 (up)
  i-=1                  Decrement the step number
print n                 Output
— Sp3000
स्रोत
लिखने के लिए दिलचस्प तरीके i-1के रूप में~-i
— mbomb007
6
@ mbomb007: सहमत। चतुर हालांकि, इसका एक ही अर्थ है लेकिन बाद में एक स्थान की आवश्यकता को समाप्त करता है while। अच्छा काम, Sp3000।
— एलेक्स ए।
सबसे कम मैं इसे u+G**H!%GHty%/GH2rhQ2Q
— अजगर
1
@FryAmTheEggman, Sp3000, क्या आप में से कोई भी यह पोस्ट करने वाला नहीं है?
— मार्टिन एंडर
@ मार्टिनबटनर ने मूल रूप से इसे पोस्ट नहीं किया था जैसा कि मैंने महसूस किया कि यह एक प्रतिलिपि का बहुत अधिक था। मैं इसे अभी के लिए एक CW उत्तर के रूप में पोस्ट करूँगा।
— फ्राईअमईएग्मन
6

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

n#k|mod k(2*n)<1=k-n|mod k n<1=k+n|k>0=k
s n=foldr((.).(#))id[2..n]n

शायद आगे गोल्फ, विशेष रूप से पहली पंक्ति। यह परिभाषित करता है एक समारोह sहै कि लेता है nऔर रिटर्न nवें बन्दूक संख्या।

map s [1..66]
[1,4,8,6,12,14,16,9,18,20,24,26,28,22,39,15,36,35,40,38,57,34,48,49,51,44,46,33,60,77,64,32,75,56,81,68,76,58,100,55,84,111,88,62,125,70,96,91,98,95,134,72,108,82,141,80,140,92,120,156,124,94,121,52,152,145]

व्याख्या

हेल्पर फ़ंक्शन #दो संख्याओं में लेता है nऔर k, और kप्रत्येक nवें नंबर पर जोड़ी स्वैप ऑपरेशन लागू करके परिभाषित की गई सूची में वें नंबर को लौटाता है । उदाहरण के लिए, इसे n = 4पैदावार के साथ पहले 20 नंबरों पर लागू करना :

map (4#) [1..20]
[1,2,3,8,5,6,7,4,9,10,11,16,13,14,15,12,17,18,19,24]

का परिणाम दूसरे क्रम के फ़ंक्शन द्वारा s nसूची ("तह") को कम करके प्राप्त किया जाता है, जो एक संख्या और एक फ़ंक्शन (शुरुआत में पहचान समारोह ) लेता है, और एक फ़ंक्शन लेता है और लेता है और वापस लौटता है । उदाहरण के लिए, मामले में सूची में एक फ़ंक्शन को कम किया जाता है जो लेता है और वापस लौटता है । केवल आधार मामले के लिए की जरूरत है , जहां सूची खाली है। अंत में, हम इस कार्य को इनपुट देते हैं , वें बन्दूक संख्या प्राप्त करते हैं ।[2..n](.).(#)mfidkf (m # k)n = 4[2,3,4]kid (4 # (3 # (2 # k)))idn = 1k = nn

— Zgarb
स्रोत
5

रूबी, 92 बाइट्स

def s(d,n)
d==1?n:s(d-1,n%d==0?n+(n%(d*2)==0?-d :d):n)
end
n=ARGV[0].to_i
print s(n,n).to_s

मेरा पहला कोड गोल्फ प्रयास। किसी अन्य उत्तर पर आधारित नहीं।

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

84 बाइट्स

n=ARGV[0].to_i
d=n
while d>1
n+=(n%d==0?(n%(d*2)==0?-d :d):0)
d-=1
end
print n.to_s

अन्य उत्तरों को देखने और यह महसूस करने के बाद कि पुनरावृत्त समाधान संभव है।

— सोलोमन स्लो
स्रोत
2
1. बदलें: अपने 84 बाइट समाधान के लिए कुछ सुधार ARGVकरने के लिए $*जादू वैश्विक। 2. to_sअनावश्यक है। 3. एक अलग लाइन पर असाइन dकरने के बजाय n, बस d=n=...एक चरित्र को शेव करने के लिए करें। अपने पहले गोल्फ के लिए अच्छा काम! :)
— दरवाज़े
1
मैं पूरा कार्यक्रम कहाँ से पूछ रहा हूँ? "आप एक कार्यक्रम या फ़ंक्शन लिख सकते हैं ...";) (यह कोड-गोल्फ चुनौतियों के लिए भी डिफ़ॉल्ट है , लेकिन मैं आमतौर पर पूर्णता के लिए शामिल करता हूं।)
— मार्टिन एंडर
@ Doorknob के सुझावों में जोड़ने के लिए, n+=लाइन पर कोष्ठक के दो सेट अनावश्यक हैं, और दोनों घटनाओं को ==0सुरक्षित रूप से बदला जा सकता है <1।
— पीटर टेलर
5

पायथन 2, 97 79 चार्ट

g=lambda n,k:n>1and g(n-1,k-(k%n<1)*n*(-1)**(k/n%2))or k
n=input()
print g(n,n)

यह प्रत्येक इंडेक्स के लिए निर्धारित करता है कि पीछे की ओर संख्या का पीछा करते हुए सही मूल्य। एल्गोरिथ्म स्वतंत्र खोजा गया था।

संपादित करें: अब यह केवल nपहले नंबर के बजाय वें नंबर को प्रिंट करता है n। बेशक एक पुनरावृत्ति दृष्टिकोण कम होगा, लेकिन मैं Sp3000 का कोड कॉपी नहीं करना चाहता।

— Jakube
स्रोत
हाँ, मुझे लगता है कि हर कोई इस पर अभिसार करेगा। मुझे यह g(i,i)विशेष रूप से कष्टप्रद लग रहा था ...
— Sp3000
2
printबयान के कारण भाषा को पायथन 2 के रूप में चिह्नित किया जाना चाहिए ।
— mbomb007 15
@ mbomb007 ने इसे ठीक किया।
— जक्यूब
4

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

1#i=i
s#i|i`mod`(2*s)==0=(s-1)#(i-s)|i`mod`s==0=(s-1)#(i+s)|1<2=(s-1)#i
p n=n#n

उपयोग: p 66जो आउटपुट145

समझाने के लिए अधिक नहीं: फ़ंक्शन #पुनरावर्ती रूप iसे चरण की स्थिति में बन्दूक की संख्या की गणना करता है s। चरण की p nस्थिति पर संख्या लौटाता है ।nn

— nimi
स्रोत
ओह, मैंने अपना जवाब प्रस्तुत करने से पहले आपका जवाब नहीं देखा। लगता है जैसे हमारे पास काफी अलग दृष्टिकोण हैं।
— जगरब
4

के, 41 बाइट्स

{{x+$[y!x;0;$[2!_x%y;y;-y]]}/[x;|2+!x-1]}

 / apply to an int
 {{x+$[y!x;0;$[2!_x%y;y;-y]]}/[x;|2+!x-1]} 42
111
 / apply to 1 through 66
 {{x+$[y!x;0;$[2!_x%y;y;-y]]}/[x;|2+!x-1]}'1+!66
1 4 8 6 12 14 16 9 18 20 24 26 28 22 39 15 36 35 40 38 57 34 48 49 51 44 46 33 60 77 64 32 75 56 81 68 76 58 100 55 84 111 88 62 125 70 96 91 98 95 134 72 108 82 141 80 140 92 120 156 124 94 121 52 152 145
  • {...} लैम्ब्डा, x और y निहित प्रथम और द्वितीय तर्क हैं
  • $[b;t;f] ternary ऑपरेटर, क्रमशः t / f के बाद b का मूल्यांकन करता है
  • b!a a modulo b
  • _ फर्श, विभाजन के परिणाम को एक इंट में डाल देता है
  • % विभाजन
  • {...}/[x;y] प्रधान {...} x के साथ और सूची y पर लागू, f [f [.. f [f [x; y0]; y1] के बराबर है; .. yn-1]; yn]
  • | उलटा
  • ! iota फ़ंक्शन, n-1 के माध्यम से सूची 0 उत्पन्न करता है
— mollmerx
स्रोत
4

आम लिस्प, 113 91

(पुनरावृति: 91)

(defun s(n)(do((r n(1- r)))((= r 1)n)(if(= 0(mod n r))(incf n(* r(if(oddp(/ n r))1 -1))))))

(मूल, पुनरावर्ती: 113)

(defun s(n &optional(r n))(cond((= r 1)n)((= 0(mod n r))(s(+ n(* r(if(oddp(/ n r))1 -1)))(1- r)))(t(s n(1- r)))))

उदाहरण

पुनरावर्ती संस्करण के साथ:

(trace s)
(s 10)

  0: (S 10)
    1: (S 20 9)
      2: (S 20 8)
        3: (S 20 7)
          4: (S 20 6)
            5: (S 20 5)
              6: (S 15 4)
                7: (S 15 3)
                  8: (S 18 2)
                    9: (S 20 1)
                    9: S returned 20
         ...
    1: S returned 20
  0: S returned 20

टेस्ट

पुनरावृत्त संस्करण के लिए जाँच और उपाय:

(let ((list '(1 4 8 6 12 14 16 9 18 20 24 26 28 22 39 15 36 35 40 38 57 34 48 49 51 44
              46 33 60 77 64 32 75 56 81 68 76 58 100 55 84 111 88 62 125 70 96 91 98 95
              134 72 108 82 141 80 140 92 120 156 124 94 121 52 152 145)))
  (time
   (loop for r in list
         for n from 1
         always (= r (s n)))))

 => T

Evaluation took:
  0.000 seconds of real time
  0.000000 seconds of total run time (0.000000 user, 0.000000 system)
  100.00% CPU
  807,160 processor cycles
  32,768 bytes consed
— कोर निपात
स्रोत
4

गणितज्ञ, ५३ ४ ९ बाइट्स

(For[i=n=#,n>1,--n,If[n∣i,i+=Mod[i,2n]2-n]];i)&

मैंने अपने संदर्भ कार्यान्वयन को गोल्फ करने का फैसला किया। ∣"विभाजित", और 3 बाइट्स के लिए मायने रखता है के लिए यूनिकोड प्रतीक है। अन्यथा, यह सभी के समान एल्गोरिथ्म का उपयोग करता है।

यह एक अनाम फ़ंक्शन को परिभाषित करता है जो nएकल पैरामीटर के रूप में लेता है और nवें शॉटगन नंबर को वापस करता है ।

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

GolfScript, 27 वर्ण

~.,(~%{):i\.@%!~)1$i/?i*-}/

व्याख्या

यदि परिवर्तनों के बाद f(i, n)स्थिति में मूल्य है , तो हमारे पास हैni-1

f(1, n) = n
f(i, n) = f(i - 1, n % i == 0 ? (((n / i - 1) ^ 1) + 1) * i : n)  for i > 1

जहां ^बिटकॉइन xor को दर्शाता है; इनपुट दिया n, हम गणना करना चाहते हैं f(n, n)।

एक पुनरावर्ती कार्य से लूप में रूपांतरण निर्बाध है; क्या दिलचस्प है जिस तरह से

n % i == 0 ? (((n / i - 1) ^ 1) + 1) * i : n

फिर से लिखा जा सकता है। अधिक स्पष्ट दृष्टिकोण यह कहना है कि यह होना चाहिए

n + (n % i == 0 ? i : 0) * g(n / i)

कुछ के लिए g। स्पष्ट रूप से और के gबीच वैकल्पिक रूप से, जैसा कि स्थिति वैकल्पिक रूप से ऊपर और नीचे स्वैप करती है; चूंकि (क्योंकि स्वैप होता है ), हमारे पास है1-1g(1) = 112

n + (n % i == 0 ? i : 0) * -1**(1 + n / i)

जहां **घातांक को दर्शाता है। अंतिम बचत इस प्रकार से लिखी जाती है

n - i * (n % i == 0 ? -1 : 0)**(n / i)

विच्छेदन

~             # Evaluate input to get n
.,(~%{        # For n-1 downto 1...
  ):i         #   Let i be that value + 1, so for i = n downto 2...
  \.@%!       #   Find n % i == 0 ? 1 : 0
  ~)          #   Negate
  1$i/?       #   Raise to the power of n/i
  i*-         #   Multiply by i and subtract
}/
— पीटर टेलर
स्रोत
यह देखते हुए कि आपके पास सबसे कम जीएस और सीजेएम उत्तर हैं, क्यों नहीं सबसे छोटा पायथ उत्तर भी है? u-G*H^_!%GH/GHrhQ2Qयदि आप इसे स्वयं पोस्ट नहीं करना चाहते हैं, तो मुझे बताएं / सीडब्ल्यू उत्तर में जोड़ें।
— फ्राईअमईएग्गमैन 15
@FryAmTheEggman, मुझे CJam में बहुत अभ्यास नहीं किया जा सकता है, लेकिन मैं इसे कम से कम अधिक-या-कम पढ़ सकता हूं। मुझे इस बात का कोई सुराग नहीं है कि आपकी टिप्पणी में अजगर क्या कहता है, हालांकि संदर्भ से मुझे लगता है कि यह इस उत्तर का एक हिस्सा है। इसलिए यह सबसे अच्छा है कि आप इसे पोस्ट करें, क्योंकि आप इसके बारे में सवालों के जवाब दे सकते हैं।
— पीटर टेलर
4

सीजेएम, 24 बाइट्स

l~__(,f-{_Imd!~)\#I*-}fI

ऑनलाइन डेमो

यह मेरे गोल्फस्क्रिप्ट उत्तर का एक पोर्ट है , मार्टिन के सीजेएम उत्तर से लूप उधार लेना और सीजेएम के divmodऑपरेटर का शोषण करना । ( मैंने कहा कि यह उपयोगी होगा!)।

— पीटर टेलर
स्रोत
4

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

n->(i=n;while~-i!=0 n+=(n%i<1)*i*(n÷i%2*2-1);i-=1;end;n)

यह एक अनाम फ़ंक्शन बनाता है जो एकल तर्क लेता है nऔर nवें शॉटगन नंबर को लौटाता है । इसे कॉल करने के लिए, इसे एक नाम दें, जैसे f=n->(...)।

उदाहरण:

julia> for i = 1:10 println(f(i)) end
1
4
8
6
12
14
16
9
18
20

वर्तमान में यह @ Sp3000 के भयानक पायथन उत्तर पर आधारित है । मैं जल्द ही इस पर दोबारा विचार करूंगा क्योंकि जूलिया में ऐसा करने का एक छोटा तरीका होना चाहिए जो मैंने यहां किया है। किसी भी इनपुट का स्वागत है, हमेशा की तरह।

— एलेक्स ए।
स्रोत
3

सीजेएम, 28 27 बाइट

तो यह थोड़ा शर्मनाक है ... इसे पोस्ट करने से पहले, मैंने खुद इस पर गोल्फ लगाने की कोशिश की और CJam में 30 बाइट्स हासिल की। मौजूदा जवाबों में से किसी ने भी अभी तक ऐसा नहीं किया है। इस बीच मैं तीन और बाइट्स भी शेव करने में कामयाब रहा। वहाँ है एक टिप्पणी में एक छोटी Pyth समाधान, लेकिन छोटे कुछ भी नहीं एक जवाब में नियुक्त किया गया है, तो ये रहा। हो सकता है कि यह एपीएल / जे लोगों को थोड़ा कठिन प्रयास करने के लिए प्रेरित करता है (या कोई वास्तव में पाइथ समाधान पोस्ट करता है), इससे पहले कि मुझे अपना जवाब स्वीकार करना पड़े। ;)

l~__(,f-{_I_+%_+I-_zI=*+}fI

इसका परीक्षण यहां करें।

व्याख्या

l~                          "Read input N and eval.";
  __(,                      "Duplicate twice, create range [0 1 2 ... N-2].";
      f-                    "Subtract each from N, giving [N N-1 N-2 ... 2].";
        {               }fI "For each element, storing the element in I.";
         _I_+%_+I-          "Compute 2(N % 2I)-I - the shuffling offset";
                  _zI=      "Check that this offset is ±I.";
                      *+    "Multiply the offset by this boolean and update to N.";
— मार्टिन एंडर
स्रोत
3

जे, 34 32 बाइट्स

   (]+[*(1-~2*2|%~)*0=|)/@(_1}2+i.)

   ((]+[*(1-~2*2|%~)*0=|)/@(_1}2+i.)) every 1+i.20  NB. running with inputs 1..20
1 4 8 6 12 14 16 9 18 20 24 26 28 22 39 15 36 35 40 38

इसे थोड़ा और गोल्फ करने की कोशिश करेंगे और बाद में कुछ स्पष्टीकरण देंगे।

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

— randomra
स्रोत
1

रूबी, 57 47 बाइट्स

यह अनिवार्य रूप से है Sp3000 के अजगर समाधान (साथ XNOR के सुझाव ) रूबी में अनुवाद किया। मैं शायद यह कुछ स्थानों में नीचे गोल्फ सकता है, हालांकि।

->n{n.downto(2).map{|i|n+=i*(n/i%2-~-n/i%2)};n}
— Sherlock9
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.