39

8675309 जैसे कुछ गैर-नकारात्मक पूर्णांक लेने और पड़ोसी अंकों के सभी जोड़े के बीच अंतर के पूर्ण मूल्यों की गणना करने पर विचार करें।

के लिए 8675309हम पाते हैं |8-6| = 2, |6-7| = 1, |7-5| = 2, |5-3| = 2, |3-0| = 3, |0-9| = 9। इन परिणामों को एक साथ स्ट्रिंग करने से एक और छोटे, गैर-नकारात्मक पूर्णांक प्राप्त होता है 212239:। इस प्रक्रिया को दोहराते हुए 11016, फिर 0115, इस सम्मेलन के द्वारा जो कि अग्रणी शून्य नहीं लिखा जाता है 115, जैसा कि सरल हो जाता है , जो 04या तो बन जाता है 4, जिसे और कम नहीं किया जा सकता है। इन सभी मूल्यों का सारांश हमें मिलता है 8675309 + 212239 + 11016 + 115 + 4 = 8898683।

आइए अंक अंतर योग (या डीडीएस) को परिभाषित करें कि किसी संख्या के अंकों के अंतर को बार-बार लेने के इस ऑपरेशन को एक नई संख्या बनाने के लिए, फिर सभी परिणामी संख्याओं को मूल में जोड़ना।

यहां संबंधित DDS अनुक्रम में पहले 20 मान दिए गए हैं:

यहाँ पहले 10000 मान हैं , जिसके लिए ग्राफ काफी जिज्ञासु है:

खासकर जब से आप इसे 1000 या 100 तक प्लॉट करते हैं, तब भी ऐसा ही दिखता है:

(मैं इसे डेंटिस्ट की सीढ़ी कहूंगा ...)

चुनौती

एक कार्यक्रम या फ़ंक्शन लिखें जो एक गैर-नकारात्मक पूर्णांक और प्रिंट में लेता है या इसका DDS मान लौटाता है। उदाहरण के लिए, यदि इनपुट था 8675309, तो आउटपुट होना चाहिए 8898683।

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

code-golf arithmetic sequence

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

दंत चिकित्सक की सीढ़ी?

— मार्टिज़न

12

@MartijnR डेंटिस्ट की सीढ़ी।

— केल्विन के शौक

@ केल्विन के शौकीन रूढ़िवादी की सीढ़ी?

— बीटा डेके

1

@ बीटाडेके डेंटिस्ट की सीढ़ी।

— एलेक्स ए।

11

अजगर, १,

s.ui.aM-VJjNTtJTQ

इसे यहां आज़माएं या टेस्ट सूट चलाएं

स्पष्टीकरण:

s.u            Q   # Cumulative reduce, i.e. getting the intermediate values of each reduce
                     step and returning them as a list, then sum the list
   i ... T         # Convert the resulting list of numbers into a base 10 number
   .aM             # Get the absolute value of each element of ...
      -VJjNTtJ     # Perform vector subtraction on the lists given by
        JjNT       # assign J the number we currently have converted to its base 10 digits
            tJ     # and J[1:]. e.x. for 123 we get J = [1,2,3] then we do
                   # zip(J,J[1:]) which gives [[1,2],[2,3]] then element wise subtract
                   # to get [-1, -1]

— FryAmTheEggman
स्रोत

यह कौनसी भाषा है? इतना गूढ़! T_T

— asgs

1

@asgs पीपीसीजी में आपका स्वागत है :) इसे पायथ कहा जाता है, आप इसके गीथब पृष्ठ पर एक दुभाषिया और कुछ दस्तावेज पा सकते हैं । इस साइट पर इस भाषा के अधिकांश उपयोगकर्ता सक्रिय हैं, इसलिए यदि आपके पास इसके बारे में प्रश्न हैं, तो चैट या कमरे में इसे समर्पित करने के लिए स्वतंत्र महसूस करें :)

— FryAmTheEggman

17

पायथन 2, 73

सौभाग्य से, मैं किसी भी स्ट्रिंग ऑपरेशन से बचने में कामयाब रहा।

t=lambda n:n>9and abs(n%10-n/10%10)+10*t(n/10)
g=lambda n:n and n+g(t(n))

g वह कार्य है जो उत्तर की गणना करता है।

— feersum
स्रोत

4

यह काला जादू क्या है ?!

— बीटा डिके

7

@ BetaDecay मेरा मानना है कि इसे "गणित" कहा जाता है।

— lirtosiast

मुझे पता नहीं है कि पायथन काफी अच्छी तरह से बताता है, लेकिन क्या आप एक ही हिट में शेष शर्तों को लागू कर सकते हैं? यह है, के (n-n/10)%10रूप में ही काम करेगा n%10-n/10%10? या शायद भी (9*n/10)%10?

— Glen O

@ गैलो पायथन में, %एक सच्चा मापांक ऑपरेटर है, शेष नहीं है, इसलिए यह काम नहीं करेगा।

— feersum

15

मतलाब, 101 105 बाइट्स

polyvalइसके बजाय उपयोग करने के लिए अपने सुझाव के लिए @ बीकर को बहुत धन्यवाद base2dec। इसने मुझे अनुमति दी

4 बाइट्स बचाएं;
बहुत सामान्यीकरण को आधारभूत रूप से सरल बनाते हैं (नीचे देखें) और वहां 22 बाइट्स बचाएं; और सबसे बढ़कर,
मुझे यह महसूस करने में मदद मिली कि सामान्य मामले के लिए कोड गलत था (अग्रणी शून्य हटाए नहीं जा रहे थे)। कोड और ग्राफ अभी सही हैं।

कोड:

function y=f(y)
x=+num2str(y);while numel(x)>1
x=polyval(abs(diff(x)),10);y=y+x;x=+dec2base(x,10);end

उदाहरण:

>> f(8675309)
ans =
     8898683

बोनस: मनमाना आधार

एक छोटा सामान्यीकरण व्यक्ति को एक मनमाना संख्या आधार का उपयोग करने की अनुमति देता है, जरूरी नहीं कि दशमलव:

2 से 10, ~~108~~ 104 बाइट्स से मनमाना आधार
```
function y=f(y,b)
x=+dec2base(y,b);while numel(x)>1
x=polyval(abs(diff(x)),b);y=y+x;x=+dec2base(x,b);end
```
कारण है कि इस पर निर्भर आधार के लिए ही काम करता है 10मैटलैब का वह यह है कि dec2baseसमारोह का उपयोग करता है अंक 0, 1, ..., 9, A, B, ..., और वहाँ से चरित्र (ASCII) कोड में एक छलांग है 9करने के लिए A।
2 से 36, 124 ~~146~~ बाइट्स के विपरीत आधार

ऊपर 9से Aसंदर्भित कूद को विशेष उपचार की आवश्यकता है। 36मैटलैब के dec2baseकार्य के अनुसार अधिकतम आधार है ।
```
function y=f(y,b)
x=+dec2base(y,b);x(x>57)=x(x>57)-7;while numel(x)>1
x=abs(diff(x));x=x(find(x,1):end);y=y+polyval(x,b);end
```

यह दंत चिकित्सक की सीढ़ियों को अलग-अलग आधारों के लिए कैसे दिखता है:

— लुइस मेंडो
स्रोत

1

यह वही है जो मैंने किया होगा ... एक और जवाब देने के लिए सोचने का समय। +1।

— रायरेंग - मोनिका

@rayryeng :-) धन्यवाद

— लुइस

@BetaDecay धन्यवाद! :-) वे वास्तव में बहुत

— अच्छे हैं

11

CJam, 22 21 बाइट्स

ri_{\s2ew::-:zsi_@+}h

ध्यान दें कि यह प्रोग्राम एक त्रुटि के साथ बाहर निकलता है, जिसे डिफ़ॉल्ट रूप से अनुमति दी जाती है ।

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

मूल संशोधन में त्रुटि को इंगित करने के लिए @ Sp3000 का धन्यवाद।

1 बाइट को बंद करने के लिए @ मार्टिनबटनर को धन्यवाद।

उदाहरण चलाते हैं

$ cjam digit-difference.cjam 2>&- <<< 8675309     
8898683

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

ri_   e# Read an integer (I) from STDIN and push a copy (A).
{     e# Do:
  \   e#   Swap I on top of A.
  s   e#   Cast I to string.
      e#   For example, 123 -> "123".
  2ew e#   Push the overlapping slices of length 2 (pair of adjacent digits).
  ::- e#   Replace each pair by its difference.
  :z  e#   Apply absolute value to each difference.
  si  e#   Cast to string, then to integer. This is the new I.
      e#   For example, [1 2 3] -> "123" -> 123.
  _   e#   Push a copy of I.
  @   e#   Rotate A on top of the copy of I.
  +   e#   Add I to A, updating A.
}h    e# While A is truthy, repeat the loop.

A हमेशा सत्य होगा जब जाँच की जाएगी h। हालाँकि, एक बार जब मैं एकल-अंक पूर्णांक होता हूं , 2ewतो उस सरणी का उपभोग करने के बाद एक त्रुटि के साथ विफल हो जाएगा जिस पर इसे बुलाया गया था। यह स्टैक पर केवल वांछित परिणाम छोड़ता है, जो बाहर निकलने से पहले मुद्रित होता है।

— डेनिस
स्रोत

2

7 मिनट के फ्लैट में पोस्ट किया गया: ओ

— केल्विन के शौक

10

भूलभुलैया , 176 134 127 119 103 97 88 82 79 76 72 बाइट्स

1 बाइट बचाने और 2 और के लिए मार्ग प्रशस्त करने के लिए Sp3000 का धन्यवाद।

यह शायद अभी भी छोटा किया जा सकता है, लेकिन हे, यह ~~जावा~~ ~~Matlab~~ पायथन को ~~हरा देता~~ है ...

?
_
)/:}+{:`};!
9       "
_ :}-"" :_10
;;{: `" "  :
  {  (_:/=%}
  0+;`"

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

यह एक त्रुटि के साथ समाप्त होता है लेकिन त्रुटि संदेश STDERR को लिखा जाता है (यही कारण है कि आप इसे TIO में नहीं देखते हैं)।

कार्यान्वयन काफी सीधा है। हम एक चालू कुल में वर्तमान मान जोड़ते हैं। यदि वर्तमान मूल्य से अधिक था 9, तो हम इसके आधार -10 अंकों (बार-बार डिव-मॉड के माध्यम से) की गणना करते हैं, और पूर्ण अंतर से एक नया नंबर बनाते हैं। यदि हम 9कम या ज्यादा हो जाते हैं, तो हम कुल रनिंग प्रिंट करते हैं।

वर्तमान संख्या के अंकों को शीर्ष पर सबसे महत्वपूर्ण अंक के साथ सहायक स्टैक पर एकत्र किया जाता है।

खैर, abs(...)मैं का फैंसी कार्यान्वयन यहां नए समाधान की तुलना में हास्यास्पद रूप से जटिल हो गया था ... जब मैं इसे आगे बढ़ा रहा हूं, तो मैं एक अद्यतन स्पष्टीकरण जोड़ूंगा।

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

5

जावा - 300 बाइट्स

गोल्फ संस्करण

static Long t=new Scanner(System.in).nextLong();static char[]c=t.toString().toCharArray();public static void main(String[]z){while(c.length>1)s();System.out.print(t);}static void s(){String s="";for(int i=0;i<c.length-1;)s+=Math.abs(c[i]-c[++i]);Long a=new Long(s);t+=a;c=a.toString().toCharArray();}

Ungolfed / पूर्ण संस्करण

import java.util.Scanner;

public class DigitDifference {

    static Long t = new Scanner(System.in).nextLong();
    static char[] c = t.toString().toCharArray();

    public static void main(String[] args){
        while( c.length > 1 )
            s();
        System.out.print(t);
    }

    static void s(){
        String s="";
        for(int i = 0; i < c.length-1;)
            s += Math.abs(c[i]-c[++i]);
        Long a = new Long(s);
        t += a;
        c = a.toString().toCharArray();
    }
}

— कोडर
स्रोत

@ लोजोवो, चीयर्स ..

— द कोडर

1

PPCG में आपका स्वागत है! यह अभी भी बहुत कुछ गोल्फ हो सकता है। मैंने तर्क पर ज्यादा गौर नहीं किया है लेकिन: 1) एक समारोह में यह सब खींचो क्योंकि आपको वास्तव में एक अलग (या उस मामले के लिए एक पूर्ण कार्यक्रम / वर्ग) की आवश्यकता नहीं है) 2) staticखींचने के बाद एस से छुटकारा पाएं 3 में) (a+"")आम तौर पर के रूप में ही है a.toString(), लेकिन कम 4) आप एक स्कैनर की जरूरत नहीं है अगर यह सिर्फ एक समारोह है, बस एक लंबा इनपुट के रूप में ले लो।

— Geobits

2

उदाहरण के लिए, ज्यादा काम किए बिना, और सिर्फ

long f(long t){long a=t;char[]c;while((c=(a+"").toCharArray()).length>1){String s="";for(int i=0;i<c.length-1;)s+=Math.abs(c[i]-c[++i]);t+=a=new Long(s);}return t;}

— क्रॉफ्ट

2

@Geobits, वह अद्भुत दोस्त था। मैं कोड गोल्फ में नया हूं, इसलिए मैं अपनी कोडिंग दक्षता में सुधार करने की कोशिश करूंगा। Cherrs ..

— कोडर

5

जूलिया, 81 60 बाइट्स

n->(s=n;while n>9 s+=n=int(join(abs(diff(["$n"...]))))end;s)

Ungolfed:

function f(n::Int)
    # Initialize a sum to the input
    s = n

    while n > 9
        # Get absolute values of the pairwise differences of the
        # digits of n, join as a string, convert it to an integer,
        # and reassign n
        n = int(join(abs(diff(["$n"...]))))

        # ["$n"...] actually splits n as a string into a vector
        # of its characters, but the difference between ASCII
        # codes is the same as the difference between the numbers
        # so it works as expected

        # Add the new n to the running sum
        s += n
    end

    # Return the sum
    return s
end

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

21 बाइट्स को फेर्सम और ग्लेन ओ को धन्यवाद दिया!

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

1

क्या कोई कारण ndigits(n)>1अलग है n>9?

— feersum

सुझाव: int(join(abs(diff(["$n"...]))))9 बाइट्स बचाता है। n>9एक और 9 बाइट्स के लिए feersum द्वारा सुझाए गए अनुसार स्विच करें । एक कदम में (जबकि अतिरिक्त, अब अनावश्यक अर्धविराम को हटाते हुए) लूप में दोनों असाइनमेंट्स करके तीन और बाइट्स बचाएं:n->(s=n;while n>9 s+=n=int(join(abs(diff(["$n"...]))))end;s)

— Glen O

@ फ़ेर्सुम उम, नोप। धन्यवाद!

— एलेक्स ए।

@GlenO बहुत बढ़िया, धन्यवाद!

— एलेक्स ए।

5

ओके , 37 32 24 23 बाइट्स

+/(10/{%x*x}1_-':.:'$)\

कार्रवाई में:

  +/(10/{%x*x}1_-':.:'$)\8675309
8898683

  (+/(10/{%x*x}1_-':.:'$)\)'!20
0 1 2 3 4 5 6 7 8 9 11 11 13 15 17 19 21 23 25 27

K5 में कुछ विशेषताएं हैं जो इस के लिए अच्छी तरह से अनुकूल हैं- "एनकोड" और "डीकोड" आधार रूपांतरण कर सकते हैं, प्रत्येक-जोड़ी ( ':) एक सूची में अनुक्रमिक तत्वों को जोड़ते हैं और फिक्स्ड पॉइंट स्कैन ( \) बंद होने तक पुनरावृत्त अनुक्रम का उत्पादन कर सकते हैं। बदल रहा है। एक आदिम की कमी के abs()रूप में कुछ भद्दा थोक की ओर जाता है {(x;-x)x<0}', यद्यपि।

संपादित करें:

इसके बजाय {(x;-x)x<0}', मैं (कुछ हद तक बेकार) अनुक्रम के वर्ग का वर्गमूल ले सकता हूं (और {%x*x}, 5 बाइट्स बचा रहा है।

2 संपादित करें:

@ मौरिनस एपीएल समाधान से प्रेरित, मैं "डिकोड" ( ((#$x)#10)\x) को संख्या के स्ट्रिंग प्रतिनिधित्व के प्रत्येक चरित्र का मूल्यांकन करने के साथ बदल सकता हूं- .:'$x! यह मुझे अतिरिक्त वर्णों को सहेजते हुए, संपूर्ण अभिव्यक्ति का एक मौन रूप का उपयोग करने देता है।

— JohnE
स्रोत

4

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

f=lambda n:n and n+f(int('0'+''.join(`abs(int(a)-int(b))`for a,b in zip(`n`,`n`[1:]))))

पुनरावर्ती वर्तमान संख्या को जोड़ता है और अंकों के अंतर को लेता है। संख्या और तारों के बीच परिवर्तित करने के बहुत सारे। शायद सुधारा जा सकता है।

— XNOR
स्रोत

4

जूलिया, 55 48 बाइट्स

h=n->(n>9&&h(int(join(abs(diff(["$n"...]))))))+n

Ungolfed:

function h(n)
  if n>9
    # If multiple digits, find the digit difference...
    digitdiff=int(join(abs(diff(["$n"...]))))
    # ... recurse the function...
    downsum=h(digitdiff)
    # ... and return the sum so far (working up from the bottom)
    return downsum+n
  else
    # If single digit, no further recursion, return the current number
    return n
  end
end

अनिवार्य रूप से, यह एकल-अंकों के स्तर (जहां कोई अंकों का अंतर नहीं किया जा सकता है) तक नीचे आता है, फिर पुन: जमा होता है क्योंकि यह पुनरावृत्ति, स्तर के स्तर से बाहर निकलता है।

— ग्लेन हे
स्रोत

3

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

d काम करता है।

import Data.Char
d n=sum.m(read.m intToDigit).fst.span(/=[]).iterate s.m digitToInt.show$n
s l@(h:t)=snd$span(==0)$m abs$zipWith(-)l t
m=map

क्या किसी को पता है कि लंबे रूपांतरण कार्यों को आयात करने से कैसे बचा जाए?

— लीफ विलर्ट्स
स्रोत

intToDigitहै toEnum.(+48)और digitToIntहै (\i->fromEnum i-48)। आप सूची के संदर्भ में sएक पॉइंटफ्री संस्करण में भी बदल सकते हैं :। अंत में, यह है कि हम गैर-नकारात्मक पूर्णांक के साथ काम कर रहे हैं। =<<s=snd.span(==0).m abs.(zipWith(-)=<<tail)(==0)(<1)

— नीम

... ओह, और अगर sपॉइंटफ्री है, तो इसे कोई नाम देने की आवश्यकता नहीं है। इसे सीधे कॉल करें:iterate(snd.span ... tail))

— nimi

... यह मेरी पहली टिप्पणी में एक गलती को ठीक करने के लिए फिर से है: =<<फ़ंक्शन संदर्भ में उपयोग किया जाता है, सूची संदर्भ नहीं, क्षमा करें।

— नीम

प्रतिभाशाली! इसके अलावा, क्या जीएचसी एक्सटेंशन का उपयोग करना यहां सामान्य प्रक्रिया है? NoMonomorphismRestrictionमुझे भी dपॉइंटफ्री करेंगे ।

— लीफ विलर्ट्स

1

chrऔर ordदोनों में हैं Data.Char, इसलिए आप इसे छोड़ नहीं सकते import। संकलक झंडे बाइट के रूप में गिना जाता है, भी, तो NoMonomorphismRestrictionआपका स्कोर 25 से बढ़ जाती है

— nimi

3

K5, 50 बाइट्स

+/{(r;x)@~r:.,/"0",{$(0;-r;r)@(~^r)+0<r:x-y}':$x}\

— kirbyfan64sos
स्रोत

3

एपीएल (22)

{⍵≤9:⍵⋄⍵+∇10⊥|2-/⍎¨⍕⍵}

स्पष्टीकरण:

⍵≤9:⍵: यदि,, 9, अपरिवर्तित लौटें।
⍎¨⍕⍵:। को स्ट्रिंग में बदलें, फिर प्रत्येक वर्ण का मूल्यांकन करें
2-/: प्रत्येक दो आसन्न संख्याओं को घटाएं
|: पूर्ण मूल्यों को लें
10⊥: सरणी को आधार -10 संख्या में बदल दें
⍵+∇: इस नए मान के साथ फ़ंक्शन को पुन: कॉल करें, और परिणाम को इनपुट में जोड़ें

— मारीनस
स्रोत

3

गणितज्ञ, 72 69 65 बाइट्स

Tr@FixedPointList[FromDigits@*Abs@*Differences@*IntegerDigits,#]&

मैं यहाँ सुझावों के लिए खुला हूँ।

— LegionMammal978
स्रोत

Tr@FixedPointList[FromDigits@*Abs@*Differences@*IntegerDigits,#]&

— एलेफाल्फा

@alephalpha दिलचस्प अवधारणा, अतिरिक्त शून्य पैदा करना ...

— LegionMammal978

2

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

t=n=>(b=10,M=Math).ceil(n&&n+t((j=n=>n>9&&M.abs(n%b-n/b%b)+b*j(n/b))(n)))

यह कोई छोटा नहीं है: / मैं और अधिक दृष्टिकोण की कोशिश करूँगा, लेकिन यह अब तक का सबसे छोटा है

— Downgoat
स्रोत

यदि आप इसे tइसे अभी भी मान्य करने के बजाय एक अनाम फ़ंक्शन के रूप में छोड़ देते हैं और यह आपको 2 बाइट्स बचाता है।

— पैट्रिक रॉबर्ट्स 14

@PatrickRoberts हाँ, लेकिन मैं पुनरावृत्ति का उपयोग कर रहा हूँ, इसलिए मुझे इसे नाम देने की आवश्यकता है

— Downgoat

ओह, बहुत याद किया।

— पैट्रिक रॉबर्ट्स

2

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

एक EcmaScript 6 अनुरूप ब्राउज़र में नीचे स्निपेट का परीक्षण करना (लेकिन क्रोम नहीं है क्योंकि यह अभी भी प्रसार ऑपरेटर का समर्थन नहीं करता है ...) एमएस एज शायद?

f=n=>n&&(n+=r='',[...n].map(d=>(r+=d>p?d-p:p-d,p=d),p=n[0]),+n+f(+r))

function test()
{
  var i=+I.value
  O.innerHTML = i+' -> '+f(i) + '\n' + O.innerHTML 
}

<input id=I value=8675309><button onclick=test()>-></button>
<pre id=O></pre>

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

वैकल्पिक, सरणी बोध का उपयोग करते हुए जो अब EcmaScript 2016 (ES7), 67 बाइट्स को लक्षित करता है:

f=n=>n&&(n+=r='',p=n[0],[for(d of n)(r+=d>p?d-p:p-d,p=d)],+n+f(+r))

— edc65
स्रोत

2

पायथन 3, 125 बाइट्स

मैं जब तक मैं इस चुनौती के लिए इसका इस्तेमाल करने की कोशिश की regex की तकलीफ पसंद करने के लिए इस्तेमाल किया ... re.findall('\d\d',s,overlapped=True)है न पर;)

s=input()
p=int
x=p(s)
while p(s)>9:g=str(s);s=p(''.join(str(abs(p(g[i])-p(g[i+1])))for i in range(len(g)-1)));x+=s 
print(x)

चीयर्स @ टोड :)

— बीटा डिके
स्रोत

1

आप एक सूची के बजाय पूर्णांक पर एक अतिरिक्त जोड़ सकते हैं, जो वर्ग कोष्ठक और अंतिम राशि की आवश्यकता को हटा देगा। 's = p (इनपुट ())' आपको लूप और x को असाइनमेंट करते समय अंतर रूपांतरण को हटाने की अनुमति देगा। इसके अलावा जी और जी [1:] के ज़िप के माध्यम से लूपिंग पर विचार करें, जो कुछ बाइट्स को बचाए।

— टोड

1

जे, 70 बाइट्स

 +/([:10&#.[:(2|@:-/\])[:10&(]#:~[#~[:>.[^.])])`]@.(11&>)^:a:".(1!:1)3

— protist
स्रोत

0

C 162 बाइट्स

golfed:

main(int argc,char **argv){char *c=argv[1];int u=atoi(c),d;do{while(c[1]!=0){*c=abs(*c-*(c+1))+48;c++;}*c=0;c=argv[1];d=atoi(c);u+=d;}while(d>9);printf("%d",u);}

ungolfed:

main(int argc, char **argv)
{
    char *c=argv[1];
    int u=atoi(c),d;

    do
    {
        while(c[1]!=0)
        {
            *c=abs(*c-*(c+1))+48;
            c++;
        }

        *c=0;
        c=argv[1];
        d=atoi(c);
        u+=d;
    }
    while(d>9);

    printf("%d\n",u);
}

— Zaibis
स्रोत

0

आर, 134 बाइट्स

कोड

f=function(x){z=x;while(z>9){n=seq(nchar(z));z=abs(diff(strtoi(substring(z,n,n))));z=sum(z*10**(rev(seq(length(z)))-1));x=x+z};cat(k)}

इसे ऑनलाइन टेस्ट करें ।

Ungolfed

f=function(x){
  z=x;
  while(z>9){
    n=seq(nchar(z));
    z=abs(diff(strtoi(substring(z,n,n))));
    z=sum(z*10**(rev(seq(length(z)))-1));
    x=x+z
  };
  cat(x)
}

यहाँ f (1) से f (1m) की "डिजिट डिफरेंस सम ऑफ ए नंबर" सीरीज के अंतर की साजिश है। सिर्फ इसलिए कि मुझे अलग करना पसंद है।

प्लॉट कोड

s <- seq(1,100000)
serie <- sapply(s,f)
plot(diff(ts(serie)),xlab="",ylab="")

— Mutador
स्रोत

0

MATLAB (141)(137)

संपादित करें: 4 बाइट्स कम, @Andras के लिए धन्यवाद

function[s j]=n(T,b,c),if(T/b>9),u=fix(T/10);[x e]=n(T,b*10,0);y=n(u,b,0);[w z]=n(u,b,c);s=abs(x-y);j=s+e+10*c*z;else,s=mod(T,10);j=s;end

इस doest ने @LuisMendo के उत्तर को हराया लेकिन कम से कम मैं निष्पादन समय को कम कर सकता था, जिसके द्वारा, मैंने इस समस्या से निपटने के तरीकों में विविधता लाने की कोशिश की होगी।
मैं इसे और कम कर सकता था लेकिन जैसा कि मैं कम समय के लिए जाता हूं, मैं अधिक बाइट बर्बाद करता हूं, इसलिए यहां सिद्धांत है:

यह प्रोग्राम इनलेट डिजिट से पहले एक ही पंक्ति के अंकों को समेटता है, इसका मतलब यह है कि यह पूर्णांक विभाजन "n / 10" log_10 (n) समय का उपयोग करता है, जटिलता O (N) है।

अगर n= a b c d

a          b           c           d
   |a-b|       |b-c|       |c-d|
    ||a-b|-|b-c|| ||b-c|-|c-d||
   ....

मेरा कार्यक्रम गणना करता है:

a+|a-b| + | |a-b|-|b-c| |  +  |  | |a-b|-|b-c| | - | |b-c|-|c-d| |  |
+10*(
b+|b-c| + | |b-c|-|c-d| |
+10*(
c+|c-d|
+10*(
d
)
)
)

उपयोग:

  [a b]=n(13652,1,1)

a =

1

 b =

   16098

— Abr001am
स्रोत

आप वैकल्पिक छोड़ते हुए द्वारा 4 बाइट छोड़ कर सकते हैं ,endकी functionघोषणा।

— एंड्रास डीक

कृपया अपनी पोस्ट के व्याकरण को संशोधित करने पर विचार करें। मैंने यह नहीं समझा कि आपने क्या कहा है।

— रायरेंग - मोनिका

0

प्रोलॉग, 143 बाइट्स

कोड:

q(X,N):-X<9,N=0;A is abs(X mod 10-X//10 mod 10),Y is X//10,q(Y,M),N is A+M*10.
r(X,N):-X<9,N=X;q(X,Y),r(Y,M),N is X+M.
p(X):-r(X,N),write(N).

व्याख्या की:

q(X,N):-X<9,N=0;                                                         % If only one digit, the difference is 0
        A is abs(X mod 10-X//10 mod 10),Y is X//10,q(Y,M),N is A+M*10.   % Else, the difference is the difference between the last 2 digits + the recursive difference of the number without the last digit
r(X,N):-X<9,N=X;                                                         % If we only have 1 digit the final answer is that digit
        q(X,Y),r(Y,M),N is X+M.                                          % Else, the final answer is the current number + the recursive difference of that number
p(X):-r(X,N),write(N).

q गणनाओं को अंजाम देता है जो किसी संख्या को अंकों के अंतर में बदल देते हैं।
r पुनरावर्ती रूप से q को कॉल करता है और अंकीय अंतर सम को खोजने के लिए परिणाम प्रस्तुत करता है।
p एंट्री पॉइंट है। एक नंबर लेता है, आर को कॉल करता है और उत्तर प्रिंट करता है।

उदाहरण:

>p(8675309).
8898683

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

— Emigna
स्रोत

0

PHP - 198 बाइट्स

<?$x=$t=$_GET['V'];function z($x){global$t;for($i=0;$i<strlen($x)-1;$i++){$z=str_split($x);$r.=str_replace('-','',$z[$i]-$z[$i+1]);}$r=ltrim($r,'0');$t+=$r;return strlen($r)>1?z($r):0;}z($x);echo$t;

Ungolfed

<?
$x=$t=$_GET['V']; // Gets the value from input
function z($x){
    global$t;
    for($i=0;$i<strlen($x)-1;$i++){
        $z=str_split($x); //Turns the string into an array
        $r.=str_replace('-','',$z[$i]-$z[$i+1]); // Sums the two values and removes the minus signal
    }
    $r=ltrim($r,'0'); // Remove trailing zeroes
    $t+=$r; // Adds to global var
    return strlen($r)>1?z($r):0; // Checks the size of the string. If >1, calls the function again
}

z($x);
echo$t;

— अपरिभाषित
स्रोत

0

पर्ल 6 , 56 बाइट्स

{[+] $_,{+.comb.rotor(2=>-1)».map((*-*).abs).join}…0} # 56 bytes

उपयोग:

my &code = {...} # insert code from above

(180..190).map: &code;
# (259 258 259 260 261 262 263 264 265 266 280)

say code 8675309; # 8898683

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

संख्या के अंकों के अंतर का योग

चुनौती

अजगर, १,

स्पष्टीकरण:

पायथन 2, 73

मतलाब, 101 105 बाइट्स

बोनस: मनमाना आधार

CJam, 22 21 बाइट्स

उदाहरण चलाते हैं

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

भूलभुलैया , 176 134 127 119 103 97 88 82 79 76 72 बाइट्स

जावा - 300 बाइट्स

जूलिया, 81 60 बाइट्स

ओके , 37 32 24 23 बाइट्स

संपादित करें:

2 संपादित करें:

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

जूलिया, 55 48 बाइट्स

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

K5, 50 बाइट्स

एपीएल (22)

गणितज्ञ, 72 69 65 बाइट्स

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

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

पायथन 3, 125 बाइट्स

जे, 70 बाइट्स

C 162 बाइट्स

आर, 134 बाइट्स

कोड

Ungolfed

प्लॉट कोड

MATLAB (141)(137)

उपयोग:

प्रोलॉग, 143 बाइट्स

PHP - 198 बाइट्स

पर्ल 6 , 56 बाइट्स