डिजिटल रूट प्रिंट करें

Question

^{यह माई वर्ड से अलग है जो आपके वर्ड को हरा सकता है क्योंकि यह कम जटिल है और केवल आपको इसकी गणना करने की आवश्यकता है, न कि उनकी तुलना करें।}

डिजिटल रूट को खोजने के लिए, किसी संख्या के सभी अंकों को लें, उन्हें जोड़ें, और तब तक दोहराएं जब तक कि आपको एक-अंकों की संख्या न मिल जाए। उदाहरण के लिए, अगर नंबर था 12345, आप जोड़ना होगा 1, 2, 3, 4, और 5, हो रही है 15। फिर आप जोड़ देते 1और 5आपको दे देते 6।

आपका कार्य

पूर्णांक एक को देखते हुए एन (0 <= एन <= 10000) के माध्यम से STDIN , के डिजिटल जड़ प्रिंट एन ।

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

1 -> 1
45 -> 9
341 -> 8
6801 -> 6
59613 -> 6
495106 -> 7

याद रखें, यह कोड-गोल्फ है , इसलिए सबसे कम संख्या में बाइट्स जीतता है।

Comments

हो सकता है कि इस चुनौती का एक सारांश ।

— nimi

इस चुनौती से बहुत निकटता से ... शायद एक डुप्लीकेट के लिए काफी करीब है।

— AdmBorkBork

कृपया जब कह रहे हों तो अधिक सटीक रहें number। विशेष रूप से। इनपुट 0का समर्थन किया जाना चाहिए ?

— टन हास्पेल

@ मुझे लगता है कि यह एक पूर्णांक रूपांतरण के लिए पत्र को जोड़ने के बिना बहुत क्लीनर चुनौती है, दो मूल्यों के लिए फ़ंक्शन की गणना और शाब्दिक सहित STALEMATE। इससे बेहतर होगा कि आप इसे दूसरे को बंद कर दें।

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

@MartinEnder मैंने अपने करीबी वोट को वापस ले लिया, मुझे लगता है कि किसी अन्य जटिल जटिल चुनौती के रूप में एक अच्छी चुनौती को बंद करना अनुचित है।

— आउटगॉल्फ

Answer 1

पाइके, 1 बाइट

s

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

इनपुट के डिजिटल रूट लेता है

Answer 2

जेली , 7 5 4 3 बाइट्स

ḃ9Ṫ

TryItOnline! या सभी परीक्षण मामलों

कैसे?

डिजिटल जड़ सूत्र (n-1)% 9 + 1 का पालन करने के लिए जाना जाता है।
यह जीवनी आधार 9 में अंतिम अंक के समान है
(और कार्यान्वयन के कारण 0ḃ9=[]और []Ṫ=0यह शून्य के किनारे-मामले को संभालता है)।

ḃ9Ṫ - Main link: n
ḃ9  - convert to bijective base 9 digits (a list)
  Ṫ - tail (get the last digit)

Answer 3

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

n=>--n%9+1

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

let f =

n=>--n%9+1

console.log(f(1)); // -> 1
console.log(f(45)); // -> 9
console.log(f(341)); // -> 8
console.log(f(6801)); // -> 6
console.log(f(59613)); // -> 6
console.log(f(495106)); // -> 7

Answer 4

MATL , 3 बाइट्स

9X\

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

परिणाम प्राप्त करने के लिए बहुत सारे (अब हटाए गए उत्तर) ने मोडुलो 9 का उपयोग करने की कोशिश की। यह एक शानदार शॉर्टकट है, लेकिन दुर्भाग्य से 9. के गुणकों के लिए काम नहीं करता है। MATL में अंतराल पर मॉडुलो के लिए एक फ़ंक्शन है [1, n]। इस modulo का उपयोग करना, हमारे पास है 1 % 3 == 1, 2 % 3 == 2, 3 % 3 == 3, 4 % 3 == 1, आदि यह उत्तर बस इस modulo का उपयोग करके इनपुट modulo नौ लेता है।

Answer 5

गणितज्ञ, 27 11 बाइट्स

Mod[#,9,1]&

Mathematica Modmodulo की परिणामी सीमा की भरपाई के रूप में एक तीसरा पैरामीटर लेता है। यह इनपुट घटने और आउटपुट को बढ़ाने से बचा जाता है।

Answer 6

पायथन, 16 20 बाइट्स

+4 बाइट्स शून्य के किनारे मामले को संभालने के लिए।

lambda n:n and~-n%9+1

repl.it

Comments

वाह। यह इतना आसान है कि इसे किसी भी भाषा में पोर्ट किया जा सकता है। आप यहां तक ​​कर सकते हैं~-input()%9+1

— कार्ल नैप

दुर्भाग्य से 0 के लिए काम नहीं करता है।

— एमिग्ना

@KarlNapf कि जरूरत नहीं होगी print?

— जोनाथन एलन

@ जोनाथनअल्लन आह, संभवतः। मैंने अभी REPL वातावरण में इसका परीक्षण किया और इसने यह किया।

— कार्ल नेफ ऑक्ट

@ अनाम उपयोगकर्ता जिसने संपादन का प्रयास किया है - उसने वास्तव में कोड को तोड़ दिया होगा (इसके बजाय 0परिणाम का एक इनपुट बनाया 9है 0, जिसे n andकोड के भाग के लिए पूरा किया गया है ) इसके अलावा इसे 19 बाइट्स नहीं 13 के रूप में गिना जाएगा चूंकि printऔर स्थान को गिना जाना चाहिए)।

— जोनाथन एलन

Answer 7

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

!n=mod1(n,9)

या

n->mod1(n,9)

mod1एक विकल्प है modजिसके [1, n]बजाय सीमा के लिए नक्शे [0, n)।

Answer 8

PHP, 15 बाइट्स

<?=--$argn%9+1;

पिछला संस्करण PHP, 55 बाइट्स

$n=$argn;while($n>9)$n=array_sum(Str_split($n));echo$n;

Comments

बिल्कुल मैंने इसे कैसे किया!

— 14:14 बजे CT14.IT

@ CT14.IT यदि आप चाहें तो मैं इस पोस्ट को हटा सकता हूं। 1 मिनट पहले आपकी डिलीट की गई पोस्ट ws और आप केवल लूप को भूल गए हैं

— Jörg Hülsermann

नहीं हटाए गए उत्तर को गलत था क्योंकि मैंने शुरू करने के लिए प्रश्न को ठीक से नहीं पढ़ा था, मैंने उत्पन्न संख्या

— CT14.IT

आप अन्य उत्तरों की चाल जोड़ सकते हैं<?=--$argv[1]%9+1?>

— क्रिप्टो

Answer 9

हास्केल, 35 34 बाइट्स

until(<10)$sum.map(read.pure).show

Ideone पर इसे आज़माएं।

स्पष्टीकरण:

until(<10)$sum.map(read.pure).show
                              show  -- convert int to string
               map(         ).      -- turn each char (digit) into
                        pure        --    a string 
                   read.            --    and then a number
           sum.                     -- sum up the list of numbers
until(<10)$                         -- repeat until the result is < 10

Answer 10

पर्ल, 15 बाइट्स

के लिए +2 शामिल है -lp

STDIN पर इनपुट दें

root.pl <<< 123

root.pl

#!/usr/bin/perl -lp
$_&&=~-$_%9+1

यह उबाऊ समाधान है जो पहले से ही कई भाषाओं में दिया गया है, लेकिन कम से कम यह संस्करण 0भी समर्थन करता है

अधिक दिलचस्प वास्तविक दोहराए जाने वाले अतिरिक्त (हालांकि एक अन्य क्रम में) वास्तव में केवल 1 बाइट लंबा है:

#!/usr/bin/perl -p
s%%$_+=chop%reg

Answer 11

आर, 72 67 29 बाइट्स

संपादित करें: दो बाइट्स बंद करने के लिए @rturnbull का धन्यवाद।

n=scan();`if`(n%%9|!n,n%%9,9)

Comments

मैंने हाल ही में सीखा है कि ifelseइसे `if`समान व्यवहार के साथ बदला जा सकता है, जो आपको कुछ बाइट्स बचाता है।

— rturnbull

@rturnbull मैं हमेशा सोच रहा था कि कैसे ` if` काम किया। क्या आप एक उदाहरण दे सकते हैं या शायद इसे गोल्फ में शामिल

— बिलीवॉब

इसे समझने का सबसे सरल तरीका यह है कि यह एक गैर-वेक्टरकृत है ifelse। इस स्थिति में, `if`(n%%9|!n,n%%9,9)आपके द्वारा पोस्ट किए गए कोड के समान व्यवहार प्रदान करता है। जहाँ तक मैं बता सकता हूँ, यह व्यवहार अनिर्दिष्ट है! मैं सुझाव थ्रेड में एक टिप्पणी जोड़ूंगा।

— rturnbull

Answer 12

रेटिना , 7 बाइट्स

{`.
*
.

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

मैं बहुत सारे गणितीय समाधान देखता हूं, लेकिन रेटिना में सीधा दृष्टिकोण सबसे अच्छा लगता है।

व्याख्या

{`जब तक स्ट्रिंग अब और नहीं बदलती, तब तक पूरे कार्यक्रम को एक लूप में चलाया जाता है। लूप में दो चरण होते हैं:

.
*

प्रत्येक अंक को एकात्मक में बदलें।

.

वर्णों की संख्या की गणना करें (= यूनिरी संख्या को दशमलव में बदलें)।

यह काम करता है क्योंकि अंकों के बीच कोई विभाजक नहीं होने के साथ प्रत्येक अंक को एकजुट करने के लिए एक एकल संख्या बनाता है जो सभी अंकों के योग के बराबर है।

Answer 13

ब्रेकीलॉग , 9 बाइट्स

#0|@e+:0&

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

व्याख्या

#0            Input = Output = a digit
  |           OR
   @e         Split the input into a list of digits
     +        Sum
      :0&     Call this predicate recursively

वैकल्पिक दृष्टिकोण, 11 बाइट्स

: मैं: {@ ई +} मैं # 0

यह एक मेटा-विधेय का उपयोग करता है i - Iterateकॉल करने के लिए Iविधेय बार {@e+}इनपुट पर। यह अनंत Iसे 0लेकर तब तक के मूल्यों की कोशिश करेगा जब तक कि कोई इसे नहीं बनाता है ताकि आउटपुट iएक एकल अंक हो जो #0सच हो।

Answer 14

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

सहेजे गए 3 बाइट्स, बेसड्रॉप कंबरवॉबुवब के लिए धन्यवाद

लेता है और एक स्ट्रिंग लौटाता है।

f=s=>s[1]?f(''+eval([...s].join`+`)):s

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

f=s=>s[1]?f(''+eval([...s].join`+`)):s

console.log(f("1")); // -> 1
console.log(f("45")); // -> 9
console.log(f("341")); // -> 8
console.log(f("6801")); // -> 6
console.log(f("59613")); // -> 6
console.log(f("495106")); // -> 7

Comments

आप बदल सकते हैं s.split``करने के लिए[...s]

— Bassdrop Cumberwubwubwub

Answer 15

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

r{:~:+_s\9>}g

दुभाषिया

स्पष्टीकरण:

r{:~:+_s\9>}g Code
r             Get token
 {:~:+_s\9>}  Block: :~:+_s\9>
   ~          Eval
  :           Map
     +        Add
    :         Map
      _       Duplicate
       s      Convert to string
        \     Swap
         9    9
          >   Greater than
            g Do while (pop)

-6 बाइट्स के लिए 8478 (मार्टिन एंडर) को धन्यवाद।

---

सीजाम, 6 बाइट्स

ri(9%)

8478 (मार्टिन एंडर) द्वारा सुझाया गया। दुभाषिया

मैं इसके बारे में सोच रहा था, लेकिन मार्टिन ने इसे मेरे सामने ला दिया। स्पष्टीकरण:

ri(9%) Code
r      Get token
 i     Convert to integer
  (    Decrement
   9   9
    %  Modulo
     ) Increment

Comments

सिंगल-कमांड मैप और कम दोनों को उपसर्ग के साथ लिखा जा सकता है :, इसलिए आप कर सकते हैं :~:+। यह ब्लॉक को चलाने के लिए कम से कम एक बार चोट नहीं करता है ताकि आप gलूप के बजाय लूप का उपयोग कर सकें w।

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

@MartinEnder r{_,1>}{:~:+`}wकाम करता है, लेकिन मुझे नहीं पता कि पृथ्वी पर मैं gयहाँ कैसे उपयोग करने वाला हूँ ।

— ऑर्गन आउटगॉल्फ

जैसे इस: r{:~:+_s\9>}g(बेशक बंद फार्म समाधान ri(9%)बहुत छोटा है।

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

@MartinEnder ओह गॉड, अब असली के लिए, मैं ऐसी शुरुआत कर रहा हूं ...

— एरिक आउटोलॉफ़र

दूसरा कोई 9 के गुणकों पर काम नहीं करता है

— ThePlasmaRailgun

Answer 16

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

int f(int n){int s=0;for(;n>0;n/=10)s+=n%10;return s>9?f(s):s;}

पुनरावर्ती कार्य जो केवल mod / div के साथ अंक प्राप्त करता है। कुछ भी आकर्षक नहीं।

सस्ता बंदरगाह

के जोनाथन एलन की एक नाममात्र 28 बाइट्स होगा:

int f(int n){return~-n%9+1;}

Answer 17

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

i=input()
while~-len(i):i=`sum(map(int,i))`
print i 

3 बाइट्स बचाने में मेरी मदद करने के लिए ओलिवर और कार्ल नैफ का धन्यवाद

Comments

आप एक बाइट को बचाने के while len(i)>1लिए बदल सकते हैं while~-len(i)।

— ओलिवर नी

मुझे लगता है कि आप टिक्स को चारों ओर छोड़ सकते हैं input()और इनपुट को 2 बाइट्स को बचाने के लिए उद्धरणों में संलग्न किया जा सकता है।

— कार्ल नेफ ऑक्ट

@KarlNapf मुझे नहीं लगता कि इनपुट के पूर्णांक होने पर आप ऐसा कर सकते हैं।

— आउटगॉल्फ

@EriktheGolfer, सेशन ने कहा कि इनपुट को स्ट्रिंग के रूप में लिया जा सकता है

— डैनियल

Answer 18

पायथन, 45 बाइट्स

f=lambda x:x[1:]and f(`sum(map(int,x))`)or x

तर्क को एक तार के रूप में लेता है।

Answer 19

05AB1E , 6 बाइट्स

[SODg#

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

व्याख्या

[        # infinite loop
 S       # split into digits
  O      # sum digits
   Dg#   # if length == 1: break

Answer 20

सी, 64 29 बाइट्स

जोनाथन एलन के उत्तर से सी पोर्ट (विशेष मामले के साथ 0)।

f(i){return i>0?~-i%9+1:0;}

पिछला 64 बाइट कोड:

q(i){return i>9?i%10+q(i/10):i;}
f(i){i=q(i);return i>9?f(i):i;}

qक्रॉस योग लेता है और fएकल अंक तक क्रॉस योग को दोहराता है।

Answer 21

रेटिना , 15 बाइट्स

.+
$*
1{9}\B

1

इसे ऑनलाइन आज़माएं!(पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

व्याख्या

.+
$*

इनपुट को यूनीरी में बदलें।

(1{9})*\B

1-आधारित मॉडुलो को उन नाइनों को हटाकर लें जिनके बाद कम से कम एक और चरित्र है।

1

दशमलव में वापस बदलने के लिए 1s की शेष संख्या की गणना करें।

Answer 22

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

{($_,*.comb.sum...10>*)[*-1]}

विस्तारित:

{ # bare block lambda with implicit parameter ｢$_｣
  ( # generate a sequence

    $_,         # starting with the input
    *.comb.sum  # Whatever lambda that splits into digits, and finds sum
    ...         # keep doing that
    10 > *      # until it is less than 10

  )[ * - 1 ] # get the last value
}

Answer 23

फ़ैक्टर , २४

स्मार्ट , मैथी जवाब।

[ neg bitnot 9 mod 1 + ]

गूंगा पुनरावृत्ति समाधान के लिए 63 :

[ [ dup 9 > ] [ number>string >array [ 48 - ] map sum ] while ]

Answer 24

भूलभुलैया , 8 बाइट्स

?(_9%)!@

समीकरण का उपयोग करना (n-1)%9+1:

• ? इनपुट को दशमलव के रूप में पढ़ता है और इसे स्टैक पर धकेलता है
• ( स्टैक के शीर्ष को घटाता है
• _ स्टैक के शीर्ष पर एक शून्य को धकेलता है
• 9 स्टैक के शीर्ष को 10 बार पॉप पॉप करें (इस मामले में, 9)
• % pops y, pops x, x% y को धक्का देता है
• ) ढेर के ऊपर वेतन वृद्धि
• ! स्टैक के शीर्ष को पॉप करता है और बाहर दशमलव स्ट्रिंग के रूप में डालता है
• @ कार्यक्रम को समाप्त करता है

Answer 25

पायथ - 7 4 6 7 बाइट्स

सबसे अच्छा नहीं है, लेकिन अभी भी जवाब की एक सभ्य राशि धड़कता है:

|ejQ9 9

पिछले संस्करण की तरह, लेकिन तार्किक या का उपयोग करके 9 के गुणकों के मामलों को भी संभालना।

---

यह संस्करण 45 परीक्षण विफल रहता है :

ejQ9

स्पष्टीकरण:

 jQ9  -> converting the input to base 9
e     -> taking the last digit

इसे यहाँ आज़माएँ

पिछले संस्करण की कोशिश यहाँ!

---

पिछले समाधान:

&Qh%tQ9

स्पष्टीकरण :

    tQ    -> tail: Q-1
   %tQ9   -> Modulo: (Q-1)%9
  h%tQ9   -> head: (Q-1)%9+1
&Qh%tQ9   -> Logical 'and' - takes the first null value. If Q is 0 - returns zero, otherwise returns the (Q-1)%9+1 expression result

आप इसे यहाँ आज़माने के लिए आमंत्रित हैं !

Comments

आपका 4-बाइट संस्करण परीक्षण केस 45 को विफल करता है ।

— डेनिस

क्या यह 9 के गुणकों के लिए 0 नहीं देगा?

— xnor

हाँ, मैंने अभी गौर किया। वहां कुछ फिक्सिंग करेंगे। जाहिर है, jQ9जेली की तरह काम नहीं करता है ḃ9:-P

— Yotam सामन

Answer 26

APL (Dyalog) , 15 9 बाइट्स बाइट्स

××1+9|-∘1

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

Answer 27

हेक्सागोनी, 19 15 बाइट्स

.?<9{(/>!@!/)%' 

अधिक पठनीय:

  . ? < 
 9 { ( /
> ! @ ! / 
 ) % ' .
  . . . 

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

-3 बाइट्स एक अलग दृष्टिकोण लेकर, 0 किनारे के मामले को तुच्छ बनाते हैं।
0 बाइट केस बग फिक्स करके -1 बाइट

सूत्र ((n-1) mod 9) + 1 का उपयोग करके बहुत सारे अन्य समाधानों की तरह।

Answer 28

के (ओके) , 9 बाइट्स

समाधान:

(+/.:'$)/

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

स्पष्टीकरण:

सुपर सीधा। अंकों को अंकों में विभाजित करें और योग करें - ऐसा तब तक करें जब तक परिणाम परिवर्तित न हो जाए:

(+/.:'$)/ / the solution
(      )/ / do this until result converges
      $   / string, 1234 => "1234"
   .:'    / value each, "1234" => 1 2 3 4
 +/       / sum over, 1 2 3 4 => 10

Comments

K के मेरे कार्यान्वयन में मैंने आधार को आवश्यक कई अंकों के साथ x\yसांकेतिक शब्दों yमें बदलना x, इसलिए यह थोड़ा कम है:(+/10\)/

— ngn

अच्छा लगा। Kdb + के नए संस्करणों में (मुझे लगता है कि 3.4 और ऊपर से) आप कर सकते हैं 10\:.. लेकिन ओके में नहीं - और .:'$बाइट्स की एक ही संख्या है - इसलिए मैं उस के साथ चला गया :)

— स्ट्रीटस्टर

oK \ _ का उपयोग करता है और उसे बाईं ओर एक सूची की आवश्यकता होती है: `(, 10)`

— ngn

वास्तव में, आपका कार्यान्वयन "आवश्यक के रूप में कई अंकों" को जोड़ता है, जो कि आपको \:kdb + (3.4+) से मिलता है , लेकिन ओके के लिए मुझे यह जानना होगा कि मेरी सूची में कितने 10s हैं।

— स्ट्रीटस्टर

Answer 29

केजी , 6 बाइट्स (केबीसी विकी पर SBCS)

¿;9%1+

स्पष्टीकरण:

¿#      Take implicit input
 ;9%1+# Digital Root Formula
# Implicit output

Answer 30

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

->n{~-n%9+1}

Comments

19? ऐसा नहीं होना चाहिए 9?

— टन हास्पेल

@ टोनहोस हां, बेवकूफ त्रुटि: पी

— टक्स क्राफ्टिंग