34

आपको एक तार दिया जाएगा। इसमें 0-9 से 9 अद्वितीय पूर्णांक होंगे। आपको लापता पूर्णांक वापस करना होगा। स्ट्रिंग इस तरह दिखेगा:

— हंसी मजाक करना
स्रोत

5

@riker एक क्रम में गुम संख्या के बारे में लगता है। ऐसा लगता है कि एक सेट से एक अंक गायब होने के बारे में है।

— DJMcMayhem

10

@ रिकर मुझे नहीं लगता कि यह एक डुप्लिकेट है, यह देखते हुए कि लिंक की गई चुनौती में एक सख्त वृद्धि क्रम (संभावित बहु-अंकीय संख्या) है, जबकि यहां यह मनमाना क्रम है।

— AdmBorkBork

3

नमस्ते जोश! चूंकि अब तक किसी और ने इसका उल्लेख नहीं किया है, इसलिए मैं आपको सैंडबॉक्स में निर्देशित करूंगा जहां आप भविष्य के चुनौतीपूर्ण विचारों को पोस्ट कर सकते हैं और मुख्य पोस्ट करने से पहले सार्थक प्रतिक्रिया प्राप्त कर सकते हैं। इससे आयरन को किसी भी विवरण (जैसे STDIN / STDOUT) से बाहर निकालने में मदद मिली होगी और इससे पहले कि आप नीचे दिए गए डुप्लिकेट को हल कर लें।

— AdmBorkBork

1

यह ऐसी शर्म की बात है कि 9-x% 9 किसी भी अंक के लिए काम करता है, सिवाय 0. शायद मुझसे ज्यादा चतुर कोई और इसे काम करने का तरीका मिल जाएगा।

— बिजन

2

कई उत्तर फ़ंक्शन इनपुट के रूप में पूर्णांक लेते हैं। क्या इसकी अनुमति है?

— डेनिस

36

अजगर २ , 18 16 बाइट्स

^{@ सौंदर्य बोर्सच को धन्यवाद}

`99066**2`.strip

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

99066**2 एक स्ट्रिंग उत्पन्न करने का एक छोटा तरीका है जिसमें 0 ~ 9 होता है

— छड़ी
स्रोत

7

32043 को और अधिक सुंदर संख्या में बदला जा सकता है। 99,066 केंद्र-सममित या हो सकता है 97,779 (विलोमपद, दो अलग-अलग अंक) (यदि केंद्र के चारों ओर घुमाया 180 डिग्री परिवर्तन नहीं करता है) है

— सार्ज Borsch

1

यदि ओपी दो बार नंबर प्रिंट करने की अनुमति देता है, तो 764**4दो बाइट्स बचा सकता है।

— टाइटस

@ टिट्स 764**4गायब है 5, 8और9

— रॉड

1

टाइपो ... मेरा मतलब 763**4=338920744561

— टाइटस

25

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

lambda s:-int(s,16)%15

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

एक अंकगणित समाधान। इनपुट स्ट्रिंग को हेक्स के रूप में व्याख्या करता है, इसे नकारता है, और परिणाम modulo 15 लेता है।

— XNOR
स्रोत

2

क्या आप बता सकते हैं कि यह क्यों काम करता है?

— कार्लकेस्टर २०

1

@KarlKastor, बेस 16 में मॉडुलो 15 बेस 10. में मोड्यूलो 9 के लिए एनालॉग रूप से काम करता है। अंकों का योग लेते समय मोडुलो बेस -1 स्थिर होता है, सिर्फ इसलिए कि 10 (1 (मॉड बेस -1)। सभी संभव अंकों का योग स्थिर है, इसलिए लापता अंक इस निरंतरता और इनपुट संख्या (मॉडुलो बेस -1) का अंतर है।

— mik

16

APL (Dyalog) , 4 बाइट्स

व्युत्पन्न कार्य

⎕D∘~

⎕D डी इगिट्स

∘ (एक मोनडिक फ़ंक्शन बनाने के लिए निम्न डायडिक फ़ंक्शन के लिए एक बाएं तर्क रखता है)

~ सिवाय [तर्क]

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

फंक्शन ट्रेन

⎕D~⊢

⎕D डी इगिट्स

~ के सिवाय

⊢ सही तर्क

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

स्पष्ट कार्यक्रम

⎕D~⍞

⎕D डी इगिट्स

~ के सिवाय

⍞ चरित्र इनपुट

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

— एडम
स्रोत

12

ब्रेन-फ्लैक , 48 38 36 + 3 = 39 बाइट्स

DJMcMayhem की बदौलत 10 बाइट बच गईं!

((([]())[]{}){()()({}[()])}{}[{{}}])

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

व्याख्या

Ascii में सभी अंकों का योग 525 है। यह कार्यक्रम इनपुट को समेटता है और लापता अंक प्राप्त करने के लिए इसे 525 से घटाता है।

((([]())[]{}){()()({}[()])}{}      )

525 को आगे बढ़ाएगा। यह इस तथ्य का लाभ उठाता है कि हम जानते हैं कि इनपुट के 9 तत्वों के साथ शुरू होगा। इस का मतलब है कि[] evaluates to 9 which allows us to get to large numbers like 525 quickly.

अगला हमारे पास है:

                             [{{}}]

जो इनपुट को सम्‍मिलित करेगा और उसे कुल से घटाएगा।

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

यह कैसे काम करता है?

— पावेल

@ ГригорийПерельман स्पष्टीकरण जोड़ा गया!

— गेहूं जादूगर

2

यदि आप negative(sum(input()))अंत तक चले जाते हैं , तो आप 525 की ऊँचाई तक पहुँचाने के लिए स्टैक-ऊँचाई के निलाद का दुरुपयोग कर सकते हैं। (([][][]()()()){()()({}[()])}{}[{{}}])आप 10 बाइट्स बचाने चाहिए

— DJMcMayhem

477 के बजाय 477 घटाकर 30 बाइट्स

— जो किंग

12

हास्केल , 24 23 बाइट्स

(477-).sum.map fromEnum

इसे ऑनलाइन आज़माएं! उपयोग: (477-).sum.map fromEnum $ "123456890"। 477 अंक 1 से 9 तक के वर्ण कोडों का योग है, जिसमें से 0. को छोड़कर। यह अनाम फ़ंक्शन 477 शून्य से गणना करता है कि लापता होने वाले को खोजने के लिए सभी अंकों के वर्ण कोडों का योग है।

Turning the char digits to ints is one byte longer:

(45-).sum.map(read.pure)
foldl(\a b->a-read[b])45

Try it online!

— Laikoni
स्रोत

10

Jelly, 3 bytes

ØDḟ

Simply filters (ḟ) the input string from “0123456789” (ØD).

Try it online!

— Dennis
स्रोत

3

I like the way that all the golfing languages (and even some non-golfing languages) are using the same algorithm, but Jelly manages to have the shortest names for the builtins it uses, and the least boilerplate for reversing the arguments to ḟ.

1

@ais523 APL is letter by letter the same (except that it would be an APL snippet rather than a function/program): Ø=⎕, D=D, ḟ=~, as in ⎕D~'867953120'.

— Adám

3

Me, while scrolling through the answers: "I'm predicting 3 characters in Jelly." Bingo. :^D

— DLosc

9

Ruby, 14

Sums the ascii codes and subtracts from 48*9+45

->s{477-s.sum}

Use like this

f=->s{477-s.sum}

puts f["123456789"]

— Level River St
स्रोत

9

JavaScript (ES6), 26

Edit 1 byte save thx @Neil, with a much more smarter trick

Xoring all the values from 1 to 9 gives 1. Xor 1 one more time and the result is 0. So, if any single value is missing, the result will be the missing value.

s=>eval([1,...s].join`^`)

Test

f=s=>eval([1,...s].join`^`)

function go() {

  var i=I.value;
  O.textContent = f(i)
}  

go()

<input oninput='go()' value='012987653' id=I>
<pre id=O></pre>

Expand snippet

— edc65
स्रोत

s=>eval([1,...s].join`^`) saves a byte.

— Neil

@Neil ... and it's much more interesting too

— edc65

I feel this tip came suspiciously short after my answer :D anyway nice golf +1.

— Christoph

1

@Christoph Well it sounded as if you wanted to spread the word...

— Neil

@Neil absolutly :) Nice to see that it helped!

— Christoph

8

Retina, 27 21 19 bytes

-6 Thanks to Basic Sunset
-2 Thanks to Martin Ender

.
$*_5$*
+`_1|1_

1

Try it online!

Replace every digit with that many _s and 5 1s:

.
$*_5$*

Remove all of the _s and a 1 for each:

+`_1|1_

Count the number of 1s left:

— Riley
स्रोत

The first line of the second answer can be just ..

— Neil

You can save a few bytes by using deduplication instead of replacement: Try it online

— Business Cat

Oh well, and here was I just getting the second answer down to the old byte count of the first answer... ^ 5 ^. $*9¶ . $*_ +`_¶_ ¶ _

— Neil

@Neil I got it to one less than the original.

— Riley

(Huh, that looks suspiciously similar to my answer, the only difference is that you switched from _ to 1 to save a byte.)

— Neil

6

05AB1E, 6 bytes

45¹SO-

Try it online!

45     # Push 45
  ¹    # push input
   S   # Split
    O  # Sum
     - # Subtract (45 - sum)

— Riley
स्रोत

6

JavaScript (ES6), 31 29 28 22 bytes

s=>(15-`0x${s}`%15)%15

पोर्ट ऑफ @ xnor के पाइथन उत्तर, सिवाय इसके कि जावास्क्रिप्ट में केवल एक modulo ऑपरेटर के बजाय एक शेष ऑपरेटर है, इसलिए मैं इसे एक ही चरण में नहीं कर सकता। संपादित करें: @Annauld के लिए 6 बाइट्स सहेजे गए।

— Neil
स्रोत

s=>[...s].map(c=>r-=c,r=45)|r ;-)

— 21

3

आपको बहुत प्यार है reduce। वैसे भी +1

— edc65

@Arnauld मैं यह नहीं देखता कि कब काम कर रहा हूं s[0]!='0', लेकिन पहले से ही एक जवाब है जो उपयोग करता है eval।

— नील

क्या आप कर सकते हैं s=>(15-`0x${s}`%15)%15?

— अरनौलद

@Arnauld Bah, and I'd already done that for the Batch port too...

— Neil

6

Brainfuck, 17 15 bytes

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

Try it out here. This solution works on standard Brainfuck (8-bit cells) only, as it relies on wrapping.

It's a rare day when Brainfuck can actually compete, but this challenge just happened to line up with the BF spec pretty well!

Instead of straight-up breaking down this answer, I'd like to step through the iterations I took, because I think it would be more understandable (and more interesting).
Note: this solution is inspired largely by Wheat Wizard's Brain-Flak answer.

Explanation

Step 1, 26 bytes

In his answer, Wheat Wizard pointed out that the sum of the ASCII values from 0-9 sum to 525. And since standard Brainfuck only has a notion of [0,255], this makes the value 525 % 256 = 13. That is to say, subtracting the ASCII values of the input from 13 nets you the missing digit.

इस कार्यक्रम का पहला संस्करण था:
1. पहली सेल में 13 रखो
। दूसरी सेल में इनपुट ले लो
। दूसरी सेल को पहली सेल से घटाएं
4. यदि इनपुट शेष हैं तो 2 पर जाएं
। पहली सेल प्रिंट करें

और यहाँ सरल समाधान के लिए कोड है:

+++++++++++++ #Set the first cell to 13  
>,            #Take inputs into the second cell  
[[<->-],]     #Subtract the second cell from the first cell and repeat until inputs are over  
<.            #Print the first cell

चरण 2, 19 बाइट्स

जैसा कि उनके उत्तर में बताया गया है, क्योंकि हम जानते हैं कि इनपुट की लंबाई 9 होगी, हम उस मान को एक स्थिरांक के रूप में उपयोग कर सकते हैं, और शुरुआत में + के सही लंबे स्ट्रिंग को समाप्त कर सकते हैं।
यह भी कोई फर्क नहीं पड़ता कि हम किस बिंदु पर 13 जोड़ते हैं (धन्यवाद, सराहनीय संपत्ति!), इसलिए हम इसे घटाव और मुद्रण चरणों के साथ मिलाएंगे।

,        #Take input to enter the loop
[[->-<], #Subtract the first cell from the second cell 
>+<]     #Add 1 for each input; totaling 9
>++++    #Add the missing 4 to make 13
.        #And print

इस समस्या का मूल जवाब यही था, लेकिन हम बेहतर कर सकते हैं।

चरण 3, 17 बाइट्स

दिलचस्प रूप से पर्याप्त है, पिछला उत्तर तब भी काम करता है जब हम एक के बजाय + से शुरू करते हैं,

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

लूप शुरू करने के लिए एक सेल में ब्रेनफक को कुछ आवश्यक था । हमने भोलेपन से उस अतिरिक्त 4 को अंत में जोड़ा, जब वह अन्य स्थानों पर जा सकता था।

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

कुछ पूरी तरह से जानबूझकर (पढ़ें: परीक्षण और त्रुटि) लूप प्रवंचना, के साथ कार्यक्रम शुरू - एक दो दिलचस्प परिणाम की ओर जाता है:

एक दूसरे सेल में जोड़ा जाता है (अंत में 1 बाइट की बचत)।
लूप्स एक अतिरिक्त समय चलाता है, 9 के बजाय कुल 10 (अन्य 1 बाइट की बचत)।

1 + 10 + 2 = 13, और हम मूल उत्तर के साथ समाप्त होते हैं।

इस पर पीछे मुड़कर देखें, तो इस तरह के एक सरल ब्रेनफैक कार्यक्रम के लिए यह एक अत्यधिक लेखन है।

चरण 4, 15 बाइट्स

इस समाधान के बारे में थोड़ा और सोचने के बाद, मैं 2 बाइट्स काटने में सक्षम था।

मैं पिछले चरण के बारे में कुछ स्पष्ट करना चाहता था:
लूप में प्रवेश करने के लिए माइनस प्रभावी रूप से 1 जोड़ता है, लेकिन वास्तव में यह क्या कर रहा है दूसरे सेल से 255 घटा रहा है (परिणामस्वरूप 1)।

यह पूर्वव्यापी में स्पष्ट है, लेकिन पहली सेल से 1 घटाना 1 है दूसरे सेल में 1 जोड़ना (क्योंकि पहली सेल में सब कुछ दूसरे सेल से घटाया जाता है।)

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

मैं पहले लूप की शुरुआत में "-" जोड़कर "> + <" निकालने में सक्षम था। इसे वहां जाना है, न कि जहां "> + <" था, क्योंकि कार्यक्रम अन्यथा लूप होगा।

— ज़ैक सी।
स्रोत

5

ऑक्टेव , 22 बाइट्स

@(x)setdiff('0':'9',x)

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

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

5

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

477-Tr@ToCharacterCode@#&

शुद्ध कार्य इनपुट के रूप में एक स्ट्रिंग ले रहा है और एक पूर्णांक लौटा रहा है। मैथेमेटिका के पास लंबे समय से कमांड नाम हैं और तार और पूर्णांक के बीच कनवर्ट करने के लिए अनिच्छुक हैं, जो इस चुनौती पर विशेष रूप से बुरा बनाता है। मुझे सबसे अच्छा मिल सकता था लेवल रिवर सेंट के रूबी उत्तर से एल्गोरिथ्म , जो इनपुट स्ट्रिंग के एएससीआईआई कोड के कुल के आधार पर एक संगणना करता है; गणित में, यह केवल एक लंबे कमांड नाम का उपयोग करता है।

— ग्रेग मार्टिन
स्रोत

5

PHP, 27

<?=trim(32043**2,$argv[1]);

रॉड के उत्तर से चाल का उपयोग करता है ताकि सभी अंकों से युक्त एक स्ट्रिंग उत्पन्न हो और फिर लापता एक को छोड़कर सभी अंकों को हटा दिया जाए।

PHP, 41

for($b=1;$i<9;$b^=$argv[1][$i++]);echo$b;

यह एक xor का उपयोग करता है क्योंकि मैंने इसे अभी तक नहीं देखा है।

— क्रिस्टोफ
स्रोत

अच्छा मैंने ट्रिम के बारे में नहीं सोचा है। वैकल्पिक मूल्य

32043,32286,33144,35172,35337,35757,35853,37176,37905,38772,39147,39336,40545,42744,43902,44016,45567,45624,46587,48852,49314,49353,50706,53976,54918,55446,55524,55581,55626,56532,57321,58413,58455,58554,59403,60984,61575,61866,62679,62961,63051,63129,65634,65637,66105,66276,67677,68763,68781,69513,71433,72621,75759,76047,76182,77346,78072,78453,80361,80445,81222,81945,83919,84648,85353,85743,85803,86073,87639,88623,89079,89145,89355,89523,90144,90153,90198,91248,91605,92214,94695,95154,96702,97779,98055,98802,99066

— जार्ग हल्सरमैन

5

बैश + कोरुटिल्स, 19 बाइट्स

मुझे एक ~~छोटा~~ सा बैश समाधान मिला , जो एक दिलचस्प चेकसम दृष्टिकोण का उपयोग करता है:

sum -s|dc -e524?--P

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

स्पष्टीकरण:

sumआदेश चेकसम और एक ब्लॉक गिनती प्रिंट करता है। मैं कई विवरण नहीं जानता, लेकिन विकल्प का उपयोग करना-s (सिस्टम वी एल्गोरिथ्म) का उपयोग करके चेकसम को प्रत्येक इनपुट वर्ण कोड के ASCII योग के बराबर बना देगा। जैसे, समान इनपुट वर्णों का क्रम बदलने पर चेकसम स्थिर रहता है।

यह देखते हुए 867953120परीक्षण का मामला (पिछले उदाहरण) के रूप में, यहाँ है कैसे स्क्रिप्ट काम करता है:

sum -sआउटपुट 473 1। यदि कोई पूर्णांक अनुपलब्ध था, तो चेकसम 525 होगा।
dc -e524?524 और फिर पाइप इनपुट को धक्का देता है। स्टैक है 1 473 524:। 525 से चेकसम को घटाना है, लेकिन जब से 1 आउटपुट के साथ ही मुझे इसके साथ काम करने की आवश्यकता है।
--P। दो घटाव (524- (473-1)) को लागू करने के बाद, स्टैक है 52:। 'P' के साथ, मैं उस ASCII कोड के साथ चरित्र को प्रिंट करता हूं: 4लापता अंक।

— seshoumara
स्रोत

4

फोरट्रान 95, 146 128 बाइट्स

function m(s)
character(len=10)::s,t
t='0123456789'
do j=1,10
k=0
do i=1,9
if(s(i:i)==t(j:j))k=1
end do
if(k==0)m=j-1
end do
end

बहुत कम नहीं, मुझे डर है।

Ungolfed:

integer function m(s)
    implicit none

    character(len=9)::s
    character(len=10)::t
    integer:: i, j, k

    t='0123456789'
    do j=1,10
        k=0
        do i=1,9
            if (s(i:i) == t(j:j)) k=1
        end do
        if (k==0) m=j-1
    end do

end function m

— Steadybox
स्रोत

3

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

A,sq-

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

A,     e# The range from 0 to 9: [0 1 2 3 4 5 6 7 8 9]
  s    e# Cast to a string: "0123456789"
   q   e# The input
    -  e# Remove all characters from the range that are in the input
       e# Implicit output

— बिजनेस कैट
स्रोत

3

GNU sed , 36 बाइट्स

के लिए +1 शामिल है -r

s/$/0123456789/
:
s/(.)(.*)\1/\2/
t

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

s/$/0123456789/ # Append 0123456789
:               # Start loop
s/(.)(.*)\1/\2/ # remove a duplicate character
t               # loop if something changed

— रिले
स्रोत

3

ब्रेकीलॉग (2), 5 बाइट्स

ẹ:Ị↔x

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

यकीनन कम होना चाहिए (मैं अभी भी उलझन में हूं कि यह क्यों ẹआवश्यक है), लेकिन यह सबसे अच्छा है जो मैं कर सकता था।

व्याख्या

ẹ:Ị↔x
ẹ      Split the input into a list of characters
 :Ị    Pair that list with the string "0123456789"
   ↔x  Remove all elements of the list from the string

xकार्यान्वयन पुरानी और बहुत छोटी गाड़ी है, जिसके कारण आपको आवश्यकता है ẹ।

— घातक

आप वास्तव में एक तर्क दे सकते हैं कि कुछ ऐसा ¬∋ℕहोना चाहिए जो केवल 3 वर्णों में काम करे - यही मैंने पहले प्रयास किया था - लेकिन इसके कई कारण हैं कि ऐसा क्यों नहीं होता है, और मुझे नहीं लगता कि ब्राचीलॉग को बदलने का कोई प्रशंसनीय तरीका है ताकि यह हो।

प्रोलॉग में ऐसा ¬∋ℕकाम करना भी संभव नहीं है, जब तक कि विशेष रूप से प्रोग्रामिंग न करें कि आपका क्या मतलब है not in। ¬ब्रेजलॉग में प्रोलॉग के बराबर है \+, और इसका अर्थ "बंद-दुनिया की धारणा के तहत साबित नहीं होने वाला" है, इसके बजाय "मुझे हर चीज के लिए पसंद अंक दें जो इसे सत्यापित नहीं करता है" (जो लगभग हमेशा एक अनंत संख्या में है )

— घातक

प्रोलॉग में ऐसा करने का एकमात्र तरीका ℕअग्रिम में "लेबल करना" होगा, लेकिन इसका मतलब होगा कि ब्रैडीग्लॉग के मूल्यांकन के आदेश के साथ छेड़छाड़ की भविष्यवाणी की सामग्री के आधार पर की जाएगी। हालांकि यह समस्याओं में से केवल एक है, हालांकि; दूसरों के एक टन हैं।

3

आम लिस्प, 47 बाइट्स

(lambda(s)(- 45(reduce'+ s :key'digit-char-p)))

Ungolfed:

(lambda (s) (- 45 (reduce '+ s :key 'digit-char-p)))

explaination:

(reduce '+ s :key 'digit-char-p)

यह वर्णों के माध्यम से छोरों s, उन्हें अंकों में परिवर्तित करता है, और उन्हें जोड़ता है। डिजिट-चार-पी, सुविधापूर्वक, चार्ट की संख्या को उसके "सही" मान के रूप में लौटाएं, इसलिए इसका उपयोग परीक्षण या रूपांतरण के रूप में किया जा सकता है।

(- 45 ...)

45 से घटाना उस अंक को वापस देता है जो इनपुट से गायब था।

— djeis
स्रोत

3

Cubix , 18 बाइट्स

5v&;52/ni?@.>!&oW+

विस्तारित

    5 v
    & ;
5 2 / n i ? @ .
> ! & o W + . .
    . .
    . .

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

इस तरह की विधि का उपयोग करता है मस्तिष्क-फ्लैक उत्तर ।

स्टैक पर मान 525 बनाएँ 5, 2, समसामयिकी, 5 धक्का, समतल और नकारात्मक को धक्का देकर।
फिर लगातार इनपुट प्राप्त करें और इनपुट के अंत तक जोड़ दें।
अंतिम इनपुट निकालें, नकारात्मक जोड़ें (सकारात्मक बनाएं) अंतिम परिणाम जोड़ें, चरित्र और पड़ाव का उत्पादन करें।

-525 अप से काम करने का कारण यह है कि प्रत्येक इनपुट पुनरावृति के लिए वर्ण आउटपुट हिट होता है। चूंकि मान ऋणात्मक है, इसलिए कुछ भी आउटपुट नहीं है जब तक कि लूप बाहर नहीं निकलता है और नकारात्मक मूल्य को सकारात्मक बनाया जाता है।

— MickyT
स्रोत

3

PHP, 37 बाइट्स

<?=45-array_sum(str_split($argv[1]));

— user63956
स्रोत

3

बैश (+ उपयोगिताओं), 22, 19 बाइट्स

seqब्रेस विस्तार के बजाय का उपयोग करें , -3 बाइट्स (Thx @Riley!)

seq 0 9|tr -d \\n$1

परीक्षा

$seq 0 9|tr -d \\n123456789
0

यह ऑनलाइन की कोशिश करो!

— टसेपेल्लिन
स्रोत

यदि आप इससे पहले कि $1यह अधिक स्पष्ट होगा अंतरिक्ष चले गए ...

— नील

@ नील, हाँ, यह एक अच्छा विचार है! धन्यवाद !

— ज़ेपेलिन

आप seqइसके बदले उपयोग कर सकते हैं echo: seq 0 9|tr -d \\n$1

— रिले

3

Google शीट, 39 33 बाइट्स

इनपुट सेल में दर्ज किया गया है A1।

कोड:

=REGEXEXTRACT(4&2^29,"[^"&A1&"]")

स्टीव कैस की बदौलत 6 बाइट्स बचाए।

पिछला कोड:

=REGEXEXTRACT("0123456789","[^"&A1&"]")

परिणाम:

— अनुदान मिलर
स्रोत

संख्या 2 ^ 29 में सभी अंक हैं लेकिन 4, इसलिए 33 बाइट्स: = REGEXEXTRACT (4 & 2 ^ 29, "[^" और A4 & "]")

— स्टीव कैस

@SteveKass अच्छा लगा। =REGEXEXTRACT(0&49^9,"[^"&A1&"]")इसी तरह का तर्क देते हुए, एक वैध समाधान भी है। अद्यतन उत्तर।

— ग्रांट मिलर

3

Befunge 98, 14 12 बाइट्स

मैंने कुछ बेहतर गणित करके कार्यक्रम को 1 पंक्ति और 1 बाइट पर ले जाकर 1 बाइट को बचाया

~+;@.%a--7;#

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

व्याख्या

एएससीआईआई मानों का योग 477 से 468 तक होता है, जिसके आधार पर संख्या गायब है। 7 से इसे घटाकर, हमें -470 से -461 रेंज मिलती है। इस संख्या को 10 तक संशोधित करके, हमें 0 - 9 की सीमा मिलती है, जिसे हम बाद में प्रिंट कर सकते हैं।

~+;       ;#    Sums the ASCII values of all characters to stdIn
~          #    The # doesn't skip over the ~ because it's on the end of a line
~               Once EOF is hit, the ~ reverses the IP's direction
          ;#    Jump the ; that was used before
       --7      Subtract the sum from 7 (really just 0 - (sum - 7))
     %a         Mod it by 10
   @.           Print and exit

पूर्णांक इनपुट लेने के बजाय ASCII मानों का उपयोग करने का कारण यह है क्योंकि &यह कोशिश में आदेश EOF पर ऑनलाइन रुकता है (भले ही इसे आईपी को उलट देना चाहिए)। ~सही ढंग से, हालांकि काम करता है।

पुराना कार्यक्रम , 14 बाइट्स

#v~+
@>'i5*--,

सभी 10 अंकों के ASCII मानों का योग 525 है। 525 से दिए गए अंकों के योग को घटाकर, हमें गायब चरित्र का ASCII मान मिलता है।

#v~+         Sums the ASCII values of all characters on stdIn
             Moves to the next line when this is done
 >'i5*       Pushes 525 (105 * 5)
      --     Subtracts the sum from 525
@       ,    Prints and exits

— MildlyMilquetoast
स्रोत

2

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

param($n)0..9|?{$n-notmatch$_}

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

इनपुट लेता है $n, एक सीमा 0..9(यानी 0, 1, 2 ... 9) का निर्माण करता है, फिर उस संख्या को निकालने के लिए एक Where-Objectखंड ( |?{...}) का उपयोग करता है जो रेगेक्स करता है -notmatch। यह पाइपलाइन पर छोड़ दिया गया है, आउटपुट निहित है।

— AdmBorkBork
स्रोत

2

रोदा , 28 बाइट्स

{(_/"")|ord _|sum|chr 525-_}

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

— fergusq
स्रोत

2

पायथ, 5 बाइट्स

-jkUT

कोशिश करो!

व्याख्या

-jkUT
    T   # 10
   U    # The unary range of ten: [0,1,..,9]
 jk     # join that on the empty string
-       # set minus

"-jUT" भी थोड़े काम करता है लेकिन हर इंट के लिए नयापन पैदा करता है।

— KarlKastor
स्रोत

2

05AB1E , 5 बाइट्स

žhISK

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

व्याख्या

žh     # from the string "0123456789"
    K  # remove
  IS   # each digit of the input

— Emigna
स्रोत

6

मुझे यह पसंद है क्योंकि आप इसे ज़ोर से कह सकते हैं। "hhISK’ ’, वह रोया, जैसा कि उसने अपनी टोपी को ऊपर की टोपी पर लहराया और एक छोटा सफेद खरगोश धुएं के गुबार में दिखाई दिया।

— पेंगुइन

लापता पूर्णांक आउटपुट

अजगर २ , 18 16 बाइट्स

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

APL (Dyalog) , 4 बाइट्स

व्युत्पन्न कार्य

फंक्शन ट्रेन

स्पष्ट कार्यक्रम

ब्रेन-फ्लैक , 48 38 36 + 3 = 39 बाइट्स

व्याख्या

हास्केल , 24 23 बाइट्स

Jelly, 3 bytes

Ruby, 14

JavaScript (ES6), 26

Retina, 27 21 19 bytes

05AB1E, 6 bytes

JavaScript (ES6), 31 29 28 22 bytes

Brainfuck, 17 15 bytes

Explanation

Step 1, 26 bytes

चरण 2, 19 बाइट्स

चरण 3, 17 बाइट्स

चरण 4, 15 बाइट्स

ऑक्टेव , 22 बाइट्स

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

PHP, 27

बैश + कोरुटिल्स, 19 बाइट्स

फोरट्रान 95, 146 128 बाइट्स

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

GNU sed , 36 बाइट्स

ब्रेकीलॉग (2), 5 बाइट्स

व्याख्या

आम लिस्प, 47 बाइट्स

Cubix , 18 बाइट्स

PHP, 37 बाइट्स

बैश (+ उपयोगिताओं), 22, 19 बाइट्स

Google शीट, 39 33 बाइट्स

Befunge 98, 14 12 बाइट्स

व्याख्या

पुराना कार्यक्रम , 14 बाइट्स

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

रोदा , 28 बाइट्स

पायथ, 5 बाइट्स

व्याख्या

05AB1E , 5 बाइट्स