चुनौती का वर्णन

चलो एक सकारात्मक पूर्णांक लेते हैं n, rev(n)इन दो नंबरों के अंतर के पूर्ण मूल्य को प्राप्त करने और प्राप्त करने के लिए इसके अंकों को उल्टा करते हैं: |n - rev(n)|(या abs(n - rev(n)))।

उदाहरण:

n = 5067 
rev(n) = 7605
|n - rev(n)| = |5067 - 7605| = |-2538| = 2538

इस ऑपरेशन को पर्याप्त रूप से कई बार दोहराने के बाद, अधिकांश नंबर बन जाएंगे 0(इस प्रकार लूप को समाप्त कर दिया जाएगा ...)

5067 -> 2538 -> 5814 -> 1629 -> 7632 -> 5265 -> 360 -> 297 -> 495 -> 99 -> 0

... हालाँकि कुछ संख्याएँ (जैसे 1584) एक अनंत लूप में फंस जाती हैं:

1584 -> 3267 -> 4356 -> 2178 -> 6534 -> 2178 -> 6534 -> 2178 -> 6534 -> ...
                        ^ infinite loop starts here

आपका काम यह निर्धारित करना है कि क्या एक पूर्णांक एक अनंत लूप में फंस जाता है।

इनपुट विवरण

एक सकारात्मक पूर्णांक।

आउटपुट विवरण

एक सत्य मान ( True, 1) यदि संख्या अनंत लूप में फंस जाती है, तो एक मिथ्या मान ( False, 0)।

ट्रेलिंग जीरो को ommited होना चाहिए। यानी rev(5020) = 205।
याद रखें कि यह कोड-गोल्फ है , इसलिए अपने कोड को यथासंभव छोटा बनाएं!
प्रासंगिक क्रम: A072140

code-golf number-theory

— shooqie
स्रोत

सम्बंधित। सम्बंधित।

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

एक दिलचस्प नोट: 2 के लूपिंग अवधि के साथ एक मनमाने ढंग से लंबे पूर्णांक का निर्माण करना संभव है, जैसा कि A072141 पर टिप्पणियों में वर्णित है । यह विधि अन्य अवधियों के समान है, जैसे 12, 14, 17 और 22।

— mbomb007

18

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

4 बाइट्स FryAmTheEggman के लिए धन्यवाद

uas_`

परीक्षण सूट।

सत्य मान लूप में संख्याओं में से एक है।

झूठी कीमत है 0।

व्याख्या

uas_`      Input:Q
uas_`GGQ   Implicit filling of variables.

u      Q   Set G as Q: do this repeatedly until result seen before: Set G as
 a             the absolute difference of
     G             G
    `              convert to string
   _               reverse
  s                convert to integer
      G        and G

— लीक नन
स्रोत

स्वत: भरण चर का अच्छा उपयोग!

— FryAmTheEggman

1

* दुरुपयोग - - - - -

— लीक नून

वह काम कैसे करता है, जो किसी को पाइथ नहीं जानता है?

— घातक

3

कैसे ASCII रेंज में अभी तक बहुत कम है pyth ._

— डाउनगोट

3

@Downgoat क्योंकि यह अजगर है।

— लीक नून

11

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

Nest[Abs[#-IntegerReverse@#]&,#,#]<1&

बस रिवर्स / घटाव परिवर्तन nबार इनपुट पर लागू होता है nऔर फिर जाँचता है कि परिणाम क्या है 0। 10nलूप तक पहुंचने के लिए कभी भी अधिक कदम नहीं उठाए जा सकते हैं, क्योंकि परिवर्तन अंकों की संख्या में वृद्धि नहीं कर सकता है, और 10nसंख्याओं की तुलना में कम अंकों की संख्या नहीं है n। यह कैसे कम करने के लिए डेनिस का प्रमाण देखें n।

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

10

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

ṚḌạµ¡

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

पृष्ठभूमि

इस का उपयोग करता है @ MartinEnder ऊपरी बाध्य है की 10n पुनरावृत्तियों और निम्नलिखित टिप्पणियों।

कर रहे हैं 9 × 10 ^{1 - कश्मीर} धनात्मक पूर्णांक n के साथ कश्मीर अंक।
एक संख्या और उसके रिवर्स का अंतर हमेशा 9 का एक बहु होता है , इसलिए उनमें से केवल 10 ^{k - 1} पहले पुनरावृत्ति के बाद हो सकते हैं।
गुणकों के, अधिक से अधिक 1/10 अगले चरण में एक अंकों (शुरुआत के लिए, यह सब आरंभ और समाप्ति ही अंकों के साथ, और मोटे तौर पर दो बार कई के रूप में करता है, तो पहले अंक को न तो खो देंगे 1 और न ही एक 9 ) ऐसा है, इसमें अधिकतर 9 × 10 ^{k - 2} लगते हैं या तो एक लूप दर्ज करें या एक अंक खो दें।
एक ही तर्क को k - 1 अंक और इतने पर परिणामी पूर्णांक के रूप में लागू करते हैं , यह सबसे अधिक 9 × 10 ^{k - 2} + 9 × 10 ^{k - 2} +… ^- 10 ^{k - 1} it n पुनरावृत्तियों को लूप में प्रवेश करने के लिए लेता है पहुंच ० ।

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

ṚḌạµ¡  Main link. Argument: n

   µ¡  Iteratively apply the chain to the left n times.
Ṛ      Reverse n (casts to digits).
 Ḍ     Undecimal; convert from base 10 to integer.
  ạ    Take the absolute difference of the result and the argument.

— डेनिस
स्रोत

11

क्या पायल ने जेली को हराया?

— लीक नून

3

खैर, यह एक टाई है।

— डेनिस

ये कोई बाइट्स नहीं हैं।

— जिक

1

@ik हेडर में बाइट्स लिंक पर क्लिक करें ।

— डेनिस

5

Oracle SQL 11.2, 136 बाइट्स

WITH v(n)AS(SELECT :1 FROM DUAL UNION ALL SELECT ABS(n-REVERSE(n||''))FROM v WHERE n>0)CYCLE n SET c TO 0 DEFAULT 1 SELECT MIN(c)FROM v;

संयुक्त राष्ट्र के golfed

WITH v(n) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
  SELECT ABS(n-REVERSE(n||''))FROM v WHERE n>0 
) CYCLE n SET c TO 0 DEFAULT 1
SELECT MIN(c)FROM v

— Jeto
स्रोत

5

एपीएल, 26 वर्ण

0∘{⍵∊⍺:×⍵⋄(⍺,⍵)∇|⍵-⍎⌽⍕⍵}

हम बाएं तर्क का उपयोग उन मूल्यों के संचायक के रूप में करते हैं जो हमने पहले ही देखे हैं। हम इसे "0" के लिए आरंभीकृत करते हैं, जो कि दो समाप्ति स्थितियों में से एक है। गार्ड ⍵∊⍺:×⍵को पढ़ा जाता है: "सही तर्क कुछ है जिसे हमने पहले ही देखा है (और जिसमें शून्य भी शामिल है); यदि ऐसा है तो संख्या का संकेत लौटाएं, यह 1 या 0 है।" अन्यथा बाईं दलील के लिए वर्तमान मूल्य को पूरा करने के बाद घटाव के निरपेक्ष मूल्य के साथ खुद को कॉल करके पुनरावृत्ति करें।

मार्टिन एंडर द्वारा Mathematica समाधान की एक पुनरावृत्ति 21 वर्णों पर होगी :

 {×{|⍵-⍎⌽⍕⍵}⍣(10×⍵)⊣⍵}

इसमें लिखा है: "वांछित 10 एन बार आवेदन करने के बाद परिणाम का संकेत क्या है"?

— lstefano
स्रोत

4

अजगर 2, 50 बाइट्स

n=input()
exec'n=abs(n-int(`n`[::-1]));'*n
print n

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

पृष्ठभूमि

इस का उपयोग करता है @ MartinEnder ऊपरी बाध्य है की 10n पुनरावृत्तियों और निम्नलिखित टिप्पणियों।

कर रहे हैं 9 × 10 ^{1 - कश्मीर} धनात्मक पूर्णांक n के साथ कश्मीर अंक।
एक संख्या और उसके रिवर्स का अंतर हमेशा 9 का एक बहु होता है , इसलिए उनमें से केवल 10 ^{k - 1} पहले पुनरावृत्ति के बाद हो सकते हैं।
गुणकों के, अधिक से अधिक 1/10 अगले चरण में एक अंकों (शुरुआत के लिए, यह सब आरंभ और समाप्ति ही अंकों के साथ, और मोटे तौर पर दो बार कई के रूप में करता है, तो पहले अंक को न तो खो देंगे 1 और न ही एक 9 ) ऐसा है, इसमें अधिकतर 9 × 10 ^{k - 2} लगते हैं या तो एक लूप दर्ज करें या एक अंक खो दें।
एक ही तर्क को k - 1 अंक और इतने पर परिणामी पूर्णांक के रूप में लागू करते हैं , यह सबसे अधिक 9 × 10 ^{k - 2} + 9 × 10 ^{k - 2} +… ^- 10 ^{k - 1} it n पुनरावृत्तियों को लूप में प्रवेश करने के लिए लेता है पहुंच ० ।

— डेनिस
स्रोत

4

सीजाम, 15 13 बाइट्स

ri_{_sW%i-z}*

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

मेरे गणितज्ञ उत्तर के रूप में भी।

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

3

पायथन, 129 120 96 बाइट्स

यदि एक अपवाद पकड़ा जाता है (आमतौर पर एकमात्र फ़ंक्शन जिसे इस फ़ंक्शन के साथ फेंक दिया जा सकता है, एक रनटाइम ईरम है, अनंत पुनरावृत्ति के कारण), प्रिंट 1। अन्यथा, परिणाम प्रिंट करें, 0।

def r(n):a=abs(n-int(str(n)[::-1]));return a and r(a)
try:print(r(int(input())))
except:print(1)

@LeakyNun को @shooqie का
शुक्रिया

— TuxCrafting
स्रोत

यह आधिकारिक तौर पर अनंत पुनरावृत्ति का (अच्छा) दुरुपयोग है।

— लीक नून

return a and rev(a)

— लीक नून

3

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

— घातक

a=[n-x,x-n][n>x]

— लीके नन

आप इसे बहुत छोटा कर सकते हैं def rev(n):a=abs(n-int(str(n)[::-1]));return a and rev(a):। इसके अलावा, विधि को कुछ छोटा नाम दें (जैसे कि rइसके बजाय rev)

— शुकी

3

पायथन, 101 98 बाइट्स

कछुआ और हरे एल्गोरिथ्म।

ट्रू लूप में किसी भी मूल्य है, फाल्सी है 0।

g=lambda n:abs(n-int(str(n)[::-1]))
def r(n):
    t=g(n);h=g(t)
    while t-h:h=g(g(h));t=g(t)
    return h

Ideone यह!

— लीक नन
स्रोत

3

पायथन 2, 85 84 83 बाइट्स

L=[]
def f(n,L=L):
    if n<1or n in L:print n<1
    else:L+=[n];f(abs(n-int(`n`[::-1])))

एक और पायथन जवाब। यह प्रत्येक पुनरावृत्ति के लिए एक सूची में n जोड़ता है, और यदि n पहले से ही सूची में है, तो यह आउटपुट करता है False। अन्यथा, यह 0 से नीचे काम करता है।

धन्यवाद @NonlinearFruit एक बाइट के लिए।

— atlasologist
स्रोत

1

मेरा मानना है कि print n<1काम करता है (चूंकि nहमेशा गैर-नकारात्मक है) और यह एक बाइट बचाता है

— नॉनलीनियरफ्रंट

def f(n,L=[]):¶ if n<1or n in L:print n<1¶ else:f(abs(n-int(`n`[::-1])),L+[n])5 बाइट्स बचाता है

— लीक नन

3

05AB1E, 11 8 6 बाइट्स

DFÂï-Ä

व्याख्या की

DF          # input number of times do
  Â         # push current number and its reverse
   ï-       # convert reverse to int and subtract
     Ä      # absolute value
            # implicitly print after loop ends

ट्रू वैल्यू लूप से एक नंबर है।
मिथ्या मूल्य 0 है।

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

डेनिस के जेली उत्तर में बताई गई ऊपरी सीमा का उपयोग करता है

@ Adnan के लिए 2 बाइट्स को सहेजा गया

में संस्करण 7.9 05AB1E के 5-बाइट समाधान काम करता है निम्नलिखित के रूप में @Adnan द्वारा नोट

DFÂ-Ä

— Emigna
स्रोत

ठीक है, यह थोड़ा अजीब गोल्फ है, लेकिन 7.9 संस्करणDFÂ-Ä में काम करता है, लेकिन वर्तमान संस्करण में नहीं। वर्तमान संस्करण में, आपको इसे पहले इंट (जैसे ) में बदलने की आवश्यकता है , लेकिन आप इसे 5 बाइट्स बनाने के लिए संस्करण 7.9 का उपयोग कर सकते हैं। DFÂï-Ä

— अदनान

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

— इमिग्ना जूल

मैं शायद इसे पोस्ट नहीं करूंगा, क्योंकि यह इस जवाब से सिर्फ 1 बाइट दूर है: पी।

— अदनान

1

जावा 7, 161 बाइट्स

इसके लिए आयात की आवश्यकता है लेकिन मैंने इसे एक फ़ंक्शन के रूप में लिखा था। इस परिदृश्य में एक पूर्ण कार्यक्रम पसंद किया जाता है, तो टिप्पणी में मुझ पर चिल्लाओ। आउटपुट 1 अगर एक अनंत लूप है और 0 यदि मान 0 पर जाता है।

import java.util.*;int z(int a){int o,r,c=a;Set s=new HashSet();while(c!=0){for(r=0,o=c;o!=0;r=r*10+o%10,o/=10);c=Math.abs(c-r);if(!s.add(c))return 1;}return 0;}

— प्रहार
स्रोत

यह देखते हुए कि मैंने पहले किए गए आयात और कार्यों को देखा है। उदाहरण

— पोक

है 1truthy?

— लीक नून

1

@LeakyNun 1 को जावा में सत्य नहीं माना गया है, लेकिन स्वीकार्य आउटपुट के रूप में OP सूचियाँ (सत्य, 1) और (गलत, 0) सूचीबद्ध हैं।

— पोक

@LeakyNun क्या जावा में भी सच्चाई या झूठ की भावना है?

— नील

@Neil Java में वर्टिकल मार्केट के संदर्भों में सहक्रियात्मक अवसरों का लाभ उठाने की भावना है - यही है

— कैट

1

ब्रेकीलॉग , 49 32 23 बाइट्स

:10*N,?:N:{r:?-+.}itT'0

trueअनंत छोरों के लिए रिटर्न और falseअन्यथा।

यह मार्टिन एंडर के एल्गोरिथ्म का एक बेशर्म अनुकूलन है।

पिछला उत्तर, 32 बाइट्स

g{tTr:T-+U(0!\;?:ImU;?:[U]c:1&)}

पिछले उत्तर की व्याख्या

g{                             } Call predicate with [Input] as input
  tT                             T is the last element of Input
    r:T-                         Subtract T from the reverse of T
        +U                       U is the absolute value of T
          (0!\                   If U is 0, return false
              ;                  Or
               ?:ImU             If U is in Input, return true
                    ;            Or
                     ?:[U]c:1&)  Recursive call with U concatenated to the Input

— Fatalize
स्रोत

0

PowerShell v2 +, 94 बाइट्स

param($n)for($a=,0;){if(($n=[math]::Abs($n-(-join"$n"["$n".length..0])))-in$a){$n;exit}$a+=$n}

इनपुट लेता है $n, एक अनंत forलूप शुरू $a=,0करता है, प्रारंभिक स्थिति के रूप में (यह $aएक तत्व के एक सरणी में सेट करने के लिए अल्पविराम ऑपरेटर का उपयोग करता है 0)। यह $aपहले से देखे गए मूल्यों की हमारी सरणी है।

प्रत्येक लूप पुनरावृत्ति हम एक की जाँच करें if। स्थिति पहले $nस्ट्रिंग-रिवर्सल और [math]::Abs.NET कॉल का उपयोग करने का अगला मान सेट करती है , और यह जांचती है कि क्या यह मान पहले से ही है -in $a। यदि हां, तो हम आउटपुट $nऔर exit। अन्यथा, हम उस मान को सरणी में जोड़ते हैं और लूप जारी रखते हैं।

0इनपुट मूल्यों के लिए आउटपुट जहां यह एक अनंत लूप (जो कि पॉवरशेल में गलत है) में नहीं जाता है और उस मूल्य को आउटपुट करता है जहां लूप का सामना करना पड़ा अन्यथा (गैर-शून्य पूर्णांक सत्य हैं)। उदाहरण के लिए, 2178इनपुट के लिए आउटपुट 1584।

— AdmBorkBork
स्रोत

0

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

_#0=0
a#n|elem n a=1|1<2=(n:a)#abs(n-(read$reverse$show n))
([]#)

0झूठा और 1सच्चा के लिए लौटाता है । प्रयोग उदाहरण: ([]#) 1584-> 1।

स्पष्ट दृष्टिकोण: अब तक देखे गए सभी परिणामों के साथ एक सूची रखें। अगली संख्या की गणना तब तक करें जब तक 0वह सूची में हो।

— nimi
स्रोत

0

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

f=(n,...a)=>a.includes(n=n<0?-n:n)?n:f([...n+``].reverse().join``-n,n,...a)

n<0?n=-n:nऔर n*=n>0||-1भी काम। एल्गोरिदम कुछ हद तक पॉवरशेल उत्तर जैसा दिखता है, हालांकि यह एक पुनरावर्ती सूत्रीकरण है।

— नील
स्रोत

0

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

->n,*h{h[n]=n=(n-"#{n}".reverse.to_i).abs until h[n];n>0}

शुरू में खाली सरणी hट्रैक पहले हिट मानों को ट्रैक करता है। हम संख्या को तब तक पुनरावृत्त करते हैं जब तक कि हम पिछला मान नहीं मारते, तब अंतिम पुनरावृत्ति पर मान की जाँच करें। चूँकि 0 1 का एक चक्र है, यह 0 होगा यदि और केवल अगर कोई बड़ा चक्र नहीं है। मैं इसे बूलियन में बदलने के लिए अतिरिक्त 2 बाइट लेता हूं क्योंकि 0 रूबी में सत्य है।

— histocrat
स्रोत

0

पर्ल 6 58 53 33 30 बाइट्स

sub {$/=%;$^a,{return ?1 if $/{$_}++;abs $_-.flip}...0;?0}
{$/=%;?($_,{last if $/{$_}++;abs $_-.flip}...0)[*-1]}
{?($_,{abs $_-.flip}...0)[10**$_]}

{?($_,{abs $_-.flip}...0)[$_]}

स्पष्टीकरण:

{ # block lambda with implicit parameter $_

  # coerce the following to Bool
  # ( False for Nil or 0, True otherwise )
  ?

  (

    $_, # start a sequence with the input

    # block lambda with implicit parameter $_
    # subtracts the previous value in the sequence and its reverse
    # ( .flip is short for $_.flip where a term is expected )
    { abs $_ - .flip } 

    ... # repeat that lambda
    0   # until you get 0

  # get the element indexed with the block's input
  # may be 0, Nil, or a number that is part of a repeating sequence
  )[ $_ ]
}

(पिछले अवलोकन पर निर्भर करता है कि आपको केवल यह परिवर्तन अधिकांश nसमय करने की आवश्यकता है)

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

0

पर्ल 5, 31 29 बाइट्स

~~perl -pe'for$x(1..$_){$_=abs$_-reverse}'~~

perl -pe'eval"\$_=abs\$_-reverse;"x$_'

यह n=|n-rev(n)|n बार पुनरावृत्ति करता है, इसलिए लूप न होने पर आउटपुट 0 है, अन्यथा 0। डेनिस ने पहले ही साबित कर दिया कि यह पर्याप्त है।

नया संस्करण लूप के बजाय ऑपरेटर का उपयोग करता है evalऔर xदोहराता है for।

— mik
स्रोत

अच्छा जवाब, और PPCG में आपका स्वागत है! ध्यान दें कि पर्ल के लिए, कमांड-लाइन विकल्प को आपकी बाइट-काउंट में शामिल किया जाना चाहिए , इसलिए यह काफी 30 बाइट्स नहीं है ।

— AdmBorkBork

@TimmyD ठीक है, +1 -pविकल्प के लिए, -lएकल इनपुट के लिए आवश्यक नहीं है

— mik

0

मतलाब, 89 84 बाइट्स

n=input('');z=n;while n
z=abs(z-str2num(fliplr(num2str(z))));n=[n z]*all(n~=z);end
z

सरल दृष्टिकोण - सभी संख्याओं को रोक देता है और जांचता है कि क्या कोई संख्या पहले प्रकट हुई थी।

व्याख्या

n=input('');z=n;  -- take input, initiate z
while n           -- n is said to be positive
z=abs(z-str2num(fliplr(num2str(z)))) -- calculate the "reverse and substract"
n=[n z]           -- put the value at the end of the vector
       *all(n~=z) -- make the n all zeroes if z is previously in the vector (break the loop)
end
z                 -- print z (0 when not entered loop, >0 otherwise)

— pajonk
स्रोत

उल्टा और घटाना

चुनौती का वर्णन

इनपुट विवरण

आउटपुट विवरण

टिप्पणियाँ

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

व्याख्या

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

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

पृष्ठभूमि

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

Oracle SQL 11.2, 136 बाइट्स

एपीएल, 26 वर्ण

अजगर 2, 50 बाइट्स

पृष्ठभूमि

सीजाम, 15 13 बाइट्स

पायथन, 129 120 96 बाइट्स

पायथन, 101 98 बाइट्स

पायथन 2, 85 84 83 बाइट्स

05AB1E, 11 8 6 बाइट्स

जावा 7, 161 बाइट्स

ब्रेकीलॉग , 49 32 23 बाइट्स

पिछला उत्तर, 32 बाइट्स

पिछले उत्तर की व्याख्या

PowerShell v2 +, 94 बाइट्स

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

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

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

पर्ल 6 58 53 33 30 बाइट्स

स्पष्टीकरण:

पर्ल 5, 31 29 बाइट्स

मतलाब, 89 84 बाइट्स