36

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

आप वैकल्पिक रूप से आउटपुट के लिए एक अनुगामी newline जोड़ सकते हैं।

यह कोड-गोल्फ है, (विषम) बाइट्स जीत में सबसे कम उत्तर।

मानक खामियों को मना किया जाता है। इसके अलावा, आप भाषाओं के संस्करणों का उपयोग नहीं कर सकते हैं, जो इस चुनौती के पद से नए हैं।

उदाहरण इनपुट> आउटपुट:

13 > 13

42 >

code-golf restricted-source

— M.Herzkamp
स्रोत

10

मैंने इस चुनौती को अस्वीकार कर दिया क्योंकि यह "डू एक्स विदाउट वाई" चुनौती है।

— लीक नून

4

वास्तव में क्या does nothing otherwiseमतलब है? हास्केल में प्रकार के साथ एक फ़ंक्शन Int -> Int या तो एक पूर्णांक लौटाता है या कुछ त्रुटि को रोक या फेंकता नहीं है। यदि इनपुट है, तो यह स्पष्ट रूप से वापस नहीं होना चाहिए, इसलिए इस मामले में कोई त्रुटि रोकना या फेंकना स्वीकार्य नहीं होगा?

— लकोनी

2

यदि आप जानते हैं कि क्या आप अपने स्रोत कोड का उपयोग कर सकते हैं, तो इन लिपियों को अपने ब्राउज़र कंसोल में आज़माएँ। मान्य वर्णसेट बनाएँ alphabet=new Set(Array(256).fill(0).map((v,i)=>i).filter(v=>v%2).map(String.fromCharCode));:। जाँच करें कि क्या स्रोत मान्य है [..."SOURCE CODE"].every(v=>alphabet.has(v)):। स्रोत में अमान्य वर्ण देखें: [...new Set("SOURCE CODE")].filter(v=>!alphabet.has(v))। अपने उद्धरण, "=> \";) से बचने के लिए याद रखें

— kamoroso94

14

@LeakyNun "Y के बिना X करें" सामान्य प्रतिबंधित-स्रोत चुनौतियों का उल्लेख नहीं करता है , लेकिन ऐसी चुनौतियाँ जो आपको किसी भाषा की कुछ विशेषताओं का उपयोग करने से मना करती हैं। यह चुनौती यह नहीं है और न ही इसमें कोई समस्या है जो वास्तविक "डू एक्स विदाउट वाई" चुनौतियों को समस्याग्रस्त बनाती है।

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

1

@ लिकोनी जैसा कि पहले से ही कुछ उत्तर हैं जो एक अनंत लूप में जाते हैं, मैं कहूंगा कि ऐसा व्यवहार दिखाना ठीक है। वापस न लौटने की व्याख्या कुछ भी नहीं के रूप में की जा सकती है।

— M.Herzkamp

1

जाप `-f` , 1 बाइट

uका चार-कोड मान है 117।

कोशिश करो

— ओलिवर
स्रोत

1

पार्टी के लिए देर हो रही है, लेकिन मेरे ... क्या जवाब है!

— एम। हर्जकम्प

67

Lenguage , 645529908926937253684695788965635909332404360034079 9394157991500940492270727190763049448735 1174269748937617561533841898064735499551 2293382937520069758100171520285996319 बाइट्स

यह लगभग 2 ग्रहणी बाइट के बराबर है।

फ़ाइल निम्नलिखित ब्रेनफक प्रोग्राम में अनुवाद करती है:

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

256 के अधिकतम मूल्य के साथ ASCII कोड के रूप में इनपुट लेता है। रैपिंग का उपयोग करता है।

— Okx
स्रोत

@ ओकेएक्स मेरी गलती। लेकिन तुम सिर्फ इस्तेमाल क्यों नहीं करते ,[<<+>+>-]<[>>+<<-]+>>[-[->]<]<[<[<]>.<]?

— user202729

1

,[[>]++[-<]<+>>]>[<<<.<]केवल 3452857532394791089951 बाइट्स के बारे में कैसे ?

— जो किंग

वास्तव में, चूंकि अनंत छोरों की अनुमति है, ,-[-->++<]>+.वैसे ही काम करता है

— जो किंग

20

x86-64 मशीन कोड, 8 बाइट्स

ब्रूस फोर्ट के समाधान से प्रेरित है , लेकिन थोड़ा सा बराबर है। :-)

8D 07          lea      eax, [rdi]    ; put copy of input parameter in EAX
D1 EF          shr      edi, 1        ; shift LSB into CF
             InfiniteLoop:
F3 73 FD       rep jnc  InfiniteLoop  ; test CF; infinite loop back here if input was even
C3             ret                    ; return with original input in EAX if it was odd

एक एकल पूर्णांक पैरामीटर EDIरजिस्टर में लिया जाता है , सिस्टम V AMD64 कॉलिंग कन्वेंशन के बाद।

इस मूल्य की एक प्रति शुरू में बनाई गई है, और इसे डाल दिया गया है, EAXयदि उपयुक्त हो तो इसे वापस किया जा सकता है। ( LEAसामान्य के बजाय इसका उपयोग किया जाता है MOVक्योंकि हमें विषम बाइट्स के साथ एक निर्देश की आवश्यकता होती है।)

फिर, मान को EDI1 से दाईं ओर स्थानांतरित कर दिया जाता है, जो स्थानांतरित किए गए बिट को कैरी फ़्लैग (CF) में रखता है। यह बिट 0 होगा यदि संख्या समान थी, या 1 यदि यह विषम था।

हम फिर JNCनिर्देश का उपयोग करते हुए सीएफ का परीक्षण करते हैं , जो केवल तभी सीएफ होगा यदि सीएफ 0 है (यानी, संख्या सम थी)। इसका मतलब यह है कि हम मूल्यों के लिए एक अनंत लूप में जाएंगे। विषम मानों के लिए, हम गिर जाते हैं और मूल मूल्य (में EAX) वापस आ जाता है।

JNCनिर्देश के साथ एक चाल है , हालांकि, यह एक REPउपसर्ग है! आम तौर पर, REPउपसर्गों का उपयोग केवल कड़े निर्देशों के साथ किया जाता है, लेकिन क्योंकि इंटेल और एएमडी मैनुअल दोनों सहमत हैं कि अप्रासंगिक / अतिरेक / अतिरेक REPउपसर्गों को अनदेखा किया जाता है, हम इसे 3 बायपास बनाने के लिए शाखा निर्देश पर फेंक देते हैं। इस तरह, जम्प निर्देश में एन्कोडेड हो जाने वाली सापेक्ष ऑफ़सेट भी विषम है। (और, ज़ाहिर है, REPअपने आप में एक अजीब-बाइट उपसर्ग है।)

धन्यवाद अच्छाई RETएक विषम बाइट का उपयोग करके एन्कोडेड है!

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

यदि आप यह मानकर नहीं लौटते हैं कि यदि यह विषम है या अनंत लूप में जा रहा है तो यह भी (ताकि आप कभी न लौटें) चुनौती की "आउटपुट" आवश्यकताओं को पूरा करता है, या आप कुछ और अधिक दिलचस्प चाहते हैं, यहाँ एक फ़ंक्शन है यह एक सीरियल पोर्ट के लिए मूल्य को आउटपुट करता है (लेकिन केवल अगर यह विषम है, तो निश्चित रूप से)।

x86-64 मशीन कोड (सीरियल पोर्ट के लिए आउटपुट), 17 बाइट्स

8D 07         lea   eax, [rdi]   ; put copy of input parameter (EDI) in EAX

B1 F7         mov   cl, 0xf7     ; put 0xF7 into low-order bits of CX
B5 03         mov   ch, 0x03     ; put 0x03 into high-order bits of CX
FE C1         inc   cl           ; increment low-order bits of CX to 0xF8 (so all together it's now 0x3F8)
0F B7 D1      movzx edx, cx      ; move CX to DX ("MOV DX, CX" would have a 16-bit prefix of 0x66)

D1 EF         shr   edi, 1       ; shift LSB of input parameter into CF
73 01         jnc   IsEven       ; test CF: branch if 0 (even), fall through if 1 (odd)
EF            out   dx, eax      ; output EAX (original input) to I/O port 0x3F8 (in DX)
            IsEven:
C3            ret                ; return

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

वैसे भी, यह I / O पोर्ट 0x3F8 को लिखने के लिए x86 OUTनिर्देश का उपयोग करता है , जो कि पीसी पर मानक COM1 सीरियल पोर्ट है । मज़ेदार हिस्सा, निश्चित रूप से, यह है कि सभी मानक I / O पोर्ट (धारावाहिक और समानांतर) के पते भी हैं, इसलिए उन्हें केवल OUTनिर्देश के लिए तुरंत इनकोड नहीं किया जा सकता है या सीधे रजिस्टर में ले जाया जा सकता है। आपको वास्तविक मूल्य से कम के साथ आरंभ करना होगा, और फिर रजिस्टर में मूल्य बढ़ाना होगा। आप हेरफेर के लिए कुछ रजिस्टरों का उपयोग करने के लिए भी सीमित हैं क्योंकि आपको उन रजिस्टरों की आवश्यकता है जो ऑपरेंड्स के उपयोग के दौरान निर्देश में अजीब बाइट्स का उपयोग करके एन्कोडेड हैं।

इसके अलावा, मुझे लूप के शीर्ष पर DXरजिस्टर (रजिस्टर के माध्यम से CX) को इनिशियलाइज़ करना था , भले ही यह केवल तभी आवश्यक हो जब मान विषम हो, यह सुनिश्चित करने के लिए कि JNCनिर्देश में एक विषम ऑफसेट होगा। हालाँकि, हम जिस चीज को छोड़ रहे हैं वह OUTनिर्देश है, यह सब कोड बेकार साइकिल और क्लोबर स्क्रैच रजिस्टर है; यह वास्तव में कुछ भी उत्पादन नहीं करता है , इसलिए यह नियमों को नहीं तोड़ता है।

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

इसके लिए कोई TIO लिंक नहीं, क्योंकि यह सीरियल पोर्ट पर आउटपुट लागू नहीं करता है। आपको असली लोहा, या एक कल्पना की आवश्यकता होगी।

— कोडी ग्रे
स्रोत

स्पष्टीकरण के लिए +1! आप दूसरी पंक्ति में mov का उपयोग क्यों कर सकते हैं लेकिन पहली में नहीं?

— M.Herzkamp

एन्कोडिंग के अलावा यह एक MOVनिर्देश है, इसके ऑपरेंड को भी बाइट्स में एनकोड करना होगा। इस मामले में, वह स्रोत और गंतव्य रजिस्टर होंगे (हालांकि ऑपरेंड भी तत्काल मान हो सकते हैं, जो स्थिरांक की तरह हैं)। अलग-अलग बाइट्स के लिए अलग-अलग रजिस्टर मैप करते हैं, और उनमें से कुछ बाइट्स भी हैं। इसलिए, उदाहरण के लिए, मैं जो उपयोग करना चाहता हूं वह होगा mov eax, edi, लेकिन वह 89 F8बाइट्स में है। "कोड" सेक्शन के तहत, यहां के एन्कोडिंग्स पर आप जितना जानना चाहते हैं, उससे कहीं अधिक रास्ता देखें । @ एम। हर्जकम्प

— कोडी ग्रे

19

जेली , 2 बाइट्स

ẋḂ

ये पात्र जेली के कोड पृष्ठ में 0xF7 और 0xBF के बाइट्स के अनुरूप हैं ।

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

— डेनिस
स्रोत

5

एक शर्म की बात है अगर बाइट काउंट के साथ इस समाधान ने चुनौती जीती ... 1 बाइट समाधान किसी को भी?

— एम। हर्ककम्प

9

05AB1E , 3 बाइट्स

Éi=

कोड बाइट मानों से मेल खाता है C9,69,3Dया 201,105,61जो सभी विषम हैं।

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

व्याख्या

É     # input % 2 == 1
 i    # if true
  =   # print without popping

— Emigna
स्रोत

= # print without newlineयह वास्तव में पॉपिंग के बिना न्यूलाइन के साथ प्रिंट होता है

— एरिक आउटगॉल्फर

@EriktheOutgolfer: सच है। मैं स्पष्टीकरण ठीक कर दूँगा।

— एमिगा जूल

दुर्भाग्य से, É×काम करने के लिए प्रतीत नहीं होता है):

— कलसवरस

@kalsowerus: हाँ, मैंने उस पर भी ध्यान दिया। एक Dसामने के साथ सही ढंग से काम करता है , लेकिन यह भी है और कोई छोटा नहीं है। कारण यह नहीं है कि दोहराया तर्क इनपुट 2 तर्क के रूप में लिया जाता है।

— एमिगा जूल 11'17

@ एमिग्ना लेकिन अजीब बात है, स्टैक पर शीर्ष दो मूल्यों को दो बार स्वैप करना, यह भी काम करता है ...

— कलसोवरस

5

MATL , 3 बाइट्स

o?G

Matl ASCII वर्ण है, इसलिए का उपयोग करता o?Gबाइट्स से मेल खाती है (दशमलव में) 111, 63, 71।

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

व्याख्या

o     % Push (implicit) input modulo 2
?     % If nonzero
  G   %   Push input
      % End (implicit)
      % Display stack contents (implicit)

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

5

हास्केल , 36 33 बाइट्स

c[1]=1;c[m]=1+1+c[m-1-1];o	m=c[m]

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

उपयोग: o 7yiedls 7, o 8एक अनंत लूप में प्रवेश करता है।

वास्तविक एल्गोरिथ्म है

o 1 = 1
o m = 2 + o(m-2)

पहली समस्या जिसका मुझे सामना करना पड़ा, वह जगह की कमी थी और (, क्योंकि एक फ़ंक्शन oजो एक तर्क लेता mहै उसे आमतौर पर o m=...या के रूप में परिभाषित किया जाता है o(m)=...। हालाँकि मुझे पता चला कि इनलाइन टिप्पणी {- some comment -}टोकन सीमांकक के रूप में भी काम करती है, इसलिए o{--}m=...दिए गए नियमों के तहत एक परिभाषा संभव है। संपादित करें: अर्जन जोहानसन ने बताया कि एक अंतरिक्ष के बजाय एक टैब वर्ण का उपयोग कर सकता है, जिससे तीन बाइट्स बचते हैं: o m=...

दूसरी समस्या पुनरावर्ती कॉल थी o(m-2)। -2बस है -1-1, लेकिन यहां टिप्पणी चाल काम नहीं करती है क्योंकि कोष्ठक की आवश्यकता होती है। मैं एक संख्या वाले सिंगलटन सूची पर समारोह काम की अनुमति से इस तय: o[m-2], तथापि, के रूप में इस इनपुट प्रदान करने के लिए एक मानक तरीका नहीं है, मैं एक सहायक कार्य करने के लिए गणना आउटसोर्स cजो सूचियों और फोन पर काम करता है cसे oजो सही स्वरूप है ।

— Laikoni
स्रोत

आप एक स्थान के बजाय एक टैब का उपयोग कर सकते हैं।

— अर्जन जोहान्सन

@ ItrjanJohansen मैं यह सत्यापित कर सकता हूं कि इसके \tबजाय इसके साथ काम करता है {--}।

— २२:४ang में फल फल

@ TorjanJohansen धन्यवाद, यह जानना अच्छा है।

— लकोनी

5

पायथन आरईपीएल, 38 बाइट्स

पिछली अभिव्यक्ति के उपयोग के मूल्य के रूप में इनपुट लेता है _। आउटपुट एक स्ट्रिंग (विषम के लिए पूर्णांक का स्ट्रिंग प्रतिनिधित्व, या यहां तक कि खाली स्ट्रिंग के लिए) होगा।

'%s'%[['']+[_]][-1][[_%[1+1][-1]][-1]]

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

इसे वास्तविक शेल में चलाने के लिए, आप इसे यहाँ आज़मा सकते हैं । इनपुट टाइप करें, हिट दर्ज करें। कोड पेस्ट करें, हिट दर्ज करें।

स्पष्टीकरण:

यह पता लगाने में थोड़ा समय लगा। कोई गुणन नहीं, कोई शाखा नहीं, कोई स्लाइसिंग नहीं, कोई अल्पविराम नहीं, कोई अवधि नहीं, कोई आयात नहीं, कोई कोष्ठक नहीं exec, नहीं eval, नहीं print, नहीं , और कोई कार्य नहीं। मुझे एक समाधान मिला कि स्टडर का उपयोग करके उस आउटपुट को काम करना, लेकिन फिर मुझे एहसास हुआ कि हमें वास्तविक पूर्णांक का उत्पादन करना था, न कि केवल एक सत्य / गलत मूल्य।

मैं कोष्ठक के स्थान पर कोष्ठक का उपयोग करता हूं [expression][-1]। सरलीकरण जो उपरोक्त कोड को बदल देता है '%s'%(['']+[_])[_%(1+1)]।

चूंकि कोई अल्पविराम नहीं हो सकता है, इसलिए मैंने बनाने के लिए सूची जोड़ का उपयोग किया ['',_]। स्ट्रिंग स्वरूपण का उपयोग करके, वांछित परिणाम प्राप्त किया जाता है।

— mbomb007
स्रोत

कुडोस। एक बोनस के रूप में, यह रूबी आईआरबी के लिए भी काम करता है :) नाइटपिक: क्या विषम संख्याओं के लिए एक स्ट्रिंग वापस करना ठीक है, क्या संख्याओं के लिए एक खाली स्ट्रिंग वापस करना ठीक है?

— एरिक डुमिनील

कुछ भी नहीं कर रहा है और मुद्रण या कुछ भी नहीं लौट रहा है, मुझे लगता है। एक तरह से, खाली स्ट्रिंग कुछ भी नहीं है।

— mbomb007

हां, मैं वास्तव में नाइटपैकिंग था। यह अभी भी कुछ नहीं के बजाय एक स्ट्रिंग लौटाता है। पायथन आरईपीएल में, मैं कहूंगा कि Noneइससे भी बेहतर मैच होगा ''। वैसे भी, मैं अभी भी कुछ भी है कि मैं के साथ आ सकता से 10000 गुना बेहतर है।

— एरिक डुमिनील

@EricDuminil मैं लौट सकता था False। Idk आप कैसे प्राप्त कर सकते हैं None, हालांकि।

— mbomb007

4

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

q_iY%%

113 95 105 89 37 37

यह प्रोग्राम इनपुट के मॉड 2 को लेता है (इसे r कहते हैं ) और इनपुट स्ट्रिंग में प्रत्येक r वें वर्ण को प्रिंट करता है । यदि इनपुट संख्या विषम है, तो यह पूरे स्ट्रिंग को प्रिंट करता है, लेकिन अगर हर 0 वें वर्ण को प्रिंट करने के लिए कहा जाए तो प्रोग्राम एक त्रुटि फेंकता है।

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

— geokavel
स्रोत

अच्छा! मैं पोस्ट करने जा रहा था qi_Y%]W%{}/M?और फिर मैंने यह देखा।

— Esolanging Fruit

4

क्यूबिक्स , 23 19 17 बाइट्स

;;u!I1)%/;O=!;;/;

कोशिश करो!

@, जो एक क्यूबिक्स कार्यक्रम को समाप्त करता है, अस्की 64 है, इसलिए दुर्भाग्य से यह वास्तव में विषमता के परीक्षण के बाद एक अनंत लूप में प्रवेश करता है। कोई TIO लिंक नहीं है क्योंकि यह समय समाप्त हो जाएगा।

= (ascii 61) क्यूबिक्स में एक नो-ऑप है।

यह पूर्व एल्गोरिथ्म (उसी # बाइट्स) का एक मामूली संशोधन है जो वास्तव में नकारात्मक पूर्णांक के लिए काम करता है।

घन संस्करण:

    ; ;
    u !
I 1 ) % / ; O =
! ; ; / ; . . .
    . .
    . .

कलन विधि:

I (73) : इनपुट में संख्या के रूप में पढ़ें
1 (49) : धक्का १
) (41) : वेतन वृद्धि
% (37) : मोद ले लो
/ (47) : बांए मुड़िए
! (33) : अजीब होने पर अगला निर्देश छोड़ें
- 1;;/; ;है (59): आउटपुट के लिए स्टैक तैयार करता है
- O (79) : एक संख्या के रूप में आउटपुट।
- फिर यह एल्गोरिथ्म में फिर से प्रवेश करता है, लेकिन इनपुट के अंत के लिए Iपढ़ता है 0, इसलिए हमें यहां तक कि शाखा में प्रवेश करने की गारंटी है
u (117) : दाहिना हाथ यू-टर्न
;;;!I : पाश, प्रभावी रूप से कुछ नहीं कर रहा।

— ग्यूसेप
स्रोत

@ मिक्की जो नकारात्मक इनपुट के लिए विफल रहता है, यही वजह है कि मैंने इसका उपयोग करने से परहेज किया?

— Giuseppe

क्षमायाचना, मैंने ठीक से इसकी जाँच नहीं की

— मिकट

3

चारकोल , 9 बाइट्स

¿﹪Ｉθ÷χ⁵→θ

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

मूल रूप से यह इनपुट को ठीक से प्रिंट करता है यदि यह 10/5 का गुणक नहीं है ( चारकोल कोड पेज² में भी चार है )। उपयोग किए गए वर्ण हैं:

¿: कोड BF।
﹪: कोड A5।
Ｉ: कोड C9।
θ: कोड F1।
÷: कोड AF।
χ: कोड E3।
⁵: कोड B5।
→: कोड 13।

वास्तव में →अंत के निकट निरर्थक है, लेकिन फिर मैंने देखा कि उत्तर के लिए एक विषम लंबाई होनी चाहिए ...

स्पष्टीकरण:

¿      if (
 ﹪      Modulo (
  Ｉθ      the input as number,
  ÷χ⁵      χ (predefined value: 10) divided by 5 = 2 ) [is 1])
 →θ      then print rightwards the input as string

— चार्ली
स्रोत

आप छपाई कर रहे हैं और फिर सही चल रहे हैं; वास्तव में प्रिंट सही होगा →θ।

— नील

@ नील उफ़, तय। कम से कम कि मेरे जवाब को अमान्य नहीं किया ...:

— चार्ली

3

x86_64 मशीन कोड (लिनक्स), 12 11 बाइट्स

दुर्भाग्य 0x80से भी है, लेकिन यह अभी भी काम किया (यह मानते हुए कि "कुछ भी नहीं करता है" का अर्थ है वापस न आना):

0000000000000000 <odd>:
   0:   8d 07                   lea  (%rdi), %eax
   2:   83 e7 01                and    $0x1, %edi
   5:   83 ff 01                cmp    $0x1, %edi
   8:   75 fb                   jne       5  <odd+0x5>
   a:   c3                      retq

-1 बाइट, धन्यवाद @CodyGray!

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

— ბიმო
स्रोत

1

चूंकि यह x86-64 है, इसलिए जब स्रोत 32-बिट रजिस्टर होता है , तो lea (%edi),%eaxएड्रेस साइज ओवरराइड प्रीफिक्स ( 0x67) की आवश्यकता होती है । जिसे करके आप खत्म कर सकते हैं lea (%rdi),%eax। यह एक बाइट बचाता है, और वास्तव में कोड को थोड़ा और अधिक कुशल बना देगा (उपसर्गों ने डिकोडिंग को धीमा कर दिया और आई-कैश को भर दिया)। कुछ अन्य चीजें हैं जो आप इसे और भी छोटा कर सकते हैं, लेकिन यह अनिवार्य रूप से एक पूर्ण पुनर्लेखन का गठन करता है, इसलिए मैं अपना उत्तर पोस्ट करूंगा। :-) मैंने इसे उतारा है, वह भी, बिल्कुल! (ओह, बस एहसास हुआ कि आपने छलांग को ऑफसेट अजीब बनाने के लिए उपसर्ग का उपयोग किया होगा। खैर, आपको अधिक जादू की आवश्यकता होगी।)

— कोडी ग्रे

इसके अलावा, वास्तव में TIO के लिए चतुर समाधान! मैं इसे अपने अधिकांश asm उत्तरों में छोड़ रहा हूँ क्योंकि मैं asm में आउटपुट प्रिंट करने के लिए "footer" में सभी बॉयलरप्लेट नहीं लिखना चाहता था। मैं अंत में खराब हो गई है और यह दूसरे दिन किया था, लेकिन यह एक है ज्यादा बेहतर विचार है, तो आप सब कुछ के लिए C उपयोग करने के लिए अनुमति देता है। मैं अब से यह चोरी कर रहा हूँ! :-)

— कोडी ग्रे

आपके इनपुट के लिए चीयर्स, मैं असेंबली में पूरी तरह से नॉब हूं लेकिन यह काफी आसान लग रहा था! आपके समाधान के लिए उत्सुक। ओह, इसका श्रेय @ceilingcat को जाता है - मैंने इसे खुद चुरा लिया;)

— '

मैं वास्तव में आपको एक बाइट नहीं बचा पाया ... आपके पास अब निर्देश के F6लिए एक बाइट भी है ( JNEक्योंकि इसमें एक ऑफसेट भी है। यही कारण है कि मैं अंतिम पैतृक द्वारा मैं अपनी पहली टिप्पणी में संपादित किया था। आपको वास्तव में एक अजीब संरेखण बनाने के लिए उस उपसर्ग की आवश्यकता है। या आपको किसी अन्य तरीके से कोड को फिर से लिखना होगा। मैंने विभिन्न रूपों का एक गुच्छा के साथ खेला। मैंने वास्तव में पिछली रात को देखा था और OUTविषम मानों का उपयोग करने के लिए एक अच्छा तरीका निकालने की कोशिश कर रहा था , लेकिन वास्तव में मेरे लिए कोई अच्छा समाधान नहीं हुआ। मेरे लिए यहाँ अंतर्दृष्टि भी मूल्यों के लिए एक अनंत लूप में जाने के लिए है।

— कोडी ग्रे

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

— कोडी ग्रे

3

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

गैर-गोल्फ भाषा में पहला समाधान होने की अपील करें।

a=1+1;g[i_/;!a\[Divides]i]=i

में MacintoshChineseTraditionalचरित्र एन्कोडिंग। \[Divides]है {161, 253}(2 बाइट्स)

वैकल्पिक संस्करण (23 बाइट्स)

\[CapitalAlpha]=1+1;\[CapitalGamma][\[CapitalChi]_/;\[CapitalAlpha]\[LeftFloor]\[CapitalChi]/\[CapitalAlpha]\[RightFloor]\[NotEqual]\[CapitalChi]]=\[CapitalChi]

या (यूनिकोड में दिखाया गया है)

Α=1+1;Γ[Χ_/;Α⌊Χ/Α⌋≠Χ]=Χ

में Symbolचरित्र एन्कोडिंग। (केवल 1-बाइट वर्ण का उपयोग करें)

समाधान एक फ़ंक्शन g(या Γ) को परिभाषित करता है, जो इनपुट विषम होने पर इनपुट का मूल्यांकन करता है, और शाब्दिक रूप से "कुछ भी नहीं करता है" (मूल्यांकन नहीं करता है) जब इनपुट सम है।

— user202729
स्रोत

+1 बाइट ( ;अंत में) यदि बाइट की संख्या सम होनी चाहिए; और \[Divides]विषम यूनिकोड कोडपॉइंट भी है।

— user202729

आप की जरूरत नहीं है I[1+1], आप बस का उपयोग कर सकते हैं {1+1}। इसके अलावा, क्या आपने जाँच की है कि फर्श कोष्ठक के बाइट्स वैध हैं? यदि हां, तो आप प्राप्त कर सकते हैं 2से \[LeftFloor]E\[RightFloor]।

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

@MartinEnder केवल Symbolमंजिल को वैध बनाते हैं, लेकिन इसके पास न तो है Eऔर न ही है \[ExponentialE]।

— user202729

मुझे डर है कि आपको पात्रों का उपयोग करने की अनुमति नहीं है D; v; और न ही d, क्योंकि उनके पास एक भी बाइट-वैल्यू है .. :(

— केविन क्रूज़सेन

1

@ केविनक्रूजसेन \[Divides], मैथेमेटिका में एक एकल पात्र है, जिसे 2 बाइट्स द्वारा दर्शाया गया है {161, 253}।

— user202729

3

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

की आवश्यकता है -E।

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

s//A_=Y[;A_=A_%O?A_W''/;y/#A-_/#-A/;s/[#-}]+/uc/ee;say

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

व्याख्या

डिफ़ॉल्ट रूप से, पर्ल के अधिकांश स्ट्रिंग फ़ंक्शन काम करते हैं $_, जो शुरू करने के लिए खाली है।

सबसे पहले, s//A_=Y[;A_=A_%O?A_W''/में रिक्त स्ट्रिंग की जगह $_के साथ A_=Y[;A_=A_%O?A_W''है, तो y/#A-_/#-A/निम्न सूची के आधार पर वर्ण (चार से ऊपर नीचे चार हो जाता है) को बदल देता है:

#ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
#$%&'()*+,-./0123456789:;<=>?@A

जिसमें अद्यतन $_शामिल हैं $_=<>;$_=$_%2?$_:''। इसके बाद s/[#-}]+/uc/eeसभी वर्णों [#-}]+को बदल देता है uc। इसके बिना /eeसिर्फ स्ट्रिंग होगी uc, लेकिन /eeदो बार स्ट्रिंग की सामग्री का मूल्यांकन करता है। पहला मूल्यांकन का परिणाम देता है uc, जो एक अपरकेस संस्करण है, $_लेकिन चूंकि $_इसमें कोई वर्णमाला वर्ण नहीं हैं, यह सिर्फ पूरी स्ट्रिंग लौटाता है, तो दूसरा /eफिर से स्ट्रिंग का मूल्यांकन करता है, जो $_या तो $_(इनपुट नंबर) या फिर या ''उसके आधार पर सेट होता है संख्या विषम या सम नहीं है।

अंत में, चूंकि $_अब हम जो चाहते हैं, उसमें हम कॉल करते हैं say(जो -Eइसके बजाय आवश्यक है -e) जो $_एक नई पंक्ति के बाद प्रिंट करता है ।

वैकल्पिक पर्ल, 93 बाइट्स

92 बाइट्स कोड + 1 के लिए -p, जो मुझे लगता है कि यह गैर-प्रतिस्पर्धात्मक होगा।

s//_/g;s//uc/e;y/\x09-\x0b/_/;s/____/}[/;s/___/%C]/;s/_/{''H/;y/'{}1CDGH/'-)1-3+--/;s/[#-}]+/uc/ee

इसमें एक टैब और एक ऊर्ध्वाधर टैब होता है y///, जैसा संकेत दिया गया है \x09और \x0b।

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

— डोम हेस्टिंग्स
स्रोत

2

लोगो , 390 46 52 50 बाइट्स

[ask    1   se[make]iseq    1-3 cos ?/ask   1[1/sum 1   179]?]

यह एक टेम्प्लेट-सूची है जो इनपुट के अजीब होने पर इनपुट लौटाता है, और यदि इनपुट सम है तो त्रुटि का कारण बनता है।

उपयोग:

show invoke [ask ... (paste code here) ... ] 5

उत्पादन

चूंकि 5 विषम है, और

invoke [ask ... (paste code here) ... ] 6

एक त्रुटि का कारण होगा क्योंकि 6 भी है।

— user202729
स्रोत

2

टीआई-बेसिक, 14 बाइट्स

Input Q
sinֿ¹(gcd(Q²,int(e
Q

यह एक सम संख्या पर एक डोमेन त्रुटि (होमस्क्रीन पर कुछ भी नहीं छापना) फेंकता है।

Input Q             Q is a variable with an odd code. We cannot use "Ans" as it's even.

            int(e   floor(e) = 2; "2" is even.
         Q²         Q may be negative, so we square it which preserves parity.
     gcd(Q²,int(e   1 if Q is odd; 2 if Q is even.
sinֿ¹(gcd(Q²,int(e   Error iff Q is even.

Q                   If there was no error, print Q.

— lirtosiast
स्रोत

1

पायथ , 14 11 10 9 बाइट्स

I + Q_ + K / Q + 3_1KQ 
I! SIcQ + 3_1Q 
I! U + 1__QQQ
? यू + 1_GQ1k

टेस्ट सूट ।

— लीक नन
स्रोत

यह एक चतुर तरीका है, लेकिन कुछ I%Qy1Qभी काम नहीं करना चाहिए ?

— जकुबे

@ जाकुब मैं स्पष्ट रूप से समझ नहीं पाया y1... हालांकि %, दुख की बात नहीं है।

— लीक नून

क्यों नहीं? %का आस्की मान 37 है और विषम है।

— जकूबे

3

@ जाकुब क्योंकि स्पष्ट रूप से मुझे इस सूची में ओपी द्वारा प्रदान की गई (जो कि गलत है) पर भरोसा है

— लीक नून

1

जाप , 4 बाइट्स

u)çU

Japt ISO / IEC 8859-1 का उपयोग करता है , इसलिए यह (दशमलव में) से मेल खाता है 117 41 231 85।

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

व्याख्या

Uu)çU   Implicit: U = input integer
Uu)     Return Python-style U % (missing argument = 2). This gives 1 if U is odd, 0 if even.
   çU   Implicitly convert U to a string and repeat it that many times.
        Implicit: output result of last expression

मैंने पहली बार समाधानों का उपयोग करने की कोशिश की p, जो मूल रूप çसे उल्टे तर्कों के साथ है। हालाँकि, pयदि उसका बाएँ तर्क एक संख्या है, तो घातांक करता है, इसलिए हमें इसे स्पष्ट रूप से एक स्ट्रिंग में बदलने की आवश्यकता होगी। यह समाधान वास्तव में एक बाइट से छोटा हो जाता है, इसके अलावा किसी भी विषम बाइट को शामिल नहीं किया जाता है।

— ETHproductions
स्रोत

1

डीसी , 21 बाइट्स

[c]sa?kKKCI-1;1k%1!=a

दशमलव: 91 99 93 115 97 63 107 75 75 67 73 45 49 59 49 107 37 49 33 61 97

इस IO डिफ़ॉल्ट के अनुसार , यह प्रोग्राम इनपुट को मुख्य स्टैक पर छोड़ देता है यदि यह विषम है और स्टैक को खाली करता है अन्यथा। इस fकार्यक्रम के अंत में डिबग कमांड को जोड़कर इसकी पुष्टि की जा सकती है जैसा कि TIO पेज पर होता है।

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

व्याख्या

[    # Begin macro definition.
 c   # Clear the main stack.
]sa  # End macro definition and push the macro into register "a".
?k   # Prompt for input and store it into precision parameter "k".
KK   # Push two copies of the input to the main stack.
CI-  # Push C-I = 12-10 = 2 to the main stack  
1;1  # Push the value stored in the first index of array "1" (0 by default) 
     # to the main stack. 
k    # Push 0 into parameter "k" to reset the precision (otherwise the modulus 
     # function will not work correctly).
%    # Push the input (mod 2) to the main stack.
1!=a # If the input (mod 2) does not equal 1, execute the macro in register "a".
f    # OPTIONAL: Output the contents of the main stack.

— आर। कप
स्रोत

1

टीआई-बेसिक, 18 बाइट्स

2 बाइट्स lirtosiast के लिए धन्यवाद बचा लिया

:Prompt Q
:While 5Q/ᴇ1-int(5Q/ᴇ1
:Q

बाइट्स में (+2 newlines = 3F)

:Prompt Q
 DD     51
:While 5Q/ᴇ1-int(5Q/ᴇ1
 D1    35 3B B1  35 3B  
        51 31     51 31
         83 71     83
:Q
 51

Http://tibasicdev.wikidot.com/one-byte-tokens देखें

— ओकी
स्रोत

1

क्यों नहीं fPart का उपयोग करें? (?

— lirtosiast

@lirtosiast tibasicdev.wikidot.com/one-byte-tokens के अनुसार एक भी बाइट (BA = 186) लगता है

— Oki

ओह, मैंने गलत सूचना दी कि कौन सी प्रविष्टियाँ पंक्तियाँ थीं और कौन से स्तंभ हैं।

— lirtosiast

1

मैंने पाया Input Q[newline]sinֿ¹(gcd(Q²,int(e[newline]Q(14 बाइट्स)। क्या मुझे अलग उत्तर के रूप में पोस्ट करना चाहिए?

— lirtosiast

@lirtosiast वाह! यह निश्चित रूप से एक अलग जवाब के लिए पर्याप्त अलग है। इसे प्यार करें

— Oki

1

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

¥{k

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

प्रयुक्त बाइट्स हैं 157, 123, 107।

व्याख्या

¥     Input modulo 2
 {    Loop that many times
  k   Push input

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

0

बैश , 31 बाइट्स

read a
[ $[a%2] = 0 ] ||echo $a

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

स्पष्टीकरण:

read a                   reading the input and define it on the variable a
[ $[a%2] = 0 ]      outputs exit status 0 when a/2 is 0 and exit status 1 if not.
||                           evaluates only when the exit status left of it is 1
echo $a                displays the variable a

— ADDB
स्रोत

आपको लगता है कि यह एक प्रतिबंधित स्रोत चुनौती है - आप निषिद्ध बाइट्स का उपयोग कर रहे हैं। ( rd $20|hऔर न्यूलाइन।)

— अर्जन जोहान्सन

@ ADrrrJohansen ने तय किया कि मुझे लगता है

— ADDB

2

उम नहीं। कार्यक्रम की लंबाई पर कोई प्रतिबंध नहीं है, लेकिन इसमें प्रत्येक वर्ण का एक विषम बाइट मान होना चाहिए।

— अर्जन जोहान्सन

मैं भी नहीं ... मैं केवल अजीब!

जाप -f , 1 बाइट

Lenguage , 645529908926937253684695788965635909332404360034079 9394157991500940492270727190763049448735 1174269748937617561533841898064735499551 2293382937520069758100171520285996319 बाइट्स

x86-64 मशीन कोड, 8 बाइट्स

x86-64 मशीन कोड (सीरियल पोर्ट के लिए आउटपुट), 17 बाइट्स

जेली , 2 बाइट्स

05AB1E , 3 बाइट्स

MATL , 3 बाइट्स

व्याख्या

हास्केल , 36 33 बाइट्स

पायथन आरईपीएल, 38 बाइट्स

स्पष्टीकरण:

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

क्यूबिक्स , 23 19 17 बाइट्स

चारकोल , 9 बाइट्स

x86_64 मशीन कोड (लिनक्स), 12 11 बाइट्स

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

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

व्याख्या

वैकल्पिक पर्ल, 93 बाइट्स

लोगो , 390 46 52 50 बाइट्स

टीआई-बेसिक, 14 बाइट्स

पायथ , 14 11 10 9 बाइट्स

जाप , 4 बाइट्स

व्याख्या

डीसी , 21 बाइट्स

व्याख्या

टीआई-बेसिक, 18 बाइट्स

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

व्याख्या

बैश , 31 बाइट्स

स्पष्टीकरण:

जाप `-f` , 1 बाइट