बात दुभाषिया की

10

"टॉक" एक baroquified संचायक-आधारित भाषा है, जो talk.tryitonline.net पर डेनिस की बोली के जवाब में बनाई गई है ।

Waiting for someone to create an esolang called talk.

। "टॉक" भाषा में 4 कमांड हैं:

  • 00 यदि संचायक 0 है, तो संचायक को 0 पर सेट करें।
  • 01 यदि संचायक 0 है, तो संचायक को 1 पर सेट करें।
  • 10 यदि संचायक 1 है, तो संचायक को 0 पर सेट करें।
  • 11 यदि संचायक 1 है, तो संचायक को 1 पर सेट करें।

इनपुट:

  • इनपुट को हमारे मानक I / O नियमों द्वारा किसी भी स्वीकार्य इनपुट विधि के माध्यम से लिया जा सकता है।

  • दो इनपुट हैं, प्रारंभिक संचयकर्ता मान और प्रोग्राम। यदि आप चाहें, तो आप इन दोनों इनपुट को एक इनपुट में मर्ज कर सकते हैं या अपने इनपुट को मान्य कमांड में विभाजित [00, 01, 00]कर सकते हैं।

आउटपुट:

  • एक कमांड निष्पादन के अंत में, संचायक को अनुमानित रूप से आउटपुट किया जाता है।

नियम:

  • इनपुट कर सकते हैं एक एकल स्ट्रिंग या चरित्र सूची हो।
  • जैसा कि यह है कोड गोल्फसबसे छोटा जवाब, बाइट्स में, जीतता है।
  • हम अंक या तार / अक्षर लेते हैं।

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

0 0001111101 -> 1
0 000100 -> 1
0 11001000 -> 0

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

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

code-golf  interpreter 
3
तो वहाँ दो आदानों, आदेशों का अनुक्रम और प्रारंभिक संचायक मूल्य है?
— xnor
4
कुछ परीक्षण मामले जो संचायक को नहीं बदलते हैं, संचयकर्ता में 1 से शुरू होता है या कोई निर्देश अच्छा नहीं होता है
— जो किंग
8
क्या टॉक को वास्तव में एक प्रोग्रामिंग भाषा माना जा सकता है ?
— लुइस मेंडो
8
@A_ वह टिप्पणी शायद मजाक के रूप में थी। दिन में वापस, लैंग नामक भाषा में एक URL होगा lang.tryitonline.net(अब यह है tio.run/#lang)। तो टॉक नामक भाषा तत्कालीन हाल ही में बनाई गई चैटरूम के लिए URL के साथ भ्रम पैदा करेगी, जो हैtalk.tryitonline.net
— लुइस मेंडो
7
भविष्य में, कृपया कई उत्तर पोस्ट किए जाने के बाद I / O को बदलने से बचना चाहिए। मैं आज वापस आया और मैप किए गए इनपुट की अनुमति देते हुए मैंने जो उत्तर दिया उससे यह पूरी तरह से अलग चुनौती है ।
— गामाफंक्शन

जवाबों:

21

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

y@/

इनपुट एकल सूची है: संचायक, उसके बाद जोड़े।

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

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

yपरमाणु प्रदर्शन लिप्यंतरण; [क, ख] yग की जगह एक साथ ख , तो यह रिटर्न ख अगर एक = ग और ग अगर एक ≠ ग ।

y@/सिलवटों / इनपुट yको स्वैप किए गए तर्कों के साथ घटाता है, प्रति जोड़े एक लिप्यंतरण का प्रदर्शन करता है।

— डेनिस
स्रोत
14
यह एकमात्र जेली उत्तर है जो मैंने अब तक देखा है कि केवल ASCII वर्णों का उपयोग करता है।
2
— डेनिस
21

पायथन 3 , 43 बाइट्स

lambda s:re.sub("00|11","",s)[-1]
import re

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

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

मुश्किल हिस्सा साबित होता है कि समाधान सही परिणाम देता है। इसे देखने के लिए, हमें कमांड के गहन विश्लेषण की आवश्यकता है। सबसे पहले, हम देख सकते हैं कि कमांड्स में निम्नलिखित गुण हैं:

  • संपत्ति (1) : कमांडर 00और 11संचायक स्थिति को बनाए रखें।
  • संपत्ति (2) : आदेश 01और 10संचायक राज्य को उसकी मूल स्थिति की परवाह किए बिना दूसरे बिट के समान बनाते हैं।

इसलिए, अंतिम संचायक स्थिति है:

  • केस 1 : यदि कोई 01या 10आदेश मौजूद नहीं है, तो अंतिम स्थिति प्रारंभिक राज्य के समान है।
  • केस 2 : अन्यथा, अंतिम 10या 01कमांड का अंतिम बिट ।

आगे हम समाधान दिखाएंगे कि दोनों मामलों में सही परिणाम मिलेगा। हम अंतिम राज्य के लिए बयान को साबित करेंगे 0और अंतिम राज्य के 1अनुरूप साबित किया जा सकता है। यदि अंतिम स्थिति 0इनपुट निम्न में से किसी एक रूप में है:

  • ^0{2k+1}11(11|00)*

    के लिए केस 1 , इनपुट स्ट्रिंग sसे प्रारंभ होना चाहिए 2k+10, जिसके बाद 11और 00आदेशों। 00एस और 11एस को खत्म करने से एक एकल पैदावार होती है 0, जो अंतिम स्थिति है।

  • .+10{2k+1}11(11|00)*

    के लिए केस 2 , एक साथ इनपुट स्ट्रिंग समाप्त होता है 10आदेश, शून्य या अधिक द्वारा पीछा किया 00और 11रों। यह पैटर्न 0 के 1बाद के बराबर है 2k+1, और फिर शून्य या अधिक 11एस और 00एस। को खत्म करना 00है और 11की पिछले एक के पीछे रों पत्ते 2k+1स्ट्रिंग, जो अंतिम राज्य का प्रतिनिधित्व के अंत में 0।

उपरोक्त सभी के आधार पर, एक ही पास में एक साथ00 s और 11s को समाप्त करने के बाद ( यदि एक पास में और फिर दूसरे पास में समाप्त हो गया है तो एक काउंटर-उदाहरण है ) इनपुट से , अंतिम वर्ण अंतिम स्थिति है। इसलिए समाधान की शुद्धता साबित होती है।010010011s

— जोएल
स्रोत
PPCG में आपका स्वागत है! उत्कृष्ट उत्तर, और इसके साथ जाने के लिए एक अच्छा औपचारिक प्रमाण!
— गामा फंक्शन
3
धन्यवाद। मुझे लगता है कि लोगों को संदेह हो सकता है कि इस तरह के एक सरल समाधान पहली नज़र में सही परिणाम देता है। अतः उसके लिए एक प्रमाण देने की आवश्यकता है।
— जोएल
9

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

{m/.)>[(.)$0]*$/}

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

"आप इन दो इनपुटों को एक इनपुट में मर्ज कर सकते हैं, यदि आप चाहें तो इनपुट ले सकते हैं" जैसे कि संचायक मान को कमांड के साथ समाहित मान लिया जाता 1,[00,11]है 10011। यदि यह ठीक नहीं है, तो इसे लेने के लिए केवल 5 अतिरिक्त बाइट्स हैं f(accumulator, commands)। एक मैच ऑब्जेक्ट लौटाता है जिसे एक स्ट्रिंग के लिए मजबूर किया जा सकता है।

स्पष्टीकरण:

{                }  # Anonymous code block
 m/             /   # Find the first match from the input
   .)>              # Capture a number
      [     ]*      # Followed by any number of
       (.)$0        # Pairs of identical characters
              $     # Ending the string

मूल रूप से यह काम करता है क्योंकि 00और 11आदेश शाब्दिक रूप से कुछ भी नहीं करते हैं, जबकि01 और 10कमांड केवल संचायक को कमांड के दूसरे अंक में सेट करते हैं। यदि कोई कमांड नहीं हैं, तो इसके बजाय संचायक का प्रारंभिक मूल्य लेता है।

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

Zsh , 33 बाइट्स

चरित्र सूची को तर्कों के रूप में पारित किया जाता है, संचायक का प्रारंभिक मूल्य स्टड के रूप में पारित किया जाता है।

read a
for x y;a=$[x^a?a:y]
<<<$a

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

39 बाइट्स : यदि कमांड्स में एक स्ट्रिंग होना चाहिए

इनपुट accumulator commandsतर्क के रूप में है। 

for x y (${(s::)2})1=$[x^$1?$1:y]
<<<$1

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

मज़े के लिए, यहाँ एक 50 बाइट पुनरावर्ती एक लाइनर ( TIO ) है:

<<<${${2+`f $[$1^${2[1]}?$1:${2[2]}] ${2:2}`}:-$1}
— GammaFunction
स्रोत
6

पायथन 3 , 52 बाइट्स

f=lambda a,s:s and f([s[1],a][s[0]==s[1]],s[2:])or a

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

चास ब्राउन के लिए निश्चित असंगत वापसी प्रकार धन्यवाद

इनपुट को दो तार के रूप में लेता है; संचायक और कोड।

— नकारात्मक सात
स्रोत
अरे नहीं, वह तेज था।
— HighlyRadioactive
1
अच्छा लगा लेकिन इसमें यह संभावित समस्या है - f(1,'11')==f(1,'01')है False; यह कभी-कभी लौट आता है intऔर कभी-कभी str। तो शायद यह निर्दिष्ट करें कि यह स्ट्रिंग के रूप में एसीसी इनपुट लेता है?
— चास ब्राउन
@ChasBrown अच्छा कॉल, जो मैं सोच रहा था, उससे बहुत सरल है।
— नकारात्मक सात
अच्छा है, लेकिन चूंकि आपका फ़ंक्शन पुनरावर्ती है, इसलिए यह अनाम नहीं हो सकता है। यह 52 बाइट्स होना चाहिए ।
— जित्स
5

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

tġ₂≠ˢtt|h

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

चूंकि यह काफी लंबे समय से है कि मैं प्रत्येक कमांड के बाद संचायक को प्रिंट करने की धारणा को भूल गया हूं, मैंने जो किंग के पर्ल जवाब से कुछ प्रेरणा लेकर काफी कम भोली समाधान तैयार किया है।

       |     The output is
     tt      the last element of the last element of
t            the last element of the input
 ġ₂          split into length-2 slices
   ≠ˢ        with equal pairs removed.
       |     If there is no such element, the input
        h    's first element is the output.

पुराना समाधान:

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

ġ₂ᵗc{th~h?tt|h}ˡ

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

इनपुट प्रारूप को बदलने से -2 बाइट्स।

— असंबंधित स्ट्रिंग
स्रोत
5

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

इनपुट के रूप में लेता है (a)(code), जहां कोड एक है 2-बिट पूर्णांक की सूची।

a=>c=>c.map(x=>a^=x==a+1)|a

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

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

इनपुट के रूप में लेता है (a)(code), जहां कोड एक स्ट्रिंग है।

a=>c=>c.replace(/../g,x=>a^=x%4==a+1)&&a

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

कैसे?

सभी संभावित मामलों को नीचे संक्षेप में प्रस्तुत किया गया है। केवल दो मामलों में जहां हमें संचायक को टॉगल करने की आवश्यकता होती है(a=0,x=012) तथा (ए=1,एक्स=102)।

  a | x (bin) | int(x) % 4 | a + 1 | equal?
----+---------+------------+-------+--------
  0 |   "00"  |  0 % 4 = 0 |   1   |   N
  1 |   "00"  |  0 % 4 = 0 |   2   |   N
  0 |   "01"  |  1 % 4 = 1 |   1   |   Y
  1 |   "01"  |  1 % 4 = 1 |   2   |   N
  0 |   "10"  | 10 % 4 = 2 |   1   |   N
  1 |   "10"  | 10 % 4 = 2 |   2   |   Y
  0 |   "11"  | 11 % 4 = 3 |   1   |   N
  1 |   "11"  | 11 % 4 = 3 |   2   |   N
— Arnauld
स्रोत
4

sed -E, 26 19 बाइट्स

एक जोड़ी -7 बाइट्स @Cowsquack से सभी जोड़े को हटाने के साथ ही काम करता है।

s/(.)\1//g
s/.*\B//

स्टड पर एक साथ इनपुट को अलग किया जाता है। जो किंग के पर्ल जवाब से प्रेरित है । पट्टी अनुगामी जोड़े सभी जोड़े निकालें, फिर अंतिम अंक प्राप्त करें।

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

— GammaFunction
स्रोत
1
अंतिम पंक्ति बस हो सकती है s/.*\B//, लेकिन दृष्टिकोण को बदलने वाले किसी भी मार्ग को थोड़ा छोटा 19 बाइट्स देता है इसे ऑनलाइन आज़माएं!
— user41805
1
हुह, मुझे नहीं लगा कि s/(.)\1//gयह काम करेगा, क्योंकि यह एक जोड़ी के अंत और अगले की शुरुआत को हटा सकता है, लेकिन यह अभी भी काम करता है। अति उत्कृष्ट!
— गामाफंक्शन
@GammaFunction मेरे समाधान में दिखाए गए के s/(.)\1//gबराबर है s/00|11//g।
— जोएल
4

रेटिना 0.8.2 , 18 11 बाइट्स

(.)\1

!`.$

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

— नील
स्रोत
— user41805
@Cowsquack D'oh, एक बार जब आप चरणों को अलग करने के बारे में सोचते हैं, तो पहले से ही 2 बाइट की बचत होती है, फिर एक और बाइट बचती है क्योंकि आप इसका उपयोग कर सकते हैं !`.$ , और फिर एक और 4 बाइट्स क्योंकि आपको अनुगामी जोड़े को सीमित करने की आवश्यकता नहीं है ...
— नील
4

पायथन 3 , 38 बाइट्स

lambda l:[y for*x,y in l if[y]!=x][-1]

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

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

प्रारंभिक संचायक मान के माध्यम से इस गिरावट को बनाने के लिए जब ऐसी कोई आज्ञा नहीं होती है, तो हम इसे बनाते हैं ताकि एकल-चार प्रारंभिक मूल्य स्ट्रिंग परीक्षण पास हो जाए। हम ऐसा करके जाँच करते हैं कि पिछले चरित्र के साथ एक सिंगलटन सूची सभी पूर्ववर्ती पात्रों की सूची के लिए असमान है, जो कि किसी भी लम्बाई-एक स्ट्रिंग या लंबाई-दो स्ट्रिंग के साथ दो अलग-अलग पात्रों द्वारा पारित की जाती है।

— XNOR
स्रोत
3

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

EÐḟṪṪo

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

निक कैनेडी के लिए -2 बाइट्स ने मुझे नियमों में बदलाव की जानकारी दी। (उनका प्रस्तावित गोल्फ, EÐḟFȯṪकुछ अधिक ही चतुर लगता है, लेकिन मेरे पिछले समाधान माइनस के समान ही लंबाई है s2।) इनपुट प्रारूप अब कमांड को दो-वर्ण स्ट्रिंग्स की सूची के रूप में लेता है, लेकिन परीक्षण पाद लेख सुविधा के लिए पुराने प्रारूप से अनुवाद करता है।

मेरे नए Brachylog समाधान से अनुवादित।

पुराना संस्करण:

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

ḢẎ⁼⁹a⁸o
s2ç@ƒ

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

मुझे 100% यकीन नहीं है कि यह सही है, लेकिन यह सभी तीन परीक्षण मामलों पर सफल होता है। आदेशों को बाएं तर्क के रूप में और आरंभिक संचायक को सही तर्क के रूप में लेता है।

— असंबंधित स्ट्रिंग
स्रोत
1
इनपुट को एक सूची में विभाजित करने की अनुमति है, इसलिए आप EÐḟFȯṪइनपुट के साथ हो सकते हैं जैसे [[0,0],[0,1],[1,1],[1,1],[0,1]]।
— निक केनेडी
वाह, वास्तव में कल्पना के परिवर्तन काफी बड़े थे ...
— असंबंधित स्ट्रिंग
3

हास्केल , 29 बाइट्स

प्रकार के साथ पहली पंक्ति पर एक अनाम फ़ंक्शन को परिभाषित करता है (Foldable t, Eq b) => b -> t [b] -> b। इस कोड गोल्फ के प्रयोजनों के लिए, हम इसे इंस्टेंट कर सकते हैं Char -> [String] -> Charजहां पहला तर्क संचायक है और दूसरा स्ट्रिंग की एक सूची है जिसमें प्रत्येक स्ट्रिंग एक ही कमांड है।

foldl(#)
a#[x,y]|a==x=y|1>0=a

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

— आंख-morpork
स्रोत
1
यदि आप इसे उपसर्ग संकेतन का उपयोग करके परिभाषित करते हैं तो वही बायटेकाउंट । मुझे विश्वास नहीं हो रहा है कि मैंने एक ही समय में लगभग एक ही उत्तर लिखा है, यहां तक ​​कि टाइप सिग्नेचर स्पष्टीकरण भी शामिल है ...
— कोल
2

अजगर, 111 बाइट्स

def f(a,b):
    c=a
    for i in range(0,len(b)-1,2):
        c=(not b[i])*(c or b[i] or b[i+1]) or c*b[i]*b[i+1]
    return c

Ungolfed। संपादित करें: AHHH किसी ने मुझे इसे हराया!

— HighlyRadioactive
स्रोत
2

केग ,, -ir16 बाइट्स

"(!;½|':"=['_"|_

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

व्याख्या की:

  1. निहित इनपुट लेता है और सही संचायक मान को नीचे तक ले जाता है

  2. निम्नलिखित को दोहराएं (स्टैक की लंबाई - 1 2 से विभाजित) बार

2.1। संचायक को शीर्ष पर वापस शिफ्ट करें

2.2। कमांड के पहले भाग के साथ समानता के लिए तुलना करें

2.2.1। यदि सही है, तो संचायक को बदलें, अन्यथा प्रतिस्थापन को पॉप करें

इनपुट को स्रोत के साथ आरंभिक एसीसी मूल्य के रूप में लिया जाता है। उदाहरण के लिए

010011000
  • प्रथम चार मूल्य है
  • बाकी कार्यक्रम है
— Lyxal
स्रोत
1

बैश , 58 40 बाइट्स

एक पूर्ण कार्यक्रम के लिए एक बाइट जोड़ें: इसमें परिवर्तन fकरें $0।

(($1=$2-a?a:$3,1))&&f $1 ${@:4}||echo $1

58 बाइट्स इसे ऑनलाइन आज़माएं!

जब टर्नरी झूठे वापस आ जाएगा $1 सेट किया जाता है0 , लेकिन ,1अंत में एक सिंटैक्स त्रुटि को छोड़कर पूरा ((expression))सच हो जाएगा ।

जब सभी तर्कों का उपभोग किया जाता है, तो एक सिंटैक्स त्रुटि होती है और पुनरावृत्ति समाप्त होती है।

— GammaFunction
स्रोत
1

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

Ｆ⪪η²Ｆ⁼θ§ι⁰≔§ι¹θθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। अलग-अलग तर्क देता है। स्पष्टीकरण:

Ｆ⪪η²

निर्देशों को अंकों के जोड़ों में विभाजित करें और उन पर लूप करें।

Ｆ⁼θ§ι⁰

यदि संचायक पहले अंक के बराबर है ...

≔§ι¹θ

... इसके बाद दूसरा अंक असाइन करें।

θ

संचयकर्ता को लूप के अंत में प्रिंट करें।

— नील
स्रोत
1

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

fؽḂ⁹;Ṫ

एक डायडिक लिंक प्रोग्राम को बाईं ओर पूर्णांक और दाईं ओर प्रारंभिक संचयकर्ता की सूची के रूप में स्वीकार करता है जो पूर्णांक देता है।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें

— जोनाथन एलन
स्रोत
मैं इनपुट-मैपिंग को हटा रहा हूं क्योंकि @GammaFunction ने मुझे ऐसा करने की सिफारिश की थी।
@A_ ah OK खिचड़ी भाषा मोबाइल पर डिलीट हो जाती है इसलिए इसे बाद में संबोधित करना होगा
— जोनाथन एलन
@A_ ने 0,1,2,3 के साथ काम करने के लिए तय किया है कि अंक के रूप में निर्देशों का अनछुए संस्करण ठीक है?
— जोनाथन एलन
1
हां वह ठीक है।
1

रूनिक एनकाउंटर , 28 बाइट्स

/~@/i~/i<
/=?/~iR:l}i{l1-=?!

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

अंतरिक्ष अलग बाइट्स की एक श्रृंखला के रूप में इनपुट लेता है (रूनिक सूचियों को नहीं समझता है)। पहला बाइट प्रारंभिक अवस्था है और प्रत्येक अन्य बाइट कार्यक्रम है। कोई सत्यापन नहीं किया जाता है (अर्थात यह केवल मान्य कार्यक्रमों को इनपुट के रूप में दिया जाता है और यह परवाह नहीं करता है कि किस मूल्य का उपयोग प्रतिनिधित्व करने के लिए किया जाता है 0और 1)।

— Draco18s अब SE पर भरोसा नहीं करता है
स्रोत
1

x86 असेंबली, 33 बाइट्स

प्रारंभिक संचयकर्ता स्थिति CL(पूर्णांक 0या 1) और एक शून्य-समाप्त ASCII स्ट्रिंग के रूप में आदेशों का पता लेता है ESI। अंतिम संचायक स्थिति में छोड़ देता हैCL ।

ऑफसेट पर कॉल निर्देश को इंगित करें 0x1B( interpretस्पष्टीकरण में लेबल )।

3C 30 74 03 B0 01 C3 30 C0 C3 E8 F1 FF FF FF 38
C8 AC 75 07 E8 E7 FF FF FF 88 C1 AC 84 C0 75 EA
C3

स्पष्टीकरण (इंटेल सिंटैक्स का उपयोग करके):

; function to convert ASCII '1'/'0' into 0 or 1 int values (from AL to AL)
ctob:
        CMP AL, 0x30 ; '0'
        JE .zero
        MOV AL, 1
        RET
        .zero:
        XOR AL, AL
        RET

; interpreting function
        interp_lp:
                CALL ctob     ; convert to number
                CMP AL, CL    ; compare to current accumulator
                LODSB         ; read the next character of the string
                              ; this doesn't affect any flags and we need to do
                              ; it in both cases anyway
                JNE interpret ; if AL != CL (from above, not the new value of AL), skip forward
                CALL ctob     ; convert AL to number
                MOV CL, AL    ; store AL in CL
interpret:      LODSB         ; read the next character of the string
                TEST AL, AL   ; check if it is a zero byte
                JNZ interp_lp ; if not, jump back into the loop
        RET
— Fayti1703
स्रोत
1

सी (जीसीसी) , 45 41 बाइट्स

f(a,i)char*i;{a=*i?f(a^*i?a:i[1],i+2):a;}

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

4 बाइट्स मुंडा @ErikF की बदौलत!

— जी। स्लीपेन
स्रोत
1
आप पहले पैरामीटर में रिटर्न मान को संग्रहीत करने की सामान्य चाल का उपयोग करके 4 बाइट्स बचा सकते हैं: इसे ऑनलाइन आज़माएं!
— एरिक
0

क्रिस्टल , 46 बाइट्स

एक Array(Tuple(Int32,Int32))जैसे (जैसे) में कमांड के साथ [{0,0}, {0,1}, {0,0}]।

def f(s,i);i.map{|c,v|s+=~(s^c)&(s^v)%2};s;end

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

इसे और अधिक पठनीय रूप में समझना बहुत सरल है:

def f(state, instructions)
  instructions.map do |check, value|
    state += ~(state ^ check) & (state ^ value) % 2
  end
  state
end

फ़ंक्शन प्रत्येक कमांड के माध्यम से लूप करता है, स्वचालित रूप से ट्यूपल मानों को अनपैक कर रहा है cऔर v। यह तब stateसूत्र द्वारा सेट होता है

state = state + NOT(state XOR check) AND (state XOR value) mod 2

जो मैं ज्यादातर परीक्षण और त्रुटि के द्वारा पहुँचा। एक बार सभी कमांड संसाधित हो जाने के बाद, यह राज्य मान लौटाता है।

— Kinxer
स्रोत
0

सी (क्लैंग) , 68 62 बाइट्स

t(s,e,a)char*s,*e;{for(;s<e;++s)a=*s++-48^a?a:*s-48;puts(&a);}

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

स्रोत स्ट्रिंग की शुरुआत के लिए एक संकेतक लेता है, स्रोत स्ट्रिंग के अंत में एक सूचक (स्टार्ट + स्ट्रलेन (शुरू)), और प्रारंभिक संचयकर्ता मूल्य।

पुराना संस्करण (0/1 के लिए ASCII 48/49 प्रिंट करता है):

t(s,e,a)char*s,*e;{for(;s<e;++s)a=*s++-48^a?a:*s-48;putchar(a+48);}
— osuka_
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.