कुज़नेत्सोव का अनुक्रम

18

कुज़नेत्सोव का अनुक्रम

(I made the name up, don't bother with Wikipedia or Google)

किसी भी संख्या को देखते हुए n > 0, संख्या rका उल्टा प्रतिनिधित्व करें n। अंतिम परिणाम शून्य होने तक Iterate करें, नीचे दिए गए ऑपरेशन के द्वारा पुनरावृत्ति या अपनी पसंद की कार्यप्रणाली का उपयोग करके फ़ंक्शन में प्रत्येक पुनरावृत्ति का परिणाम पारित करें:

  • यदि r > nउस पुनरावृत्ति के लिए परिणाम है r % n।
  • यदि n > rउस पुनरावृत्ति के लिए परिणाम है n % r।
  • यदि n % r = 0या r % n = 0, आप पुनरावृत्ति को समाप्त करते हैं।

प्रत्येक निष्पादन का मध्यवर्ती परिणाम लें और उन्हें अंतिम उत्तर के लिए एक सरणी में संग्रहीत करें। प्रारंभिक संख्या nअनुक्रम का हिस्सा नहीं है, न ही है 0; उदाहरणों को सब कुछ थोड़ा और स्पष्ट करना चाहिए।

चलिए एक उदाहरण के माध्यम से चलते हैं n=32452345।

54325423 % 32452345 = 21873078 # r > n, uses r % n
87037812 % 21873078 = 21418578 # r > n, uses r % n
87581412 % 21418578 = 1907100  # r > n, uses r % n
1907100 % 17091 = 9999         # n > r, uses n % r
9999 % 9999 = 0                # r % n = n % r = 0, terminated

Result: [21873078, 21418578, 1907100, 9999]

एक और उदाहरण n=12345678:

87654321 % 12345678 = 1234575 # r > n, uses r % n
5754321 % 1234575 = 816021    # r > n, uses r % n
816021 % 120618 = 92313       # n > r, uses n % r
92313 % 31329 = 29655         # n > r, uses n % r
55692 % 29655 = 26037         # r > n, uses r % n
73062 % 26037 = 20988         # r > n, uses r % n
88902 % 20988 = 4950          # r > n, uses r % n
4950 % 594 = 198              # n > r, uses n % r
891 % 198 = 99                # r > n, uses r % n
99 % 99 = 0                   # r % n = n % r = 0, terminated

Result: [1234575, 816021, 92313, 29655, 26037, 20988, 4950, 198, 99]

एक अंतिम उदाहरण n=11000:

11000 % 11 = 0 # n % r = 0, terminated

Result: []

यह कोड-गोल्फ सबसे कम बाइट-काउंट जीत है।

code-golf  sequence 
— जादू ऑक्टोपस Urn
स्रोत
2
क्या परिणाम मुद्रित हो सकते हैं क्योंकि गणना होती है या इसे एक सरणी का निर्माण करना चाहिए?
— 21
मुझे लगता है कि डिफ़ॉल्ट आउटपुट नियम लागू होते हैं, इसलिए आप आउटपुट फॉर्मार्ट (सरणी, रिक्त स्थान से अलग प्रदर्शित संख्या) चुन सकते हैं ...
— लुइस मेंडू
@ Flp.Tkc मैं आउटपुट को प्रतिबंधित नहीं करूँगा, जब तक कि आवश्यक संख्याएँ प्रदर्शित न हों।
— मैजिक ऑक्टोपस Urn
2
बस ध्यान दें कि किसी संख्या का 'रिवर्स' केवल किसी विशेष आधार के संबंध में सार्थक है।
— डेविड कॉनरैड
1
@ Sp3000 की तरह; सिवाय इसके कि आपको हर पुनरावृत्ति को उल्टा करने की आवश्यकता है। आप केवल एक संख्या को गणना के माध्यम से थ्रेड करते हैं, दो नहीं, और दूसरे को हमेशा पहले के विपरीत होने के लिए लेते हैं।
— tomsmeding

जवाबों:

6

PowerShell v2 +, 89 बाइट्स

param($n)for(){$r=-join"$n"["$n".length..0];if(!($n=(($r%$n),($n%$r))[$n-gt$r])){exit}$n}

Iterative समाधान। लंबा इसलिए क्योंकि किसी सरणी को उलटने का कोई आसान तरीका नहीं है, इसलिए हम इसे स्टोर करने के लिए इसे पीछे की तरफ से इंडिकेट करते हैं $r। फिर $nअगले दौर के लिए उपयुक्त मोडुलो को बाहर निकालने और पुन: संग्रहित करने के लिए एक छद्म टर्नररी । हालांकि, यदि परिणाम शून्य है, तो इसका मतलब है कि !($n...)इच्छा होगी $true, इसलिए हम exitइसके बजाय $n। संख्या को पाइपलाइन पर छोड़ दिया जाता है और (संक्षेप में) एक सरणी के रूप में वापस आ जाता है, लेकिन एक एनकैप्सुलेटिंग पाइपलाइन के बिना या परिणामों को एक चर में सहेजने के बिना, डिफ़ॉल्टWrite-Output बीच एक नई चिपक जाती है।

इसे ऑनलाइन आज़माएं! (हां, मृत गंभीर।)
पॉवरशेल अब TIO पर है! आप इसे एक या दो बार दे सकते हैं, क्योंकि PowerShell स्टार्टअप के लिए एक जानवर है, लेकिन अब आप, हाँ , आप अपने ब्राउज़र में PowerShell कोड को सत्यापित कर सकते हैं!

— AdmBorkBork
स्रोत
गह, मुझे इसके लिए और उसी दृष्टिकोण से हराया। अच्छा!
— रिश्वतखोर
6

पर्ल, ४३ 38 + 1 = 39 बाइट्स

-nझंडे के साथ भागो

say while$_=($;=reverse)>$_?$;%$_:$_%$

इसे ऑनलाइन आज़माएं! दो गैर-रिक्त उदाहरण शामिल हैं।

स्पष्टीकरण चार्ट

-n: पूरे कार्यक्रम को लपेटता है while(<>){ ... ;}। यह उपरोक्त कोड को निम्न पंक्ति में बदल देता है while(<>){say while$_=($;=reverse)>$_?$;%$_:$_%$;}:। ध्यान दें, अनुगामी में एक अर्धविराम जोड़ा गया है $, इसलिए यह अब चर का एक उदाहरण बन जाता है $;। whileलूप की स्थिति में , <>स्वचालित रूप से इनपुट की एक पंक्ति पढ़ता है और इसे $_चर में बचाता है । तो अब देखते हैं कि इंटरप्रेटर बाहरी whileलूप के अंदर क्या पढ़ता है :

say while$_=($;=reverse)>$_?$;%$_:$_%$;
[op][mod][         condition          ]     #While is acting as a statement modifier.
                                            #It evaluates the operation as long as the condition is truthy.
            ($;=reverse)>$_?$;%$_:$_%$;     #The meat of the program: a ternary operation
            ($;=reverse)                    #The reverse function takes $_ as a parameter by default, and reverses the value.
                                            #The value returned by reverse is stored in the variable $;
                        >$_                 #A condition asking if $% is greater than $_.  Condition of the ternary operation
                           ?$;%$_           #If true, then return $; modulo $_
                                 :$_%$;     #If false, return $_ modulo $;
         $_=                                #Assign the result of the ternary operation back into $_
                                            #If $_ is non-zero, then the condition is true, and while will evaluate the operation
say                                         #Implicitly takes the $_ variable as parameter, and outputs its contents

मूल कोड, पोस्टर के लिए सहेजा गया: 43 + 1 = 44 बाइट्स

say$_=$%>$_?$%%$_:$_%$%while$_-($%=reverse)
— गेब्रियल बेनामी
स्रोत
$%>$_?$%%$_:$_%$%क्या आपने $%इस लाइन के लिए केवल उद्देश्य पर चर का चयन किया था?
— tomsmeding
लगभग - मैं भी बयान से पहले अंतिम चरित्र के लिए एक गैर-अल्फ़ान्यूमेरिक चरित्र का उपयोग करके 1 बाइट बचाता हूं, इसलिए मुझे व्हाट्सएप की आवश्यकता नहीं है। इसके अलावा - बहुत ज्यादा, हाँ
— गेब्रियल बेनामी
5

पायथ, 13 12 बाइट्स

t.u|%F_S,s_`

@TheBikingViking के लिए धन्यवाद।

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

मेरा पुराना कोड:

W
W=Q%F_S,s_`

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

स्पष्टीकरण:

t.u|%F_S,s_`NNNQ  implicit Ns and Q at the end
               Q  start with N = Q (Q = input number)
        ,         create a pair with the numbers
         s_`N        convert N to string -> reverse-> convert to int
             N       and N
       S          sort
      _           reverse
    %F            fold by modulo
   |          N   or N (if the result is zero use N instead to stop)
 .u               apply this ^ procedure until a value repeats
                  print all intermediate values
 t                except the first one (the original number)
— Jakube
स्रोत
12 बाइट्स: t.u|%F_S,s_<backtick>। टेस्ट
— TheBikingViking
1
@BikingViking धन्यवाद, यह वास्तव में चालाक है।
— जकूबे
4

जेली , 15 14 13 बाइट्स

,ṚḌṢṚ%/
ÇÇпḊ

TryItOnline

कैसे?

,ṚḌṢṚ%/ - Link 1, iterative procedure: n
,       - pair n with
 Ṛ      - reverse n
  Ḍ     - undecimal (int of digit list)
   Ṣ    - sort
    Ṛ   - reverse
     %/ - reduce with mod

ÇÇпḊ - Main link: n
  п  - collect while
 Ç    - last link as a monad is truthy
Ç     -     last link as a monad
    Ḋ - dequeue (remove the input from the head of the resulting list)
— जोनाथन एलन
स्रोत
4

जेली , 13 12 बाइट्स

,ṚḌṢṚ%/Ṅß$Ṡ¡

यह एक विवादास्पद लिंक / फ़ंक्शन है जो STDOUT पर प्रिंट करता है।

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

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

,ṚḌṢṚ%/Ṅß$Ṡ¡  Monadic link. Argument: n

,Ṛ            Pair n and its reversed digit list.
  Ḍ           Convert the digit list into an integer.
   ṢṚ         Sort and reverse.
     %/       Reduce by modulo. Result: m
          Ṡ¡  Do sign(m) times:
       Ṅß$    Print with a newline and call the link recursively.
— डेनिस
स्रोत
के लिए पाद लेख क्या है? यदि कोड निकाल दिया जाता है तो 0
— लुइस मेंडू
यह सही है। 0 समारोह है, जो दुभाषिया प्रिंट अगर यह खारिज नहीं कर रहा है की वापसी मूल्य है। इस मेटा चर्चा के अनुसार , इसकी अनुमति है।
— डेनिस
4

पायथन 2, 92 87 81 73 61 बाइट्स

पुनरावर्ती समाधान:

def f(n):
    r=int(`n`[::-1]);x=min(r%n,n%r)
    if x:print x;f(x)

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

Iterative समाधान: (भी 61 बाइट्स )

n=input()
while n:r=int(`n`[::-1]);n=min(r%n,n%r);print n/n*n

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

— mbomb007
स्रोत
आपके द्वारा दिया गया पुनरावृत्ति समाधान वास्तव में 59 बाइट्स है, लेकिन मुझे यकीन नहीं है कि यह वैध है क्योंकि यह इनपुट प्रिंट करता है। यदि यह है, तो आप बस कर के 2 बाइट्स के गोल्फ कर सकते हैं while n:। अन्यथा, आप इसे 61 बाइट्स के साथ कर सकते हैं ।
— फ्लिपकैक
3

MATL , 16 बाइट्स

`tVPUhSPZ}\tt]xx

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

व्याख्या

`         % Do...while
  t       %   Duplicate. Takes input implicitly in the first iteration
  VPU     %   Transform the number at the top of the stack by reversing its digits
  hSPZ}   %   Concatenate the two numbers into an array, sort, reverse, split the
          %   array: this moves the smaller number to the top
  \       %   Modulo
  t       %   Duplicate. The original copy is left on the stack for displaying, 
          %   and the duplicate will be used for computing the next number
  t       %   Duplicate. This copy will be used as loop condition: exit if 0
]         % End
xx        % Delete the two zeros at the top. Implicitly display rest of the stack
— लुइस मेंडो
स्रोत
2

PHP, 78 बाइट्स

function a($n){while(($r=strrev($n))&&($n=$r>$n?$r%$n:$n%$r)!=0){echo$n.' ';}}
— Wahooka
स्रोत
2

बैच, 140 बाइट्स

@echo off
set/pn=
:l
set/am=n,l=0
:r
set/al=l*10+m%%10,m/=10
if %m% gtr 0 goto r
set/an=l%%n%%l+n%%l%%n
if %n% gtr 0 echo %n%&goto l

एसटीडीआईएन पर इनपुट लेता है और अनुक्रम को अलग लाइनों पर आउटपुट करता है। बैच में सशर्त कथन हैं (जो कुछ हद तक क्रियात्मक हैं) लेकिन कोई सशर्त अभिव्यक्ति नहीं है, इसलिए यह %गणना करने के लिए आसान है ( एस को उद्धृत करने के बावजूद ) r%n%r(जो कि r%nअगर n<rया शून्य के बराबर है तो n>r) और n%r%n(जो n%rअगर n>rया शून्य के बराबर है तो n<r) उन्हें एक साथ।

— नील
स्रोत
2

मैथमेटिका, 68 बाइट्स

सुझाव देने के बजाय ग्रेग मार्टिन का धन्यवाद :FixedPointListNestWhileList

FixedPointList[Mod[(r=IntegerReverse@#)~Max~#,r~Min~#]&,#][[2;;-4]]&

सबसे कम मैं अपना मूल समाधान FixedPointList73 बाइट्स के साथ प्राप्त कर सकता था:

NestWhileList[Mod[(r=IntegerReverse@#)~Max~#,r~Min~#]&,#,#!=0&][[2;;-2]]&
— ngenisis
स्रोत
1
ध्यान दें कि आपके पास सही समाप्ति स्थिति नहीं है (उदाहरण इनपुट का प्रयास करें 11000)। आप अपने अंतिम पैराग्राफ में वर्णित तकनीक पर स्विच करके इसे प्राप्त कर सकते हैं। लेकिन मैं नहीं दिख रहा है से छुटकारा पाने के लिए कैसे Restया Mostइस तरह से। दूसरी ओर, FixedPointList[ Mod[(r = IntegerReverse@#)~Max~#, r~Min~#] &, #][[2 ;; -4]] &केवल 68 बाइट्स है एक बार रिक्त स्थान हटा दिए जाने के बाद (त्रुटियों की एक जोड़ी, nbd फेंकता है)।
— ग्रेग मार्टिन
मैंने किसी तरह अपने आप को आश्वस्त किया था कि {a,b,c,d}[[2;;-4]]खाली सूची के बजाय स्पैन जैसा कोई त्रुटि देगा (मैंने संभवतः कॉमा का उपयोग किया था ;;)। कुछ सीखा।
— 2
आप उस पूरे न्यूनतम / अधिकतम व्यापार से छुटकारा पा सकते हैं Sort:FixedPointList[-Mod@@Sort@-{#,IntegerReverse@#}&,#][[2;;-4]]&
— मार्टिन एंडर
1

जावास्क्रिप्ट, 72 70 बाइट्स

f=(s,...o)=>(u=s>(z=[...s+''].reverse().join``)?s%z:z%s)?f(u,...o,u):o

console.log(...[32452345, 12345678, 11000].map(x=>f(x)))
.as-console-wrapper{max-height:100%!important}
स्निपेट का विस्तार करें

संपादित:

-2 बाइट्स : स्प्रेड ऑपरेटर स्ट्रिंग कॉन्टेक्शन का इंतजार करता है।

— वाशिंगटन गाइड्स
स्रोत
1

आर, 126 117 बाइट्स

x=scan();while(x){y=sort(c(x,as.double(paste(rev(el(strsplit(c(x,""),""))),collapse=""))));if(x<-y[2]%%y[1])print(x)}

अफसोस की बात है कि एक संख्या ( as.double(paste(rev(el(strsplit(c(x,""),""))),collapse="")))) को उलट देना बहुत चिंताजनक है। आराम बहुत आसान है। sortअप्रत्यक्ष रूप से जांच करने के लिए उपयोग करता है जो अधिक है।

बाकी सीधा है, यह तब तक लूपिंग करता है x=0, और सभी चरणों को प्रिंट करता है।

— JAD
स्रोत
1

सी, 87 बाइट्स

t;r;f(n){while(t=n){r=0;while(t)r=10*r+t%10,t/=10;n=r>n?r%n:n%r;if(n)printf("%d ",n);}}

tपलटने के लिए अस्थायी है। आंतरिक लूप r1 अंक को बाईं ओर शिफ्ट करता है और tजब तक यह समाप्त नहीं होता है तब तक अंतिम अंक जोड़ता है। आउटपुट पहली पुनरावृत्ति के बाद है और केवल अगर यह गैर-शून्य है ताकि पहले और अंतिम आइटम को प्रदर्शित न किया जा सके।

अधूरा और उपयोग:

t;r;
f(n){
  while (t = n){
    r = 0;
    while (t)
      r = 10*r + t%10,
      t /= 10; 
    n = r>n ? r%n : n%r;
    if(n)
      printf("%d ",n);
  }
}
— कार्ल नेफ
स्रोत
0

मैथेमेटिका, 64 बाइट्स

NestWhileList[#2~If[#<=#2,Mod,#0]~#&[IntegerReverse@#,#]&,#,#>0&]&

उपरोक्त कोड एक शुद्ध फ़ंक्शन का प्रतिनिधित्व करता है जो एक एकल इनपुट लेता है, और कुज़नेत्सोव अनुक्रम लौटाता है। गणितज्ञ के बारे में वास्तव में सुंदर बात यह है कि आप शुद्ध कार्यों की परत डाल सकते हैं ... मुझे कोड समझाने की अनुमति दें;);

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

#2~If[#<=#2,Mod,#0]~#&[IntegerReverse@#,#]&

कोड IntegerReverse@#बस आर उत्पन्न करता है, उलटा मूल्य। कोड #2~If[#<=#2,Mod,#0]~#&एक फ़ंक्शन है जो दो इनपुट लेता है और या तो मॉड ऑपरेशन करता है, या इनपुट्स को उलट देता है और खुद को फिर से कॉल करता है। इसे लिखने का एक और तरीका है If[#<=#2, Mod, #0][#2, #]&, या इसे इस तरह से एक नियमित कार्य के रूप में लिखा जा सकता है:k[a_, b_] := If[a <= b, Mod, k][b, a]

— जे। एंटोनियो पेरेज़
स्रोत
0

रैकेट 180 बाइट्स

(let p((n n)(ol'()))(let*((v reverse)(o modulo)
(r(string->number(list->string(v(string->list(number->string n))))))
(m(if(> n r)(o n r)(o r n))))(if(= m 0)(v ol)(p m(cons m ol)))))

Ungolfed: 

(define (f n)
  (let loop ((n n)
             (ol '()))
    (let* ((r (string->number
               (list->string
                (reverse
                 (string->list
                  (number->string n))))))
           (m (if (> n r)
                  (modulo n r)
                  (modulo r n))))
      (if (= m 0)
          (reverse ol)
          (loop m (cons m ol))))))

परिक्षण: 

(f 32452345)
(f 12345678)

ouput: 

'(21873078 21418578 1907100 9999)
'(1234575 816021 92313 29655 26037 20988 4950 198 99)
— rnso
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.