17

सेवन्स गुणन तालिका को 7 × 0 से 7 × 9 तक देखें:

0, 7, 14, 21, 28, 35, 42, 49, 56, 63

अगर हम सिर्फ अंकों को एक जगह से देखते हैं तो हमें अंक 0 का अंकन 9 के माध्यम से मिलता है:

0, 7, 4, 1, 8, 5, 2, 9, 6, 3

कुछ सकारात्मक दशमलव पूर्णांक N को लेने पर विचार करें और 7 × D के स्थान पर अंक के साथ N के प्रत्येक अंक D को प्रतिस्थापित करें।

उदाहरण के लिए, 15209हो जाता है 75403, क्योंकि 1करने के लिए नक्शे 7, 5के लिए नक्शे 5, 2के लिए नक्शे 4, 0के लिए नक्शे 0, और 9करने के लिए नक्शे 3।

अब हम इस नए दशमलव पूर्णांक के साथ इस प्रक्रिया को दोहराते हैं जब तक कि हम एक चक्र को नहीं देखते हैं, यानी जब तक कि एक पूर्णांक जो हमने पहले ही देखा है वह सामने आता है।

उदाहरण के लिए, 15209हमें चक्र मिलता है

15209 -> 75403 -> 95801 -> 35607 -> 15209 -> repeats...
                                      ^
                                      |
                             cycle restarts here

एक अन्य उदाहरण के रूप 505में, छोटा चक्र है

505 -> 505 -> repeats...
        ^
        |
cycle restarts here

यह पता चला है कि किसी भी एन के लिए इन चक्रों में हमेशा 1 या 4 अलग पूर्णांक होंगे। (मैं यह पता लगाने के लिए आपको छोड़ दूँगा कि ऐसा क्यों है।) क्या दिलचस्प है कि यदि आप एक चक्र में सभी अलग-अलग पूर्णांक योग करते हैं, तो आपको लगभग हमेशा एक दशमलव पूर्णांक मिलता है जिसमें केवल 2's 0' और 's ' होते हैं ।

उदाहरण के लिए, 15209 + 75403 + 95801 + 35607 = 222020।

एन = 505 अपवादों में से एक है। चक्र में एकमात्र पूर्णांक 505 है, इसलिए कुल योग 505 है।

यहाँ N = 1 से 60 के लिए चक्र के योग हैं:

हम इसे सेवन का चक्र योग अनुक्रम कहेंगे।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक दशमलव पूर्णांक एन और प्रिंट या रिटर्न में लेता है, दशमलव में, सात चक्र चक्र योग अनुक्रम के संबंधित शब्द।

उदाहरण के लिए, यदि इनपुट है 95801, तो आउटपुट होना चाहिए 222020। यदि इनपुट है 505, तो आउटपुट होना चाहिए 505। यदि इनपुट है 54, तो आउटपुट होना चाहिए 220।

बाइट्स में सबसे छोटा कोड जीतता है।

— केल्विन के शौक
स्रोत

1

बेशक, यदि आप एक-चक्र से संख्या लेते हैं और उन्हें चार से गुणा करते हैं, तो आप पाएंगे कि वे सभी संख्याएँ देते हैं जिनके केवल अंक 2 और 0. हैं

— पीटर टेलर

1

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

s.uieM*R7jNTTQ

निश्चित नहीं है, हर कोई संख्या में पैटर्न को देखकर परिणाम क्यों निर्धारित करता है। बस प्रक्रिया कर रही है, सर्कल के सभी नंबरों की गणना और उन्हें संक्षेप में छोटा है। कम से कम पायर्थ ;-) में

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

Btw, यह मेरा 200 वाँ कोड-गोल्फ उत्तर है। तो इस पोस्ट ने मुझे गोल्ड कोड-गोल्फ बैज कमाया।

स्पष्टीकरण:

s.uieM*R7jNTTQ   implicit: Q = input number
 .u          Q   apply the following expression to N=Q until it reaches a circle
         jNT        convert N to base 10
      *R7           multiply each digit with 7
    eM              and perform modulo 10 for each number
   i        T       convert digits from base 10 to a number
                    update N
                 .u returns the list of all intermediate results of N, 
                 so we have now all numbers of the circle
s                sum them up

— Jakube
स्रोत

कोड ... इसके लिए प्रतीक्षा करें ... गोल्फ! :) बधाई, और अच्छा उपयोग.u

— FryAmTheEggman

6

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

lambda n:[''.join('02'[x>'0']for x in`n`)+'0',n][set(`n`)<=set('05')]

समारोह का वर्णन करना आसान है:

यदि n में केवल 0 और 5 है, तो यह अपरिवर्तित है।
अन्यथा, n के प्रत्येक अंक को 2 के साथ बदलें, 0 को छोड़कर 0 पर, और 0 से अंत तक डील करें।

गोल्फ में सुधार किया जा सकता है, मैं ज्यादातर विधि साझा करने के लिए पोस्ट कर रहा हूं। देशी रेगेक्स के साथ एक भाषा को एक छोटे से समाधान की अनुमति देनी चाहिए।

फ़ंक्शन का एक वैकल्पिक विवरण है

N में, प्रत्येक अंक को 5 के साथ बदलें, 0 को छोड़कर, 0 के रूप में रहता है
यदि यह बदल गया है n (इसमें 0 या 5 के अलावा एक अंक था), परिणाम को 4 से गुणा करें

— XNOR
स्रोत

4

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

lambda s:s.strip('05')and''.join(`(c>'0')*2`for c in s)+'0'or s

इनपुट तर्क एक स्ट्रिंग होने की उम्मीद है।

— feersum
स्रोत

1

वाह, मुझे नहीं पता था कि stripइस तरह से व्यवहार किया गया था ।

— xsot

चलो, टाइप रूपांतरण (स्ट्रिंग और harr; संख्या) मज़ा का एक बड़ा हिस्सा हैं (यानी कोड लंबाई; ओ)!

— चार्ली

4

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

सभी के समान एल्गोरिथ्म का उपयोग करना:

r_50s-{:~2fe&0}&

परीक्षण सूट। (1 से इनपुट तक सभी परिणाम उत्पन्न करता है।)

व्याख्या

r_      e# Read input and duplicate
50s     e# Push the string "50".
-       e# Remove all '5' and '0' characters from the input.
{       e# If any characters remained in the input...
  :~    e#   Evaluate each digit character to turn it into an integer.
  2fe&  e#   Map (&& 2) over the list. Due to short-circuiting, zeros remain zeros and
        e#   everything else becomes 2.
  0     e#   Push a trailing zero.
}&

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

3

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

Xnor की विधि का उपयोग करना :

n=>/[^05]/.test(n)?`${n}0`.replace(/./g,d=>+d&&2):n

@ बेटर के लिए 3 बाइट्स का धन्यवाद !

व्याख्या

n=>
  (s=n+"").match`[^05]`          // if there are any digits which aren't 5 or 0
    ?s.replace(/\d/g,d=>+d&&2)+0 //     replace every digit except 0 with 2 then add a 0
  :s                             // else return the input unchanged

परीक्षा

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

<input type="number" id="input" value="0" oninput='result.textContent=(

n=>(s=n+"").match`[^05]`?s.replace(/\d/g,d=>+d&&2)+0:s

)(+input.value)' />
<pre id="result"></pre>

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

Naive विधि, 102 बाइट्स

n=>(c=x=>~r.indexOf(x+=m="")?eval(r.join`+`):[...r[++i]=x].map(d=>m+="0741852963"[d])&&c(m))(n,i=r=[])

n=>
  (c=x=>                  // c = recursive function
    ~r.indexOf(           // if we have calculated this number before
      x+=m="")?           // cast x to a string, m = calculated result
        eval(r.join`+`):  //     return the sum of all the calculated numbers
    [...r[++i]=x].map(d=> // else add x to the list of calculated numbers
      m+="0741852963"[d]  // map each digit of x to the "seven" digits
    )&&c(m)               // calculate the value of the result
  )(n,i=r=[])             // r = array of previously calculated values

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

<input type="number" id="input" value="0" oninput='result.textContent=(

n=>(c=x=>~r.indexOf(x+=m="")?eval(r.join`+`):[...r[++i]=x].map(d=>m+="0741852963"[d])&&c(m))(n,i=r=[])

)(+input.value)' />
<pre id="result"></pre>

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

— user81655
स्रोत

51 बाइट्स:n=>/[^05]/.test(n)?`${n}0`.replace(/./g,d=>+d&&2):n

— चार्ली 19

1

40 बाइट्स:n=>n-(s=`${n}`.replace(/[^0]/g,5))?s*4:n

— चार्ली

1

@charlie वाह, यह s*4ट्रिक कमाल की है! मुझे लगता है कि आपको इसे एक अलग उत्तर के रूप में पोस्ट करना चाहिए क्योंकि विधि काफी अलग है और यह मेरी तुलना में बहुत छोटा है। :)

— user81655

ठीक है, मैं विनम्रतापूर्वक; ओ)

— चार्ली

2

गणितज्ञ, 83 77 60 वर्ण

Tr@Union@NestList[FromDigits@Mod[7IntegerDigits@#,10]&,#,4]&

Ungolfed

Tr@
  Union@
   NestList[
    FromDigits@Mod[7 IntegerDigits@#, 10] &,
    #,
    4
   ] &

— shrx
स्रोत

2

जावास्क्रिप्ट (ईएस 5), 40 बाइट्स

n=>(s=`${n}`.replace(/[^0]/g,5))^n?s*4:n

यह x81 द्वारा वर्णित वैकल्पिक दृष्टिकोण का उपयोग करके, उपयोगकर्ता81655 समाधान का विकास है ।

व्याख्या

4-चक्र में एक गैर-शून्य अंक का योग हमेशा 20 होता है, क्योंकि अंक चक्र या तो 1 → 7 → 9 → 3, या 2 → 4 → 8 → 6, या 5 → 5 → 5 → 5 के माध्यम से होता है। इसलिए हर ऐसे अंक को 5 के साथ बदलने से योग नहीं बदलता है।

उस प्रतिस्थापन क्रिया को 4-चक्र को 1-चक्र से अलग करने के लिए पुन: उपयोग किया जाता है - यदि प्रतिस्थापन परिणाम इनपुट से अलग है, तो यह 4-चक्र है, अन्यथा यह 1-चक्र है।

NB: टेम्पलेट स्ट्रिंग `${n}`केवल पठनीयता के लिए है, (n+'')इसकी लंबाई समान है।

— चार्ली
स्रोत

नो रीगेक्सप - 47 बाइट्स:n=>(s=[...`${n}`].map(d=>+d&&5).join``)^n?s*4:n

— चार्ली 16

0

सेड, 26 बाइट्स

/[^05]/{s/[^0]/2/g;s/$/0/}

(एक और "2 के दृष्टिकोण से बदलें" पर जाएं।)

उदाहरण

echo '500' | sed '/[^05]/{s/[^0]/2/g;s/$/0/}' → 500

echo '501' | sed '/[^05]/{s/[^0]/2/g;s/$/0/}' → 2020

— चार्ली
स्रोत

0

पर्ल 6 , 68 55 53 36 33 बाइट्स

{[+] $^a,{[~] $^b.comb.map: {'0741852963'.comb[$_]}}...^{$++*?/$a/}} # 68

{$_=@=$_.comb;[~] (@$_,(|.map(2*?+*),0))[$_⊈qw<0 5>]} # 55

{[~] ($_=@=$_.comb)⊆qw<0 5>??@$_!!(|.map(2*?+*),0)} # 53

{/^<[05]>+$/??$_!!S:g/./{2*?+$/}/~0} # 36

{m/^<[05]>+$/||S:g/./{2*?+$/}/~0} # 33

यह निश्चित रूप से ऐसा करने का गलत तरीका है, अगर संख्या केवल 5एस और 0एस के होते हैं, तो यह एक मैच ऑब्जेक्ट लौटाएगा, अन्यथा यह सब कुछ बदल देता है लेकिन 0ए के साथ 2, और 0अंत में संलग्न करता है।
(यदि आप इसे एक के रूप में उपयोग करते हैं तो मैच ऑब्जेक्ट एक नंबर की तरह व्यवहार करेगा)

यद्यपि यह गलत कर रहा है, लेकिन यह कॉल करके दुर्लभ संख्याओं को इंगित करना आसान बनाता है gist विधि ।

उपयोग:

# give it a name
my &code = {...}

.say for (0..60,505,15209).flat.map({ code($_).gist.fmt: '%4s' }).rotor(1,10 xx 6,:partial)

( ｢0｣)
(  20   20   20   20  ｢5｣   20   20   20   20  200)
( 220  220  220  220  220  220  220  220  220  200)
( 220  220  220  220  220  220  220  220  220  200)
( 220  220  220  220  220  220  220  220  220  200)
( 220  220  220  220  220  220  220  220  220 ｢50｣)
( 220  220  220  220 ｢55｣  220  220  220  220  200)
(｢505｣)
(222020)

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

सात का चक्र योग क्रम

चुनौती

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

स्पष्टीकरण:

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

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

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

व्याख्या

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

व्याख्या

परीक्षा

Naive विधि, 102 बाइट्स

गणितज्ञ, 83 77 60 वर्ण

जावास्क्रिप्ट (ईएस 5), 40 बाइट्स

व्याख्या

सेड, 26 बाइट्स

उदाहरण

पर्ल 6 , 68 55 53 36 33 बाइट्स