उस छोटी संख्या को इनपुट से बड़ा ज्ञात करें जिसका डिजिटल योग इनपुट है


28

"डिजिटल योग" एक संख्या में सभी अंकों के योग को संदर्भित करता है।

उदाहरण के लिए, डिजिटल राशि 1324है 10, क्योंकि 1+3+2+4 = 10

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

वॉकथ्रू के साथ उदाहरण

एक उदाहरण के रूप में, संख्या 9को इनपुट के रूप में लें:

9 = 1+8 -> 18
9 = 2+7 -> 27
9 = 3+6 -> 36
...
9 = 8+1 -> 81
9 = 9+0 -> 90

मान्य आउटपुट उपरोक्त सबसे छोटी संख्या होगी, जो कि है 18

चश्मा

ध्यान दें कि 9इस उदाहरण के लिए मान्य आउटपुट नहीं है, क्योंकि उलट संख्या मूल संख्या से अधिक होनी चाहिए।

ध्यान दें कि इनपुट सकारात्मक होगा।

परीक्षण के मामलों:

 2 => 11      (2 = 1 + 1)
 8 => 17      (8 = 1 + 7)
12 => 39     (12 = 3 + 9)
16 => 79     (16 = 7 + 9)
18 => 99     (18 = 9 + 9)
24 => 699    (24 = 6 + 9 + 9)
32 => 5999   (32 = 5 + 9 + 9 + 9)

संदर्भ:

यह OEIS A161561 है

संपादित करें: एक अतिरिक्त टेस्टकेस जोड़ा गया (18)

लीडरबोर्ड स्निपेट के लिए मार्टिन एंडर को धन्यवाद

var QUESTION_ID=81047,OVERRIDE_USER=31373;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>


11
इस शीर्षक ने मेरे दिमाग को चोट पहुंचाई।
१६:२६ पर घातक

जवाबों:


4

05AB1E, 19 17 8 बाइट्स

कोड:

[>DSO¹Q#

व्याख्या की:

[            # start infinite loop
 >           # increase loop variable, will initially be input
  DSO        # make a copy and sum the digits
     ¹Q#     # if it equals the input, break
             # else return to start of loop
             # implicitly print

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

संपादित करें: @ Adnan के लिए 9 बाइट्स सहेजे गए


4
SOअंकों का योग प्राप्त करने का एक छोटा तरीका है (इसके बजाय J`)O)। इसके अलावा, चर असाइनमेंट के बिना, आप [>DSO¹Q#:) कर सकते हैं ।
अदनान

2
@Adnan। अच्छा! मुझे पूरी तरह से याद किया गया है। मुझे महसूस करना चाहिए कि मुझे चर की आवश्यकता नहीं थी।
इमीना

14

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

lambda n:[n+9,`n%9`+n/9*'9'][n>9]

एक प्रत्यक्ष अभिव्यक्ति। अंत में 9 के साथ एक संख्या स्ट्रिंग बनाता है और शुरुआत में शेष रहता है। सिवाय, एकल-अंक के लिए n, देता है n+9

कुछ आउटपुट में अग्रणी शून्य (के 099लिए 18) है।


7

रेटिना , 39 31 बाइट्स

r`1{1,9}
$.&
T`d`_d`^.$
^.$
1$&

इनपुट लेता एकल में

इसे ऑनलाइन आज़माएं! (पहली दो पंक्तियाँ एक साथ कई परीक्षण मामलों को चलाने की अनुमति देती हैं और सुविधा के लिए दशमलव से अकारण परिवर्तित हो जाती हैं।)

यह वास्तव में परिणाम को रैखिक रूप से नहीं खोजता है, लेकिन यह स्पष्ट रूप से गणना करता है:

  • इनपुट तो n9 से अधिक है, हम से बदलने n % 9के बाद n / 9(फिदा) नौ।
  • अन्यथा, हम इसे प्रतिस्थापित करते हैं n + 9

उपयोग !(या कुछ और जो कि नहीं है 1) एक अंक के रूप में, मैं निम्नलिखित दृष्टिकोण के साथ एक और बाइट बचा सकता हूं:

^!(?!!{9})
1
r`!{0,9}
$.&
0\B

लेकिन यह इनपुट प्रारूप थोड़ा खिंचाव का है, मुझे लगता है।


तो रेटिना इंटेगर इनपुट की अनुमति नहीं देगा या सिर्फ इंटीगर अंकगणित को संभाल नहीं सकता है?
लेवंथ

@levanth रेटिना में कोई अंकगणित नहीं है - पूरी भाषा नियमित अभिव्यक्तियों के माध्यम से स्ट्रिंग प्रसंस्करण पर आधारित है, इसलिए सभी अंकगणित आमतौर पर एकात्मक प्रतिनिधित्व पर किए जाते हैं। रेटिना दशमलव पूर्णांक इनपुट ले सकता है और इसे पहले यूरीरी में बदल सकता है, लेकिन इसकी लागत 6 अतिरिक्त बाइट्स होती है, और जब तक चुनौती दशमलव निर्दिष्ट नहीं करती है, तब तक हमारी नीतियाँ एकरी इनपुट की अनुमति देती हैं। (अगर आपको दशमलव इनपुट लेने के लिए सभी उत्तरों की आवश्यकता होगी, तो विनिर्देश में ऐसा कहने के लिए स्वतंत्र महसूस करें और मैं अपना उत्तर अपडेट करूंगा।)
मार्टिन एंडर

नो नो इट्स ओके ^ ^ मैं सिर्फ उत्सुक इनपुट के बारे में उत्सुक था
लेविन्थ


6

जावा 7, 68 61 बाइट्स

int f(int n){return n>9?-~(n%9)*(int)Math.pow(10,n/9)-1:n+9;}

मोटे तौर पर एक ही बात के रूप में कई अन्य जवाब यहाँ है। स्ट्रिंग हेरफेर और लूप का उपयोग किए बिना जावा दृष्टिकोण दिखाना चाहता था।

FryAmTheEggman को याद दिलाने के लिए धन्यवाद कि मैं गूंगा हूं;)


कम से कम आप SQL outgolfed?
R

मेह, यहां सबसे अधिक अजगर / माणिक के जवाब से केवल दो बार बड़े हैं, इसलिए मुझे अभी जावा के लिए बहुत बुरा नहीं लगता है। हालांकि सी को हराकर अच्छा लगा होगा: पी
जियोबिट्स 16

: / उफ़, मुझे अपने वर्ग ब्लॉक से मिला। मुझे इस पर कठोर होना चाहिए।
जॉयबिट्स 17

@Geobits यह शायद C-- को हरा देगा।
gcampbell

@Fry पूरी तरह से उस चाल के बारे में भूल गया। धन्यवाद, कि मुझे सी से कम से कम आगे रखा;)
जोबिट्स 17

3

MATL , 10 9 बाइट्स

`QtV!UsG-

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

व्याख्या

`        % Do...while
  Q      %   Add 1. Takes input implicitly the first time
  t      %   Duplicate
  V!Us   %   To string, transpose, to number, sum. Gives sum of digits
  G-     %   Subtract input. If 0, the loop ends and the stack is implicitly displayed

1
V!Uमेरे से +1 का चतुर उपयोग । हमें MATL मुहावरों की सूची में जाना चाहिए।
स्वेअर

@ स्वेयर्स, कि अक्सर इस्तेमाल किया जाता है
लुइस मेंडो

3

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

n=>(n%9+1)*10**(n/9|0)-(n>9||-8)

ES6 के रूप में 38 बाइट्स:

n=>parseFloat(n%9+1+'e'+n/9)-(n>9||-8)

3

पायथन 3, 128 94 84 74 बाइट्स

उत्पादन के बिना, प्रत्यक्ष दृष्टिकोण, शुरुआत कोडरोलर;)

def r(n):
 m=n
 while 1:
  m+=1
  if sum(map(int,str(m)))==n:return(m)

1
शुरुआत के लिए, बहुत सारे स्थान हैं जिन्हें हटाया जा सकता है। उदाहरण से पहले / बाद = + ()।
13

1
इसके अलावा आप के print(m)साथ बदल सकते हैं return m(किसी भी बाइट नहीं बचा है, लेकिन आप समारोह में ही मुद्रित करने के लिए नहीं है)। आप अभी भी print(r(n))अपने फ़ंक्शन का परीक्षण करने के लिए आउटपुट फ़ंक्शन रिटर्न प्रिंट कर सकते हैं
लेवनथ

1
आप बहुत सारी नईलाइनों को हटा भी सकते हैं; m=n+1;f=1औरif s==n:f=0
ब्लू

1
रिटर्न के साथ प्रिंट को प्रतिस्थापित करते समय, आप इसे सीधे-स्टेटमेंट में कर सकते हैं और एफ के साथ-साथ अन्य स्टेटमेंट को भी हटा सकते हैं।
13

2
आप अभी भी f को हटा सकते हैं और केवल 1 का उपयोग कर सकते हैं और int (c) और के लिए स्थान भी निकाल सकते हैं
Emigna

2

दरअसल, 17 बाइट्स

╗1`;$♂≈Σ╜;)=)>*`╓

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

स्पष्टीकरण:

╗1`;$♂≈Σ╜;)=)>*`╓
╗                  save input to reg0
 1`;$♂≈Σ╜;)=)>*`╓  first integer n (>= 0) where:
   ;$♂≈Σ╜;)=         the base-10 digital sum equals the input and
            )>*      is greater than the input

यह उत्तर बहुत अच्छा है क्योंकि यह फ्लर्टी है ( ;))
निधि मोनिका का मुकदमा

2

सी 73 65 बाइट्स

एक सहायक समारोह के साथ एक मैक्रो।

e(y){return y?10*e(y-1):1;}
#define F(n) n<9?n+9:(1+n%9)*e(n/9)-1

eसमारोह सिर्फ दस की घात की गणना करता है, और Fमैक्रो के रूप में ही हल विधि का उपयोग करता इस गहरे लाल रंग का है, और इस अजगर जवाब। दुर्भाग्य से, यह है से अधिक समय में एक ही लंबाई के बारे में दोनों के रूप में उन सवालों के जवाब एक साथ रखा। लेकिन यह पहला C उत्तर है।

(लिन को हटाने की चाल से 8 बाइट बचाई गई int।)


आप int8 बाइट्स बचाते हुए , दोनों घटनाओं को छोड़ सकते हैं ।
लिन

2

ब्रेकीलॉग , 8 बाइट्स (गैर-प्रतिस्पर्धात्मक)

<.=:ef+?

= इस चुनौती को पोस्ट किए जाने के बाद संशोधित किया गया था, ताकि अब यह संभवतः अनंत डोमेन पर काम करे, जो कि यहां मामला है।

व्याख्या

<.       Output > Input
  =      Label the Output (i.e. unify it with an integer)
   :ef   Get the list of digits of the Output
      +? Input is the sum of all those digits

यह =तब तक पीछे रहेगा जब तक आउटपुट का मूल्य इस पूरे विधेय को सही नहीं बनाता।



1

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

lambda n:[n+9,(1+n%9)*10**(n/9)-1][n>9]

शुद्ध पूर्णांक अंकगणित।

आउटपुट के साथ पूरा कार्यक्रम

f=lambda n:[n+9,(1+n%9)*10**(n/9)-1][n>9]

print(f(2))
print(f(8))
print(f(12))
print(f(16))
print(f(17))
print(f(18))
print(f(24))
print(f(32))

आउटपुट:

11
17
39
79
89
99
699
5999

मुझे यह पसंद है कि यह सूत्रीकरण प्रमुख शून्य से बचता है।
नील

@ दूसरे का उपयोग करके इसे टाल सकते हैंeval
ब्लू

1

PowerShell v2 +, 62 बाइट्स

param($n)for($a=$n+1;([char[]]"$a"-join'+'|iex)-ne$n;$a++){}$a

इनपुट लेता है $nफिर एक forलूप निष्पादित करता है । हम अपने लक्ष्य की संख्या निर्धारित करके लूप को इनिशियलाइज़ करते हैं $a, जिससे कि एक बड़ा हो $n(क्योंकि यह बड़ा होना है, और यह 1..9सही ढंग से काम सुनिश्चित करता है)। प्रत्येक लूप हम बढ़ाते हैं $a++। लूप में कुछ भी उचित नहीं होता है, लेकिन सशर्त वह है जहां प्रोग्राम लॉजिक होता है। हम वस्तुतः लक्ष्य संख्या को एक स्ट्रिंग के रूप में ले रहे हैं, इसे एक चार-सरणी के रूप में कास्टिंग करते -joinहैं, सरणी को इसके साथ +जोड़ते हैं और फिर इसे iex(इसी तरह eval) पाइपिंग करते हैं । हम परीक्षण करते हैं कि हमारे इनपुट नंबर के बराबर है या नहीं, और तदनुसार लूपिंग जारी रखें। एक बार जब हम लूप से बाहर निकल जाते हैं, तो हम उस स्थान पर पहुँच जाते हैं जहाँ हमारा टारगेट नंबर हमारे इनपुट नंबर के बराबर होता है, इसलिए $aपाइप लाइन पर रखा जाता है और आउटपुट निहित होता है।


संदर्भ के लिए, यहां "9 के उपयुक्त संख्या के साथ एक स्ट्रिंग का निर्माण" विधि है जो अन्य लोगों ने 67 बाइट्स पर की है

param($n)(($n+9),(+(""+($n%9)+'9'*(($n/9)-replace'\..*'))))[$n-gt9]

या "शुद्ध पूर्णांक अंकगणितीय" विधि जो अन्य लोगों ने 70 बाइट्स में की है

param($n)(($n+9),("(1+$n%9)*1e$(($n/9)-replace'\..*')-1"|iex))[$n-gt9]

दोनों में से कोई भी छोटा नहीं है, लेकिन दोनों ही अधिक दिलचस्प हैं।


आप 3 बाइट्स बचा सकते हैं:param($n)for($a=$n+1;([char[]]"$a"-join'+'|iex)-$n){$a++}$a
mazzy

1

Pyke, 9 8 7 बाइट्स, गैर प्रतिस्पर्धा - का उपयोग करता है अधिक नया संस्करण

.fhsq)h

यहाँ यह कोशिश करो!

.f      - first where true:
  h     - n+1
   sq    - digital_root(^) == input()
      h - that number +1

फिर से परीक्षण किया गया, आपका समाधान 1 से 8 तक इनपुट के लिए सही आउटपुट नहीं देता है
levanth

मुझे लगता है कि मैंने इसे तोड़ दिया ... संख्या को छोड़कर काम करता है 1। Btw क्यों Missing arg to Equals, evaling inputआता है? मेरा मतलब है कि मैं इसे एक इनपुट नंबर देता
हूं

@levanth ऐसा इसलिए होता है क्योंकि डिफ़ॉल्ट रूप से वेब इंटरफ़ेस में चेतावनी चालू होती है। मैंने इसे बंद करने का एक तरीका कोडित किया है (जैसे 10 मिनट पहले)। क्योंकि यह 1 के लिए काम नहीं करता था, मैं यह देखने के लिए जाँच कर रहा था कि क्या संख्या 10 से बड़ी थी और यदि जारी है।
ब्लू

1

जावास्क्रिप्ट (ES2015), 45 39 33 बाइट्स

एक और 6 बाइट्स @Conor O'Brien और @Shaun एच को धन्यवाद दिया।
मुझे लगता है कि मैं इसे वैसे ही छोड़ दूंगा, क्योंकि यह संस्करण @ नील के उत्तर से भिन्न है String.repeat()

v=>+(v>9?v%9+'9'.repeat(v/9):v+9)

पिछला संस्करण (@Qwertiy के लिए 6 बाइट्स सहेजे गए):

f=v=>+(v/9>1?v%9+'9'.repeat(v/9|0):v+9)

पहला संस्करण:

f=v=>+(v/9>1?v%9+'9'.repeat(~~(v/9)):'1'+v-1)

1
~~(v/9)=> v/9|0, '1'+v-1=>v+9
१iy:५५ पर क्वर्टी

@Qwertiy बहुत बहुत धन्यवाद। मुझे बिटवाइज़ ऑपरेटरों के बारे में अधिक जानने की आवश्यकता है। दूसरे बदलाव के बारे में, ऐसा लगता है कि मैंने इस मामले को अधूरा कर दिया है v <= 9। मुझे लगता है कि अगर मैं सभी संख्यात्मक मूल्यों को वापस कर सकता हूं, जो कि एक अन्य बाइट-सेवर (कोई .repeat) (और) और + () में रिटर्न वैल्यू को लपेटकर हो सकता है।
लेब्रुग

आपको हमारे नियमों के अनुसार फ़ंक्शन को नाम देने की आवश्यकता नहीं है
Conor O'Brien

1
v>92 बाइट्स छोटा है, string.repeatएक दशमलव मान की |0आवश्यकता नहीं है
शॉन एच

**पाठ्यक्रम का उपयोग न करके भी मेरे उत्तर से अलग है ।
नील

1

लुआ, 52 बाइट्स

n=...+0
print(n>9 and(n%9)..string.rep(9,n/9)or n+9)

एक फ़ाइल में सहेजे जाने का मतलब है और लुआ दुभाषिया के साथ चल रहा है, जैसे lua <file> <input number>

आप इसे यहाँ भी आज़मा सकते हैं: https://repl.it/CXom/1

(Repl.it पर परीक्षण की आसानी के लिए इनपुट नंबर हार्ड-कोडित है)


'... + 0 ’क्या करता है ...? क्या यह एक पूर्णांक में इनपुट डालता है?
यति

1
हां, एक नंबर पर (Lua 5.3 से पहले केवल डबल्स का उपयोग किया गया था, जावास्क्रिप्ट की तरह)। लुआ स्वतः ही भावों में संख्याओं में बदल जाएगा, लेकिन तुलना नहीं। तो n>9ठीक से काम करने के लिए पहले एक नंबर के लिए मजबूर होना पड़ता है।
पिगुय

+1! समझा। तो ...+0>9काम करेगा?
यति

1
हां! यह :)
PiGuy

1

रैकेट 70 अक्षर, 71 बाइट्स

अन्य सभी के रूप में एक ही एल्गोरिथ्म बहुत ज्यादा। बहुत उदास होने के बारे में% modulo के लिए नहीं है, या ** के लिए expt, या डिफ़ॉल्ट रूप से पूर्णांक विभाजन, अन्यथा यह एक बहुत छोटा हो सकता है और मैं सी और जावा outgolfed हो सकता है। फिर भी भाषा से प्यार करते हैं

(λ(x)(if(> x 9)(-(*(+(modulo x 9)1)(expt 10(floor(/ x 9))))1)(+ x 9)))

1

हेक्सागोनी , 40 31 30 बाइट्स

<_:->.(.+><.'!.\@"9!%>!/{.}|.?

या, यदि आप अपने कोड को थोड़ा कम रैखिक और थोड़ा अधिक बहुभुज पसंद करते हैं:

    < _ : -
   > . ( . +
  > < . ' ! .
 \ @ " 9 ! % >
  ! / { . } |
   . ? . . .
    . . . .

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

कुछ विचारों और प्रेरणा के लिए @FryAmTheEggman का धन्यवाद: ओ)

पुराना वर्जन: <.:->+_.!(..'!.\><9!%>@.{.}|.?"

पूर्व संस्करण: <><.-_|@"'!{|(.9+!8=@>{/".'/:!?$.%\1$..\


1
यह काम करने लगता है? अभी भी गोल्फ दिखता है।
FryAmTheEggman

@FryAmTheEggman अच्छा काम! इसे पोस्ट करने के 2 मिनट बाद मैंने इसे करने का एक बेहतर तरीका सोचा, ठीक है, बहुत ज्यादा सब कुछ। टनल विजन, शायद? मैं एक संशोधित संस्करण पर काम कर रहा हूं।
सोक

धन्यवाद :) बस एक FYI करें लोग अक्सर गूढ़ प्रोग्रामिंग भाषाओं के कमरे में हेक्सागोनी के बारे में बात करते हैं । यदि आप चाहते हैं में शामिल हों :)
FryAmTheEggman


1

पर्ल 6 ,  38   29 बाइट्स

{$_>9??(1+$_%9)*10**Int($_/9)-1!!$_+9}
{first *.comb.sum==$_,$_^..*}

(प्रत्यक्ष रूप से प्रत्यक्ष दृष्टिकोण कम है)

स्पष्टीकरण:

{
  first
    *.comb.sum == $_, # lambda that does the check
    $_ ^.. *          # Range.new: $_, Inf, :excludes-min
}

परीक्षा:

#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
   2 => 11,
   8 => 17,
   9 => 18,
  12 => 39,
  16 => 79,
  18 => 99,
  24 => 699,
  32 => 5999,
);

plan +@tests;

my &next-digital-sum = {first *.comb.sum==$_,$_^..*}

for @tests -> $_ ( :key($input), :value($expected) ) {
  is next-digital-sum($input), $expected, .gist;
}
1..8
ok 1 - 2 => 11
ok 2 - 8 => 17
ok 3 - 9 => 18
ok 4 - 12 => 39
ok 5 - 16 => 79
ok 6 - 18 => 99
ok 7 - 24 => 699
ok 8 - 32 => 5999

1

जावा 10, 114 62 बाइट्स

n->{var r="";for(int i=0;i++<n/9;r+=9);return(n>9?n%9:n+9)+r;}

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

संपादित करें: 130 73 बाइट्स बिना प्रमुख शून्य ( @ levanth` के लिए धन्यवाद ):

n->{var r="";for(int i=0;i++<n/9;r+=9);return new Long((n>9?n%9:n+9)+r);}

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

स्पष्टीकरण:

n->                           // Method with integer parameter and long return-type
  var r="";                   //  Result-String, starting empty
  for(int i=0;i++<n/9;r+=9);  //  Append `n` integer-divided by 9 amount of 9's to `r`
  return new Long(            //  Cast String to number to remove any leading zeroes:
    (n>9?                     //   If the input `n` is 10 or larger
      n%9                     //    Use `n` modulo-9
     :                        //   Else (`n` is smaller than 10):
      n+9)                    //    Use `n+9`
    +r);}                     //   And append `r`

1
अगर कोई रुचि रखता है: ठीक सात बाइट्स लंबे समय तक हो सकता है, की जगह String c(int n){return""+(n>9?(n%9)+s(n):n+9);}के साथint c(int n){return Integer.parseInt((n>9?(n%9)+s(n):n+9));}
levanth

@levanth मैं इसे संपादित किया है Btw, आप भूल गया था। ""+मेंint c(int n){return Integer.parseInt(""+(n>9?(n%9)+s(n):n+9));}
केविन Cruijssen

1

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

यह एक int अंकगणितीय संस्करण है जो कि xnor के अजगर उत्तर के समान ही होता है। यह एक अनाम फ़ंक्शन है जो एक इंट ले और रिटर्न करता है।

->n{n<10?n+9:(1+n%9)*10**(n/9)-1}

मुझे पता नहीं है कि माणिक इतना है लेकिन - अनाम समारोह के प्रारंभ में -> है?
लेवंथ

@levanth: हाँ। मैं ऊपर स्पष्ट
करूँगा

N = 9
GB

@GB आपको इस ओर इशारा करने के लिए धन्यवाद देता है। यह अब तय हो गया है।
मेगाटॉम

1

मठगोल्फ , 8 7 बाइट्स

Æ)_Σk=▼

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

निहित इनपुट याय।

स्पष्टीकरण:

          Implicit input
 Æ     ▼  Do while false loop that pops the condition
  )       Increment top of stack
   _      Duplicate
    Σ     Get the digit sum
     k    Get input
      =   Is equal?
          Implicit output

मुझे पता है कि यह एक पुराना उत्तर है, लेकिन आप इसे 7 बाइट्स में अब निहित इनपुट (पहले छोड़ें k) के साथ हल कर सकते हैं ।
अधिकतम

0

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

f=->n{n<11?n+9:"#{n<19?n-9:f.(n-9)}9"}

यह उत्तर इनपुट आकार के आधार पर एक स्ट्रिंग या इंट देता है। यह एक पुनरावर्ती समाधान है जो 9 कम के लिए एक समाधान पूछता है फिर अंत में एक "9" जोड़ता है।


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

f=->n{n<11?n+9:(n<19?n-9:f.(n-9))*10+9}

एक और बाइट के लिए, यह उत्तर हमेशा एक इंट रिटर्न देता है। समान एल्गोरिथ्म ऊपर के रूप में लेकिन संख्याओं के साथ।




0

Oracle SQL 11.2, 165 बाइट्स

SELECT l FROM(SELECT LEVEL l,TO_NUMBER(XMLQUERY(REGEXP_REPLACE(LEVEL,'(\d)','+\1')RETURNING CONTENT)) s FROM DUAL CONNECT BY 1=1)WHERE s=:1 AND l!=s AND rownum=1;

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

SELECT l   
FROM   (
         SELECT LEVEL l, -- Number to evaluate
                XMLQUERY( 
                          REGEXP_REPLACE(LEVEL,'(\d)','+\1')  -- Add a + in front of each digit 
                          RETURNING CONTENT
                        ).GETNUMBERVAL()s                     -- Evaluate le expression generated by the added + 
                FROM DUAL 
                CONNECT BY 1=1 -- Run forever            
       )
WHERE s=:1      -- The sum must be equal to the input
  AND l!=s      -- The sum must not be the input 
  AND rownum=1  -- Keep only the first result

0

पायथन 3 55 बाइट्स

दो तर्क देता है कि एक ही हैं

f=lambda a,b:a if sum(map(int,str(a)))==b else f(-~a,b)

इसे कॉल करने के लिए आप f (x, x) का उपयोग करेंगे



0

पॉवरशेल, 54 बाइट्स

$args|%{(($_+9),+(''+$_%9+'9'*(($_-$_%9)/9)))[$_-gt9]}

टेस्ट स्क्रिप्ट:

$f = {

$args|%{(($_+9),+(''+$_%9+'9'*(($_-$_%9)/9)))[$_-gt9]}

}

@(
    ,(  1,  10   )
    ,(  2 , 11   )
    ,(  8 , 17   )
    ,(  9 , 18   )
    ,( 10,  19   )
    ,( 11,  29   )
    ,( 12 , 39   )
    ,( 16 , 79   )
    ,( 18 , 99   )
    ,( 19 , 199  )
    ,( 24 , 699  )
    ,( 27 , 999  )
    ,( 32 , 5999 )
    ,( 52 , 799999 )
    ,( 128, 299999999999999 )
) | % {
    $a,$e = $_
    $r = &$f $a
    "$($r-eq$e): $r"
}

आउटपुट:

True: 1 : 10
True: 2 : 11
True: 8 : 17
True: 9 : 18
True: 10 : 19
True: 11 : 29
True: 12 : 39
True: 16 : 79
True: 18 : 99
True: 19 : 199
True: 24 : 699
True: 27 : 999
True: 32 : 5999
True: 52 : 799999
True: 128 : 299999999999999

Expalantion

  • अगर [$_-gt9]पहला अंक और एक पूंछ देता है
    • पहला अंक $ _ और 9 के योग के बीच का अंतर है ( $_%9)
    • एक पूंछ कुछ नाइन है - '9'*(($_-$_%9)/9))
    • अंत में, परिणाम 0 को अग्रणी 0 को हटाने के लिए एक संख्या में परिवर्तित करता है
  • और लौटता है ($_+9)
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.