लापता संख्या क्या है (9 से विभाज्यता)

22

चुनौती

9 और एक लापता अंक द्वारा विभाजित पूरी संख्या को देखते हुए, लापता अंक का पता लगाएं।

लापता अंक को किसी भी वर्ण द्वारा 0-9 अंकों के अलावा तब तक दर्शाया जा सकता है जब तक यह सुसंगत है।

यदि अनुपलब्ध अंक 0 या 9 हो सकता है, तो ऐसा संकेत देने के लिए कुछ आउटपुट करें।

मान लें कि उपयोगकर्ता केवल एक लापता अंक और एक संख्या आदि डालने के लिए पर्याप्त बुद्धिमान है।

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

परीक्षण मामलों में गुम अंक को एक प्रश्न चिह्न द्वारा दर्शाया जाता है

123? -> 3
?999 -> 0 or 9
?0023 -> 4
000?1 -> 8
code-golf  math  arithmetic 
— NK1406
स्रोत
2
क्या हम उत्पादन कर सकते हैं 0? [0, 9] (2 संख्याओं की सरणी या सूची) के बारे में क्या ?
— user202729
1
मान लीजिए कि आपको 0 या 9 के बजाय मतलब है, मुझे लगता है कि मैं किसी भी मूल्य को इंगित करने के लिए इस आवश्यकता को संपादित करूंगा। धन्यवाद!
— NK1406 15
3
क्या सिर्फ ?एक संभावित इनपुट है?
— xnor
2
क्या प्रमुख शून्य का समर्थन करना आवश्यक है?
— mbomb007
1
@ NK1406 मुझे अग्रणी शून्य की आवश्यकता नहीं है, मैं कुछ भाषाओं के लिए कम से कम इसका समर्थन करने के लिए आवश्यक अतिरिक्त बाइट्स देख सकता हूं।
— एरिक आउटफोलर

जवाबों:

9

ऐलिस , 12 बाइट्स

/o&
\i@/+R9%

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

0यदि परिणाम 0 या 9 हो सकता है तो आउटपुट ।

व्याख्या

/   Switch to Ordinal mode.
i   Read all input as a string.
&   Fold the next operation over the characters of this strings.
/   Switch to Cardinal mode (not an operation).
+   Add. Implicitly converts each character to the integer value it represents
    and adds it to the top of the stack. The top of the stack is initially, implicitly
    zero. When the character is "?", it is simply discarded, which adds the top of
    the stack to another implicit zero beneath, so the "?" is effectively skipped.
R   Negate. Multiplies the sum by -1.
9%  Modulo 9. This gives the result.
\   Switch to Ordinal mode.
o   Implicitly convert the result to a string and print it.
@   Terminate the program.
— मार्टिन एंडर
स्रोत
&, हटाया जा सकता है के बाद से कार्डिनल मोड सबसे 2 पूर्णांकों में के रूप में मूल इनपुट व्याख्या करता है।
— नाइट्रोडन
6

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

आउटपुट 9 अगर 0 या 9 हो सकता है। 

f=_=>9-([..._].reduce((a,b)=>a+~~b,0)%9)
— क्विंटन मिलर
स्रोत
2
PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!
— R
2
आपको गिनने की जरूरत नहीं है f=; अनाम फ़ंक्शन पूरी तरह से मान्य हैं।
— झबरा
ऑपरेटर पूर्वता के कारण सबसे बाहरी कोष्ठक आवश्यक नहीं हैं;)
— शायरु असाकोतो
5

जाप, 7 बाइट्स

कुछ समाधानों की कोशिश की, लेकिन सबसे कम अन्य लोगों के समान था सिवाय इसके कि हमें ?शुरुआत में बदलने की आवश्यकता नहीं है ।

लापता अंक के रूप में किसी भी गैर-संख्यात्मक चरित्र को ले सकते हैं। आउटपुट 0जब समाधान हो सकता है या 9।

¬x*J u9

कोशिश करो

व्याख्या

स्ट्रिंग का निहित इनपुट U। ¬अलग-अलग वर्णों की एक सरणी को विभाजित करता है, xकिसी भी गैर-संख्यात्मक तत्वों की अनदेखी करके सरणी को कम करता है, *Jप्रत्येक तत्व को -1 से गुणा करता है और u9परिणाम का सकारात्मक मापांक प्राप्त करता है।

— झबरा
स्रोत
5

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

+लापता अंक के रूप में की उम्मीद है । 0 या 9 के9 लिए रिटर्न ।

s=>9-eval(9+s+9)%9

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

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
4

पायथन 2 , 44 41 35 बाइट्स

-6 बाइट्स रियाद के लिए धन्यवाद 

lambda n:-sum(ord(c)-3for c in n)%9

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

उपयोगकर्ता ]लापता अंक के लिए।
आउटपुट 0यदि अनुपलब्ध अंक 0 या 9 हो सकता है।

— छड़ी
स्रोत
हम्म, सभी परीक्षण मामलों में मैंने इसे 0एक अस्पष्ट मामले के लिए आउटपुट देने की कोशिश की , जिससे समझ में आता है9%9 == 0
— शराबी
यदि आप int (c) -> ord (c) - 3 करते हैं, जिसकी आपको आवश्यकता नहीं है, यदि आप खराब चरित्र के लिए उपयुक्त चरित्र का चयन करते हैं
— RIAD
3

अजगर, ९ 9 बाइट्स

%_s-Qd9

परिसीमन के रूप में स्थान का उपयोग करता है और यदि परिणाम 0 या 9 हो सकता है तो 0 देता है।

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

व्याख्या

%_s-Qd9
   -Qd   Remove the space from the input.
  s      Convert it to an integer.
%_    9  Negate mod 9.
3

प्रोलॉग (एसडब्ल्यूआई) , 59 बाइट्स

0*[].
X*[H|T]:-between(0,9,H),U is mod(X+H,9),U*T.
+X:-0*X.

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

तार्किक प्रोग्रामिंग के लिए याय!

व्याख्या

पहले हम एक विधेय बनाते हैं * , जो शून्य और रिक्त सूची में लागू होने पर धारण करता है। हमारा विधेय तब भी धारण करता है जब सूची का सामने 0 और 9 के बीच होता है और जब हम अग्रणी अंक mod ​​9 जोड़ते हैं तो विधेय धारण करता है।

हम तो पहले तर्क के रूप में +इस विधेय को परिभाषित करते हैं 0। हम चाहते हैं कि डिजिटल योग 9 का गुणज हो।

प्रोलोग वास्तव में हमारे लिए समाधान खोजने के सभी गंभीर काम करता है।

— गेहूं का जादूगर
स्रोत
3

बेफुज -93 , 16 बाइट्स

1+!_#@3#.--9%~:#

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

जेम्स होल्डरनेस की एक पंक्ति संस्करण 'बेफुन्ज का जवाब है कि दो बाइट्स से दाढ़ी बनाने का प्रबंधन करता है। यह अनिवार्य रूप से कोड को एक पंक्ति में संकुचित करता है, दिशा को उलट देता है और इस तथ्य का लाभ उठाता है कि Befunge लाइन के अंत में नहीं छोड़ता है। उन्होंने सुझाव दिया कि मैं एक स्पष्टीकरण के साथ एक अलग उत्तर पोस्ट करता हूं। कोड लापता अंक का प्रतिनिधित्व करने के रूप में एक * लेता है और 0 या 9 के लिए 9 आउटपुट देता है।

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

1+!_  3  --9% Initialises the pointer going right and initialises the digitsum with 3

1+!_         ~: Gets input and checks whether it is end of input (-1)

      3  - Subtract three from the input. 
           This turns the ASCII values of digits into their mod 9 equivalent ("0"(48)=>45(mod 9)=>0)

          -9% Subtract the value from the digitsum and mod it with 9
              This keeps the digitsum as a negative digit greater than -9
              Repeat this until the input ends

Now this is where it gets tricky.
At the end of input, the stack looks like this:
  -(Digitsum%9), Copy of EOF input (-1)
The pointer is moving left from the _
 +!_ Invert the -1 to get 0 and add it to the digitsum (does nothing but get rid of the -1)
1           %~ Adds 1 mod -1 (no input) = 0 to the stack
         --9 Subtracts 9 from 0, yielding -9 and subtracts that from the digitsum. 
             This makes the digitsum positive and equal to 9-(digitsum%9), our desired value
     @  . Finally, print and exit

* (ASCII मान 42) को लापता चरित्र के रूप में चुना गया था क्योंकि यह अंक 3 के प्रारंभिक मूल्य का प्रतिकार करता है।

— मजाक कर रहा है
स्रोत
मुझे आश्चर्य है कि आप अभी भी इस से बाइट्स निचोड़ कर रख सकते हैं। बहुत बढ़िया!
— जेम्स होल्डरनेस
2

LaTeX, कई बाइट्स ( 1000 628 614)

\RequirePackage{expl3}
\ExplSyntaxOn
\tl_new:N \l_divnine_input_tl
\int_new:N \l_divnine_sum_int
\def \getnum {
  \typein [ \l_divnine_input_tl ] { Input\space a\space number }
  \tl_map_function:NN \l_divnine_input_tl \divnine_sum:n
  \int_set:Nn \l_tmpa_int { 9 - \int_mod:nn { \l_divnine_sum_int } { 9 } }
  \typeout
    { The\space missing\space digit\space is:\space
      \int_use:N \l_tmpa_int
      \int_compare:nNnT { \l_tmpa_int } = { 0 } { \space or\space 9 }
    }
}
\cs_new:Nn \divnine_sum:n {
  \regex_match:nnT { \d } { #1 } { \int_add:Nn \l_divnine_sum_int { #1 } }
}
\ExplSyntaxOff
\getnum
\stop

LaTeX, अवैध ( 348 334 बाइट्स)

\RequirePackage{expl3}\ExplSyntaxOn\int_new:N\1\tl_new:N\2\def\3{\typein[\2]{Input\space a\space number}\tl_map_function:NN\2\4\int_set:Nn\1{9-\int_mod:nn{\1}{9}}\typeout{The\space missing\space digit\space is:\space\int_use:N\1\int_compare:nNnT{\1}={0}{\space or\space9}}}\def\4#1{\regex_match:nnT{\d}{#1}{\int_add:Nn\1{#1}}}\3\stop

लाटेक्स, 132 बाइट्स

\RequirePackage{expl3}\typein[\1].\newcount\2{\ExplSyntaxOn\int_gset:Nn\2{9-\int_mod:nn\19}}\typeout{\the\2 \ifnum\2=9or 0\fi}\stop

इस कोड में अज्ञात स्थान के रूप में केवल स्थान की अनुमति है।

— Skillmon
स्रोत
2

जे , 14 12 बाइट्स

-2 बाइट्स @BolceBussiere को धन्यवाद

9|9-[:+/"."0

मैं ईमानदारी से नहीं जानता कि क्यों 0 के रूप में "."0व्याख्या ?करता है, लेकिन यह मेरे दुभाषिया पर और TIO पर ऐसा करता है इसलिए मैं इस पर सवाल नहीं उठा रहा हूं। (अपडेट: स्पष्टीकरण के लिए टिप्पणियां देखें क्यों)।

यह दृष्टिकोण बहुत ही सरलता से अंकों का योग बनाता है, इसे 9 से घटाकर नकारता है और इसे मोडुलो 9 लेता है।

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

— गोभी
स्रोत
1
आपको योग करने से पहले
— उठने की
1
इसके अलावा, "व्याख्या नहीं करता है? ' 0 के रूप में, यह इसे एक खाली सूची के रूप में व्याख्या करता है। इसे फिट बनाने के लिए, जे इसे फिलर के पात्रों के साथ पैड करता है, जो इस मामले में (एक संख्यात्मक सरणी) 0. है
— बोल्से बस्सेरी
2

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

|0SN%9

व्याख्या

|0     # Read input while removing non-digits (question marks) and removing leading zeros
  S    # Sum the digits
   N   # Negate
    %9 # Mod by 9

0 के आउटपुट का मतलब है कि परिणाम 0 या 9 हो सकता है।

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

2 एक्स बाइट्स को श्री एक्सकोडर के लिए धन्यवाद । €मूल्यांकन के दौरान प्रत्येक त्वरित ( ) का उपयोग करते समय , अंकों को अंकों में विभाजित करना अनावश्यक था।

डेनिस की बदौलत 3 बाइट्स बचाए । प्रमुख शून्य और गैर-अंकों को हटाते समय इनपुट को मैन्युअल रूप से पार्स करने के बजाय 0 के साथ बिटवाइज़ या इनपुट कर सकते हैं।

— प्रहार
स्रोत
9 बाइट्स । जेली गोल्फ में आपका स्वागत है!
— मिस्टर एक्सकोडर
यह उस मामले को नहीं संभालता जहां जवाब 0 या 9 हो सकता है। इसके अलावा, वास्तव में, जेली में आपका स्वागत है। मैं भी नया हूँ लेकिन यह अब तक बहुत मज़ेदार है।
— डायलन
@dylnan ने इसे संबोधित किया
— Poke
@ ओह, कोई बात नहीं, मैंने देखा कि आवश्यकता नहीं बदली गई थी
— डायलन डिक
|0के बजाय काम करता है fØDV€।
— डेनिस
1

बेफ़ुंज -93 (PyFunge) , 22 21 बाइट्स

मैंने महसूस किया कि मुझे ?अनुपस्थित अंक का प्रतिनिधित्व करने के लिए उपयोग करने की आवश्यकता नहीं है , इसलिए मैंने 48 को घटाने के बाद 9 में से एक का उपयोग किया है: x
यह मुझे गोल्फ से दूर कर देता है 3+, लेकिन इसने मुझे केवल 1 बाइट की वजह से बचाया। सशर्त से पहले पहली पंक्ति :(

मेरी Befunge-98 उत्तर का एक बंदरगाह:
5 अधिक आदेश की जाँच करने में बाइट्स अगर हम EOF, पहुँच गए हैं
1 अधिक बाइट पुश करने के लिए 48 ( "0"बनाम '0),
के साथ जवाब मुद्रित करने के लिए 1 और बाइट .@,
तथा 1 और बाइट, क्योंकि दूसरा लाइन में
कुल 8 और बाइट्स के लिए जगह है।

~:0`!#|_"0"-+
 @.%9-<

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

आउटपुट 0यदि अनुपलब्ध अंक 0 या 9 हो सकता है।

यह केवल नीचे बताए गए कारणों के लिए PyFunge दुभाषिया में काम करता है।

व्याख्या

इस स्पष्टीकरण का अधिकांश भाग मेरे बेफ़ुंज -98 स्पष्टीकरण से कॉपी-पेस्ट किया गया है , क्योंकि यह कार्यक्रम इस से मिलता-जुलता है। बेशर्म प्लग

कार्यक्रम की पहली पंक्ति में, हम एक्स सहित अंकों को जोड़ते हैं, जो कि एएससीआईआई मान के कारण 72 की तरह व्यवहार किया जाता है। हालाँकि, हम 9 द्वारा modded किए जाने के बाद योग एक ही होगा, इसलिए यह अप्रासंगिक है।

~:0`!#|_"0"-+    THE FIRST LINE
~                Gets a character from input - If it is negative, we've reached EOF
 :0`!            Pushes 0 if the character is positive, 0 otherwise
     #|_         Goes to the next line if the value if 0
                     This also gets the negative value off the stack by using a |
        "0"-     Subtracts 48 to account for taking in ASCII values
            +    Adds this adjusted value to the sum

यदि हम केवल 9 द्वारा modded हैं, तो हम गलत अंक के साथ छोड़ दिए जाएंगे, क्योंकि हम चाहते हैं 9 - (sum % 9)। हालांकि, हम इससे बेहतर कर सकते हैं 9\-, जो 9 से शेष को घटाएगा: यदि हम 9 से मॉडिंग करने से पहले नकारात्मक बनाते हैं, तो हम 9 - (sum % 9)कुछ दुभाषियों के बराबर एक सकारात्मक परिणाम प्राप्त करेंगे । यह वही है जो हमें Befunge 93 और 98 दोनों के लिए PyFunge दुभाषियों का उपयोग करने की आवश्यकता है, क्योंकि यह TIO पर एकमात्र है जो ऐसा करता है। दूसरे हमें 0 और 8 के बजाय -8 और 8 के बीच का मान देते हैं

 @.%9-<    THE SECOND LINE
      <    Redirects the IP onto this line
     -     Subtracts the sum from an implicit 0, making it negative
   %9      Mods the sum by 9
 @.        Prints the digit and exits
— MildlyMilquetoast
स्रोत
अच्छा जवाब! अतिरिक्त जांच से बचने के लिए लापता अंक के लिए एक कस्टम वर्ण का उपयोग करने के बारे में कभी नहीं सोचा। मुझे आशा है कि आपको कोई आपत्ति नहीं है कि मैंने अपने अद्यतन उत्तर में वह चाल चुरा ली है - मैं यह देखना चाहता था कि क्या मुझे संदर्भ दुभाषिया में काम करने वाली एक ही अवधारणा मिल सकती है।
— जेम्स होल्डरनेस
1

बेफ़ुंज -98 (PyFunge) , 15 13 बाइट्स

मैंने महसूस किया कि मुझे ?अनुपस्थित अंक का प्रतिनिधित्व करने के लिए उपयोग करने की आवश्यकता नहीं है , इसलिए मैंने 48 को घटाने के बाद 9 में से एक का उपयोग किया है: x
यह मुझे गोल्फ से दूर कर देता है 3+।

#v~'0-+
q>-9%

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

xलापता अंक के रूप में उपयोग करता है , क्योंकि यह ASCII मूल्य 48 घटाकर 9 से विभाज्य है (और यह अच्छा है क्योंकि इसका आमतौर पर गणित में एक चर के रूप में उपयोग किया जाता है)।

यदि एक्ज़िट कोड 0 या 9 हो सकता है, तो आउटपुट एक्ज़िट कोड के माध्यम से आउटपुट (क्योंकि qएक बाइट से कम है .@)
आउटपुट 0।

यह केवल नीचे बताए गए कारणों के लिए PyFunge दुभाषिया में काम करता है।

व्याख्या

कार्यक्रम की पहली पंक्ति में, हम अंकों को जोड़ते हैं, जिसमें शामिल है x, जो कि एएससीआईआई मान के कारण 72 की तरह व्यवहार किया जाता है। हालाँकि, हम 9 द्वारा modded किए जाने के बाद योग एक ही होगा, इसलिए यह अप्रासंगिक है।

#v~'0-+    THE FIRST LINE
#v~        Pushes the next character from input, and goes to the second line on EOF
   '0-     Subtracts 48 to account for taking in ASCII values
      +    Adds this adjusted value to the sum

यदि हम केवल 9 द्वारा modded हैं, तो हम गलत अंक के साथ छोड़ दिए जाएंगे, क्योंकि हम चाहते हैं 9 - (sum % 9)। हालांकि, हम इससे बेहतर कर सकते हैं 9\-, जो 9 से शेष को घटाएगा: यदि हम 9 से मॉडिंग करने से पहले ऋणात्मक योग बनाते हैं, तो हम 9 - (sum % 9) कुछ दुभाषियों के बराबर एक सकारात्मक परिणाम प्राप्त करेंगे । यह वही है जो हमें Befunge 93 और 98 दोनों के लिए PyFunge दुभाषियों का उपयोग करने की आवश्यकता है, क्योंकि यह TIO पर एकमात्र है जो ऐसा करता है। दूसरे हमें 0 और 8 के बजाय -8 और 8 के बीच का मान देते हैं।

q>-9%    THE SECOND LINE
 >       Redirects the IP onto this line
  -      Subtracts the sum from an implicit 0, making it negative
   9%    Mods the sum by 9
q        Outputs via exit code, ending the program
— MildlyMilquetoast
स्रोत
1

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

का उपयोग करता है '(किसी भी चार है कि करने के लिए एक दूरी है 0कि "0" से विभाज्य है, 0खुद सहित )।

0संकेत का एक आउटपुट 0या तो 9।

p -(gets.sum+6*~/$/)%9

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

व्याख्या

p     # print after inspecting
  -(  # unary negative, for reversing result of modulus (a-b%a)
    gets.sum # ascii value of string
    + 6*~/$/ # add six for each size (in chars) of input, so "0" translates to 0
  )%9 # mod 9
      # find remainder after dividing 9
      # except it's inverted so it's remainder to add to divide 9
— Unihedron
स्रोत
1

रूबी , 46 , 41 बाइट्स

-5 @ @ihedhedron को धन्यवाद

->s{-s.chars.sum{|i|?<>i ? i.to_i : 0}%9}

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

— टॉम लजार
स्रोत
1. हमारे पास charsइसके बजाय .split(//), 2. के '<'साथ बदला जा सकता है?<
— Unihedron
मैंने एक ही टूल (रूबी) में एक छोटा प्रोग्राम तैयार किया है जो अलग-अलग है (यह इनपुट और आउटपुट से संबंधित है) इसकी अपनी प्रस्तुति है, आप इसे यहां पा सकते हैं: codegolf.stackexchange.com/a/151869/23030
— Unihedron
@ यूनीहेड्रॉन धन्यवाद, विश्वास नहीं कर सकता कि मैं भूल गयाchars
— टॉम
1

बेफुंज -93, 28 27 19 18 बाइट्स

क्रेडिट मिस्टाह फिगर्स के पास जाना चाहिए , जिनके PyFunge जवाब ने मुझे दिखाया कि आपको लापता अंक चरित्र के लिए एक विशेष जांच की आवश्यकता नहीं है, अगर आपने अभी सुनिश्चित किया है कि ASCII मूल्य नौ से अधिक है।

जो राजा को अतिरिक्त धन्यवाद, जिन्होंने दिखाया कि आपको वर्णों को पूरी तरह से उनके संख्यात्मक समकक्ष में बदलने की आवश्यकता नहीं थी, और बस आधार 9 के सापेक्ष एक मान प्राप्त करने के लिए 3 को घटा सकते हैं (ASCII 0माइनस 3 45 है, 9 का एक गुणक) ।

3_v#`0:~--
%9_@.+9

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

इस काम के लिए, आपको *लापता अंक के लिए चरित्र का उपयोग करना चाहिए (ऐसे अन्य हैं जो काम भी कर सकते हैं, लेकिन यह सबसे अच्छा है)।

आउटपुट 9यदि अनुपलब्ध अंक 0 या 9 हो सकता है।

व्याख्या

3             Push 3 onto the stack.
 _            Since this is non-zero, drop the 3 and branch left.
3             Now executing right to left, push 3 again.
        --    Negate twice, leaving the value unchanged as our starting sum.

       ~      Now we start the main loop, reading a character from stdin.
    `0:       Duplicate and check if it's > 0, i.e. not end-of-stream.
 _ #          If so, continue to the left.
3        -    Subtract 3 to make the number relative to base 9.
        -     Then subtract it from the total, and repeat the loop.

  v           Once we reach the end of the input, we go down.
  _           Drop the EOF character from the stack and go left.
%9   +9       Mod the total with 9, and add 9.
   @.         Output the result and exit.

अनिवार्य रूप से हम सभी अंकों के योग की गणना कर रहे हैं, साथ ही प्रति अंक 45 (जो अंततः 9 के साथ मॉड करते समय रद्द हो जाएगा)। इस राशि को 3 (हमारे शुरुआती कुल) से घटाया जाता है, और एक अतिरिक्त 39 को लापता अंक (एएससीआईआई *माइनस तीन) द्वारा घटाया जाता है । फिर से 3 माइनस 39 9 की एक बहु है, इसलिए जब हम 9 के साथ मॉड करते हैं तो यह रद्द हो जाता है।

इसलिए अंत में हम सभी अंकों के नकारात्मक योग की गणना कर रहे हैं, मोड 9, प्लस 9, यानी

9 - (digitsum % 9)

और वह हमें गुम अंक देता है।

— जेम्स होल्डरनेस
स्रोत
-1 बाइट यदि आप 48 के बजाय 3 घटाते हैं। अधिकांश इसे मॉडुलो में जोड़ने के लिए 9 को जोड़ने की आवश्यकता से रद्द हो जाता है
— जो किंग
@JoKing धन्यवाद! ऐसा कभी नहीं सोचा होगा। अफ़सोस कि हमें अभी भी +9 की ज़रूरत है, लेकिन मैं इससे छुटकारा पाने का कोई रास्ता नहीं देख सकता।
— जेम्स होल्डरनेस
एक और बाइट को एक पंक्ति में संकुचित करके हटाने का प्रबंधन किया ! मैंने इसे हर लूप में% 9 में बदल दिया और फिर 9-- को 9 में जोड़ दिया।
— जो राजा
@ मुझे पता है कि यह केवल एक और बाइट बचा रहा है, लेकिन यह शानदार है! यह एक नए उत्तर के रूप में पोस्ट करने लायक है। आपको मेरा वोट जरूर मिलेगा, अगर कुछ और नहीं।
— जेम्स होल्डरनेस
इसे पोस्ट किया ! एक आखिरी बाइट को भी शेव करने में कामयाब! मुझे लगता है कि आखिरी मैं ऐसा कर सकता हूं
— जो राजा
1

Befunge-98 (PyFunge) , 8 बाइट्स

#q~3--9%

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

निर्गम कोड के माध्यम से आउटपुट। साथ के रूप में Mistah Figgin का जवाब है, यह केवल Pyfunge, जहां एक नकारात्मक संख्या आधुनिक 9 सकारात्मक हो जाता है के साथ काम करता है। लापता अंक के रूप में एक x का उपयोग करता है।

— मजाक कर रहा है
स्रोत
0

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

param($a)0..9|?{!(($a-replace'x',$_)%9)}

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें

जैसे इनपुट लेता है '123x'में $a। उन पूर्णांकों को निकालने के 0लिए एक सीमा का 9उपयोग करता है और Where-Object(यहां संक्षिप्त रूप में |?) क्लॉज से मेल खाता है। क्लॉज लेता है $a, वर्तमान अंक -replaceके xसाथ बदलने के लिए एक रेगेक्स करता है $_और 9 के साथ मॉड प्राप्त करता है %9। इस प्रकार यदि 9 समान रूप से विभाजित होता है, तो यह शून्य होगा। हम बूलियन को लेते हैं-उसके बाद नहीं, जो शून्य को सत्य बनाता है और बाकी सब कुछ गलत हो जाता है, जिससे जहां-जहां वस्तु खंड संतुष्ट होता है। उन परिणामों को पाइपलाइन पर छोड़ दिया जाता है और आउटपुट निहित होता है।

— AdmBorkBork
स्रोत
0

रेटिना , 35 34 25 बाइट्स

यदि ?हो सकता है 0 or 9, तो परिणाम के रूप में दिखाया गया है 9।

.
$*
1{9}

^
9$*;
+`;1

.

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

व्याख्या

.       Sum of the digits in unary + 1
$*
1{9}    Modulo 9

^       Prepend 9 semicolons, for subtracting
9$*;
+`;1    Subtract from 9

.       Back to decimal
— mbomb007
स्रोत
मेरा मानना ​​है कि \dबस .और निम्न पंक्ति में बदला जा सकता है $*।
— क्रिक्टी लिथोस
ठीक है। ?जब मैंने ऐसा लिखा था तब मैंने अभी तक नहीं हटाया था ।
— mbomb007
— अशुभ
— मार्टिन
@totallyhuman आह, हाँ। एक पुराने संस्करण से एक और अवशेष।
— mbomb007
0

Tcl, 53 बाइट्स

puts [expr 9-([regsub -all (\\d)\\D? 0$argv +\\1])%9]

अन्य उत्तरों के साथ, यह स्पष्ट रूप से "0 या 9" नहीं कहकर बनाया गया है।
इसके बजाय, "9" के परिणाम का अर्थ है 0 या 9।

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

व्याख्या

यह बहुत सरलता से काम करता है। यह एक नियमित अभिव्यक्ति देता है:

  • व्यक्तिगत अंकों में तर्क विभाजित करें
  • किसी भी खत्म करने (रों) प्रश्न चिह्न गैर अंकों (रों)
  • प्लस साइन्स के साथ अंकों को इंटरलेव करें

यह तब 9 का मूल्यांकन करता है - (sum_of_digits mod 9) 1..9 में अंतिम मूल्य पर पहुंचने के लिए, जो तब puts ।

0$argvइनपुट में सबसे पहले प्रश्नवाचक चिह्न (0 इन ) की आवश्यकता होती है; तब्दील अनुक्रम में एक प्रमुख प्लस संकेत के लिए एक समस्या नहीं है expr।

— Dúthomhas
स्रोत
0

ब्रेनफक , 50 बाइट्स

+>,[---[<-[<<]>[<+++++++++<]>>-],]-[<+>-----]<---.

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

9 को 0 या 9 के लिए प्रिंट करता है। गुम चरित्र को दर्शाया गया है:

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

Tape Format:
    0 Total Input 0

The total is represented as 9-digitSum%9

+>,[ Start loop with 1 as the total
    --- Subtract 3 from the inputted byte to make the value%9 equal to the digit
    [   While the input byte exists
      <-                 Decrement the total
      [<<]>[<+++++++++<] If the total is 0, reset it to 9
      >>-                Decrement the input byte
    ]
,] Continue loop until there is no input
-[<+>-----]<---. Add 48 to the total to convert the digit to the ascii value and output it

अनुपलब्ध वर्ण को एक वर्ण होना चाहिए, जिसमें 4 का मॉड 9 है, +3 क्योंकि हम सामान्य अंकों से 3 को घटाते हैं और कुल के 1 के प्रारंभिककरण के लिए +1 करते हैं।

एक साइड नोट के रूप में, गोल्फ की खातिर कोड में बहुत अधिक अक्षमता है, क्योंकि प्रत्येक अंक कुल 5 बार प्रत्येक को रीसेट करेगा, केवल एक बार की बजाय अगर मैं 3 के बजाय 48 घटाता हूं।

— मजाक कर रहा है
स्रोत
0

> <> , 35 33 25 21 15 बाइट्स

का उत्पादन 0साधन परिणाम या तो हो सकता है 0 या 9 ।

0i:&0(?n&3--9%!

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

सहेजी गयी 6 करने के लिए धन्यवाद बाइट्स जो राजा का उपयोग करके 'लापता अंक का प्रतिनिधित्व करने के लिए।

— Emigna
स्रोत
15 बाइट्स यदि आप एक 'चरित्र का उपयोग करते हैं?
— जो राजा
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.