सिक्के का मेला बनाना

Question

आपके पास एक सिक्का है जो पैदा करता है 0या 1। लेकिन आपको संदेह है कि सिक्का पक्षपाती हो सकता है , जिसका अर्थ है कि 0(या 1) की संभावना 1/2 नहीं है।

वॉन न्यूमैन द्वारा प्रस्तावित के रूप में एक पक्षपाती सिक्के को एक निष्पक्ष सिक्के (यानी समान रूप से संभावित परिणाम प्राप्त करने के लिए) में बदलने के लिए एक अच्छी तरह से ज्ञात प्रक्रिया इस प्रकार है। जब तक किसी ब्लॉक के दो मान अलग-अलग नहीं होते तब तक दो सिक्कों के ब्लॉक का उत्पादन (गैर-अतिव्यापी) ब्लॉक करें; और उस ब्लॉक में पहला मूल्य आउटपुट (दूसरा मूल्य भी होगा, लेकिन इस चुनौती के प्रयोजनों के लिए हम पहले चुनते हैं)। Intuitively, की तुलना में अधिक संभावना हो सकती है , लेकिन और समान रूप से की संभावना होगी।100110

उदाहरण के लिए, इनपुट 1110...पहले ब्लॉक को छोड़ देगा, फिर 1दूसरे ब्लॉक से उत्पादन ...

यह प्रक्रिया महंगी है , क्योंकि एकल परिणाम उत्पन्न करने के लिए कई सिक्कों की खपत की जाती है।

चुनौती

शून्य और लोगों का एक परिमित अनुक्रम लें, मूल सिक्के के टॉस का प्रतिनिधित्व करते हैं, और उपरोक्त प्रक्रिया के अनुसार अधिकतम परिणाम उत्पन्न करते हैं , जब तक कि सभी इनपुट का उपभोग नहीं किया जाता है।

इनपुट मानों की संख्या विषम होने पर अंतिम ब्लॉक अधूरा हो सकता है। उदाहरण के लिए, इनपुट अनुक्रम 11111कोई परिणाम नहीं देगा (पहले दो ब्लॉकों में समान मूल्य हैं, और तीसरा ब्लॉक अपूर्ण है)।

नियम

इनपुट में किसी भी तरह की गैर-नकारात्मक संख्या हो सकती है, जरूरी नहीं कि सकारात्मक या सम्‍मिलित हो।

इनपुट प्रारूप हो सकता है:

• शून्य और लोगों की एक सरणी;
• शून्य का एक स्ट्रिंग और एक वैकल्पिक विभाजक के साथ वाले।

आउटपुट स्वरूप हो सकता है:

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

कोड गोल्फ। सबसे कम बाइट्स जीतता है।

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

इनपुट और आउटपुट को स्ट्रिंग्स माना जाता है।

Input         -->  Output

'1110'        -->  '1'
'11000110'    -->  '01'
'1100011'     -->  '0'
'00'          -->  ''
'1'           -->  ''
''            -->  ''
'1101001'     -->  '0'
'1011101010'  -->  '1111'

Comments

क्या प्रत्येक इनपुट के लिए दो संभावित आउटपुट नहीं होने चाहिए (अर्थात वर्तमान आउटपुट का बिटवाइज़ नहीं)?

— wizzwizz4

@ wizzwizz4 आप एक या दूसरे को ले सकते हैं, लेकिन दोनों को नहीं (क्योंकि तब वे सांख्यिकीय रूप से स्वतंत्र नहीं होंगे)। इस चुनौती में मैंने मनमाने ढंग से पहला चुना

— लुइस मेंडो

आपको सिक्के पर बहुत संदेह है। बस बात को पलटें;)

— भूतों को

@IGoBest मैं इतना निश्चित नहीं हूं :-D

— लुइस

@DonMuesli मैन, उस पेपर में कैविट्स की सूची प्रभावशाली है : पी

— जियोबिट्स

Answer 1

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

s2Q€Ṗ€

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

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

s2Q€Ṗ€  Main link. Argument: S (string)

s2      Split the string into pairs of characters.
  Q€    Deduplicate each pair.
        This removes the second character iff it is equal to the first.
    Ṗ€  Pop each; remove the last character of each pair/singleton.

Answer 2

रेटिना , 16 14 बाइट्स

(.)\1|(.)?.
$2

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

व्याख्या

यह काफी सरल है। कोड एक एकल रेगेक्स प्रतिस्थापन को परिभाषित करता है (.)\1|(.)?.जो दूसरे समूह के कब्जे वाले सभी (गैर-अतिव्यापी) मैचों की जगह लेता है । यह तीन अलग-अलग मामलों को एक में जोड़ता है:

(.)\1 --> <empty>

यदि दो दोहराया अंक समान हैं, तो हम उन्हें स्ट्रिंग से हटा देते हैं (क्योंकि समूह 2 अप्रयुक्त है)।

(.).  --> $2

अन्यथा, अगर हम दो वर्णों का मिलान कर सकते हैं, तो दूसरे को हटा दें, दोनों को पहले से बदलकर। यदि ऐसा नहीं है ?तो समूह को छोड़ दिया जाएगा:

.     --> <empty>

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

Comments

यह सबसे छोटा रेटिना उत्तर हो सकता है जो मैंने देखा है :-)

— लुइस मेंडो

@ डोनम्यूसली ओम्म् ...

— मार्टिन

Answer 3

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

"(. :
""*$,@

एक कॉम्पैक्ट भूलभुलैया कार्यक्रम का एक दुर्लभ उदाहरण जिसमें कोई नो-ऑप्स भी नहीं है। |पिछले संस्करण में पूरी तरह से अनावश्यक था, और यह बड़े पैमाने पर कार्यक्रम के आकार को कम हटाने। वास्तव में, लैब रेटिना की धड़कन है!

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

नीचे-बाएँ "भी एक स्थान हो सकता है, लेकिन वहाँ होने से स्पष्टीकरण बहुत सरल हो जाता है।

व्याख्या

यह एक छोटा सा पेचीदा मामला है, इसलिए यह छवियों के साथ है। लेकिन पहले, एक त्वरित प्राइमर:

• भूलभुलैया एक स्टैक-आधारित 2D भाषा है। मेमोरी में एक मुख्य स्टैक और एक सहायक स्टैक होता है।
• भूलभुलैया के ढेर नीच और शून्य से भरे होते हैं, इसलिए खाली स्टैक पर संचालन करना एक त्रुटि नहीं है।
• प्रत्येक जंक्शन पर, जहां जाने के लिए निर्देश सूचक के लिए दो या अधिक रास्ते हैं, मुख्य स्टैक के शीर्ष को यह पता लगाने के लिए जाँच की जाती है कि आगे कहाँ जाना है। नेगेटिव लेफ्ट है, जीरो स्ट्रेट फॉरवर्ड है और पॉजिटिव राइट है। यदि कोई मोड़ विफल हो जाता है, तो सूचक दूसरी दिशा में मुड़ने का प्रयास करता है।

सेट अप

कार्यक्रम शीर्ष-बाईं ओर से शुरू होता है ", जो एक नो-ऑप है। फिर हम प्रदर्शन करते हैं:

(        Decrement a bottom zero to -1. Since -1 is negative we try to turn 
         left at this junction, fail, and turn right instead.
"        No-op junction, turn left
*        Multiply top of stack (-1) with a 0 at bottom of stack, giving 0.
         This makes us go straight ahead at this junction.
$        Bitwise xor (of 0 and 0)

यह स्टैक को उस पर एक एकल 0 के साथ छोड़ देता है, जो लेबिरिंथ के उद्देश्यों के लिए उतना ही अच्छा है।

इनपुट और समाप्ति पढ़ना

,इनपुट से एक चार्ट पढ़ता है, 48 या 49 के लिए 0या 1क्रमशः लौट रहा है, और ईओएफ पर -1। चूंकि यह नॉनज़ेरो है, इसलिए या तो हम इसमें बदल जाते हैं :, जो स्टैक के शीर्ष को डुप्लिकेट करता है।

:, एक अंत में मृत्यु पर है तो हम बिलकुल पलट गया और निष्पादित ,एक बार फिर। अब यदि अंतिम इनपुट EOF था, तो हम बाएं मुड़ते हैं और समाप्त होते हैं @, अन्यथा हम दाएं मुड़ते हैं, जैसे स्टैक लग रहा है [a a b](जहां a, bदो वर्ण हैं)।

सिक्का टॉस की व्याख्या

यदि हमने समाप्त नहीं किया है, तो हमारा अगला कदम $फिर से (बिटवाइर एक्सोर) को निष्पादित करना है। यदि इनपुट वर्ण समान थे, तो यह 0 प्राप्त करता है, 1 अन्यथा। हम aइस परिणाम के साथ गुणा करते हैं, या तो 0 या दे रहे हैं a। चूंकि *एक जंक्शन पर है, यह शीर्ष स्टैक मान निर्धारित करता है कि आगे क्या होता है।

0 मामले में, हम सीधे आगे बढ़ते हैं और तीन "नो-ऑप्स निष्पादित करते हैं, इससे पहले कि वे एक (डिक्रीमेंट करें। सेटअप की तरह, यह हमें मोड़ देता है और निष्पादित करता है "*$, जिससे हमें अधिक चार्ट पढ़ने के लिए तैयार किया जाता है।

अन्यथा, aमामले में, हम जंक्शन पर सही मोड़ लेते हैं क्योंकि aसकारात्मक (48 या 49) है। .स्टैक को खाली छोड़ते हुए, चर को आउटपुट करता है, और स्टैक (के शीर्ष को घटाता है, 0 से -1 मोड़ता है। एक बार फिर, यह हमें बाएं मुड़ता है, "*$सेटअप की तरह निष्पादित करता है, साथ ही हमें अधिक इनपुट पढ़ने के लिए तैयार करता है।

Comments

...वाह। बस वाह। जिज्ञासा से बाहर ... यदि आप प्रत्येक पंक्ति से अग्रणी उद्धरण निकालते हैं तो क्या होता है?

— 16

@ETHproductions दूसरा कॉलम अब एक जंक्शन नहीं है, इसलिए IP (फिर से निष्पादित करना शुरू कर देता है ., आउटपुट 255 (-1 मॉडुलो 256)। तो यह पहले से ही वहां से शुरू होने में गलत है, दुर्भाग्य से: P

— Sp3000

Answer 4

सीजेएम, 10 8 बाइट्स

l2/{)-}%

इसका परीक्षण यहां करें।

व्याख्या

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

"0"  --> ""
"1"  --> ""
"00" --> ""
"01" --> "0"
"10" --> "1"
"11" --> ""

यह केवल वह अंक छोड़ता है जिसकी हम तलाश कर रहे हैं। यहां बताया गया है कि कोड इसकी गणना कैसे करता है:

l     e# Read input.
2/    e# Split into pairs. Odd inputs will yield a single-character string at the end.
{     e# Map this block over the pairs...
  )   e#   Pull the last character off the string.
  -   e#   Remove all occurrences of that character from the remainder (which is either
      e#   an empty string to begin with or a single-digit string).
}%

जब कार्यक्रम के अंत में सूची को ऑटो-प्रिंट किया जाता है, तो खाली तारों को छोड़ दिया जाता है।

Comments

आप और @DonMuesli केवल अपने कोड के अलावा अन्य उत्तरों में किसी भी स्पष्टीकरण वाले लोग हैं। धन्यवाद।

— R

Answer 5

पर्ल, 19 18 17 बाइट्स

@ मॉर्टिन ब्यूटनर रेटिना समाधान ने 2 बाइट हासिल करने के लिए प्रेरित किया

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

STDIN पर इनपुट के साथ चलाएं, जैसे perl -p fair.pl <<< 11000110

fair.pl:

s/(.)\1|.?\K.//g

यहाँ बहुत समझाने के लिए नहीं है क्योंकि यह विनिर्देश का एक (अप्रत्यक्ष) अनुवाद है:

• (.)\1 यदि पहले 2 अंक समान हैं, तो उन्हें छोड़ दें
• .\K. अन्यथा पहले दो अंक अलग हैं। रखना ( \K) पहले वाला
• .?\K.सिवाय इसके कि पहला .वैकल्पिक है। यह स्ट्रिंग के अंत में एक एकल मैच के लिए अनुमति देता है जो तब रखा गया हो जाता है क्योंकि रखे गए भाग खाली है

Answer 6

गणितज्ञ, ३६ ३ 36 बाइट्स

-2 तत्व की सूची का निर्धारण करने के लिए @ LegionMammal978 के कार्य को चुराने के बाद {0,1} {{}}

#&@@@Select[#~Partition~2,Tr@#==1&]&

तर्क पूर्णांक की एक सूची होने की उम्मीद है।

Comments

अरे नहीं, एक सवाल पर तीन गणितज्ञ जवाब देते हैं!

— कैलकुलेटर

Answer 7

हेक्सागोनी , 23 21 बाइट्स

,){,/;(_\/'%<\{)/>~$>

सामने आया:

    , ) { ,
   / ; ( _ \
  / ' % < \ {
 ) / > ~ $ > .
  . . . . . .
   . . . . .
    . . . .

यह एक त्रुटि के साथ समाप्त होता है, लेकिन त्रुटि संदेश STDERR को जाता है।

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

दर्पणों की संख्या को देखते हुए यह संभव है कि इसे साइड-लेंथ 3 में फिट किया जा सके लेकिन मुझे अब तक कोई भाग्य नहीं मिला है।

व्याख्या

यहाँ सामान्य आरेख है, जो टिमवी के हेक्सागोनीकॉलर के साथ उत्पन्न होता है :

कार्यक्रम केवल तीन स्मृति किनारों, लेबल का उपयोग करता है एक , बी , और सी यहाँ (Timwi के चित्र सौजन्य EsotericIDE ):

नीले रंग के रास्ते पर निष्पादन शुरू होता है। /सिर्फ दर्पण कि अनुदेश सूचक (आईपी) अनुप्रेषित कर रहे हैं, वास्तविक कोड है:

,   Read character from STDIN into memory edge A.
)   Increment.
{   Move to memory edge B.
,   Read character from STDIN into memory edge B.
)   Increment.
'   Move to memory edge C.
%   Compute A mod B in memory edge C.

,करने के लिए धार सेट हो जाएगा -1अगर हम EOF पर पहुंच जाते हैं चरित्र कोड के बजाय। चूंकि हम दोनों इनपुट बढ़ा रहे हैं, जो यह नहीं बदलते कि वे समान हैं या नहीं, लेकिन यह ईओएफ में बदल जाता है 0।

हम समानता के लिए जाँच करने के लिए मोडुलो का उपयोग करते हैं, क्योंकि यह असमान वर्णों के लिए 1या 49(सकारात्मक) 0समान वर्णों के लिए है। यह कार्यक्रम के अंत के रूप में भी कार्य करता है, क्योंकि जब हमारे पास 0ईओएफ से होता है, तो शून्य द्वारा प्रयास विभाजन एक त्रुटि का कारण होगा।

अब <सकारात्मक परिणामों से शून्य को अलग करता है। पहला सरल: यदि अक्षर समान हैं, तो IP लाल पथ लेती है। _एक दर्पण है, एक दर्पण \भी है , लेकिन इसे नजरअंदाज कर दिया जाता है, और >आईपी ​​को ऐसे विक्षेपित करता है कि यह किनारों के चारों ओर लपेटता है और फिर से ऊपर से शुरू होता है। हालांकि, इस पुनरावृत्ति पर, ए , बी और सी की भूमिका को चक्रीय रूप से स्वैप किया जाता है ( सी अब ए और इसी तरह की भूमिका लेता है )।

यदि वर्ण भिन्न हैं, तो इसके बजाय हरा पथ लिया जाता है। यह थोड़ा गड़बड़ है। यह पहले एक ऑप-ओप के साथ कूदता है $, फिर /बाएं किनारे पर चारों ओर घूमता है, फिर दूसरी-से-अंतिम पंक्ति को दाईं से बाईं ओर ट्रेस करता है और अंत में स्रोत कोड के दिलचस्प भाग में फिर से प्रवेश करता है {। कोड का एक अनिवार्य रूप से रैखिक बिट है, जिसे मैं एक दूसरे में समझाता हूं, इससे पहले $कि आईपी कूदता >है दो मार्गों को फिर से मर्ज करने के लिए।

यहाँ कोड का रैखिक टुकड़ा है:

{    Move to memory edge A.
(    Decrement to recover the actual character we read.
;    Print the character back to STDOUT.
'    Move to memory edge B.
~    Multiply the value there by -1, making it negative. This is
     necessary to ensure that the path correctly wraps back to the top.

ध्यान दें कि इस मामले में, अगले पुनरावृत्ति के लिए किनारों की भूमिका को भी चक्रीय रूप से स्वैप किया जाता है, लेकिन बी के साथ ए और इतने पर भूमिका लेते हैं ।

Answer 8

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

p(a:b:r)=[a|a/=b]++p r
p _=[]

निमि द्वारा चरम गोल्फ ।

Answer 9

> <> , 11 बाइट्स

i:i:0(?;-?o

> <> इस तरह पढ़ने-ए-चार-ए-समय चुनौतियों के लिए बहुत अच्छी तरह से अनुकूल है :) इसे ऑनलाइन आज़माएं!

i:            Read char and duplicate
i             Read char
:0(?;         Halt if last char was EOF
-             Subtract
?o            Output first char if the subtraction was non-zero (i.e. not equal)

यह सब एक लूप में होता है क्योंकि निर्देश सूचक एक पंक्ति के अंत तक पहुंचने के बाद चारों ओर लपेटता है।

Comments

-1 के लिए> <> कार्यक्रम जिसमें कोई >या<

— लुइस मेंडो

Answer 10

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

f=lambda L:L[1:]and L[:L[0]^L[1]]+f(L[2:])

पुनरावृत्ति और बिटवाइज़ एक्सोर के साथ मज़ा। इनपुट के रूप में 1s और 0s की सूची लेता है।

Answer 11

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

s=>s.filter((c,i)=>++i%2&c!=s[i])

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

s=>s                // Take the input array.
.filter((c,i)=>   ) // Filter to only the chars that are both:
++i%2&              //  on an even index, and
c!=s[i]             //  not equal to the one after them.

Comments

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

— मामा फन रोल

@MamaFunRoll टिप के लिए धन्यवाद!

— ETHproductions

Answer 12

प्रस्तावना , 12 बाइट्स

11(-(#!)?^?)

यह एक दुभाषिया मानता है जो पात्रों को पढ़ता है और छापता है। आप इसे ऑनलाइन आज़मा सकते हैं। लेकिन यह दुभाषिया पूर्णांक प्रिंट करता है, इसलिए प्रत्येक के लिए 0आपको मिलेगा 48और प्रत्येक के लिए 1आपको 49बदले में (और एक लाइनफ़ीड) मिलेगा ।

व्याख्या

यह बहुत दुर्लभ है कि आप Prelude में एकल पंक्ति पर एक गैर-तुच्छ कार्यक्रम लिख सकते हैं (क्योंकि Prelude को ट्यूरिंग-पूर्ण होने के लिए एक से अधिक पंक्ति की आवश्यकता है)।

11      Push two 1s. We need something non-zero on the stack to enter the loop, and by
        pushing the same value twice, we make sure that the loop doesn't print anything
        on the first iteration.
(       Main loop...
  -       Subtract the last two values. This will be zero for equal values, and non-zero
          otherwise...
  (       This "loop" is simply used as a conditional: if the last two values were
          were equal, skip the code inside...
    #       Discard the conditional.
    !       Print the value below.
  )       The loop is exited because the value below is always zero.
  ?       Read the first character of the next pair from STDIN.
  ^       Duplicate it, so the lower copy can be printed.
  ?       Read the second character of the pair. This returns 0 at EOF, which
          terminates the loop.
)

Answer 13

पर्ल, 27 21 बाइट्स

say grep$_-chop,/../g

बाइट को -nझंडे के लिए जोड़ा गया ।

                /../g  match groups of two chars
    grep       ,       select/filter on...
           chop        remove the last character, mutating the string
        $_-            is it different than the remaining char?
                         (subtract it, empty string is falsy)
say                    output if so

परीक्षा:

llama@llama:~$ perl -nE 'say grep$_-chop,/../g'
1110
1
11000110
01
1100011
0
00

1



1101001
0
1011101010
1111

6 बाइट्स के लिए @TonHharma को धन्यवाद !

Comments

आप परीक्षण को छोटा करके कुछ बाइट्स प्राप्त कर सकते हैं:say grep$_-chop,/../g

— टन हास्पेल

@TonHharma बहुत अच्छा, धन्यवाद!

— दरवाज़े

Answer 14

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

~:~:0`!#@_->#,_$

कॉम्पैक्टनेस के लिए एक-लाइनर। इस ऑनलाइन दुभाषिया का उपयोग करके परीक्षण किया गया ।

~:                     Read input char a and dup
  ~                    Read input char b (-1 on EOF)
   :0`!                Push 1 if b <= 0, 0 otherwise
       #@_             Halt if b <= 0 (i.e. EOF)
          -            Subtract to check whether a != b
           >#,_$       Output a if so

अंतिम भाग इस तथ्य का उपयोग करता है कि खाली बेफ़ुंज -93 स्टैक पैदावार 0 से पॉपिंग ।

यदि a != b, हम प्रदर्शन करते हैं

>                      Move rightward
#                      Bridge: skip next
_                      Horizontal if - go right if 0, else left. But a != b, so we go left
,                      Output a
#                      Bridge: skip next
-                      Subtract (0 - 0 = 0)
_                      If: go right since 0 is popped
>#                     Go right and skip next
_                      If: go right since 0 is popped
$                      Pop top of stack, stack is now empty

अन्यथा, यदि a == b, हम प्रदर्शन करते हैं:

>                      Move rightward
#                      Bridge: skip next
_                      If: go right since a == b (i.e. a-b is 0)
$                      Pop top of stack and discard, keeping stack empty

Answer 15

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

jkPM{Mcz2

डेनिस के जेली उत्तर से एल्गोरिथ्म बेशर्मी से चोरी हो गया ।

       z    input
      c 2   chunks of 2
    {M      dedup each chunk
  PM        all-but-last element of each chunk
jk          join on empty string; can't use `s' because that gives `0' for []

Answer 16

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

lambda n:[s for s,t in zip(*[iter(n)]*2)if s!=t]

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

डेनिस और वॉल्टह को धन्यवाद जो मैंने याद किया सामान को इंगित करने के लिए

Comments

मुझे लगता है कि आप zip(*[iter(n)]*2)

— vaultah

एक भेड़ का बच्चा काम नहीं करेगा?

— डेनिस

Answer 17

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

Select[#~Partition~2,Tr@#==1&][[1]]&

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

Answer 18

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

s=>s.replace(/(.)\1|(.)?./g,"$2")

रेटिना जवाब के बोरिंग पोर्ट।

Answer 19

sed, 34 33 बाइट्स

s/../& /g;s/00\|11//g;s/.\b\| //g

परीक्षा:

llama@llama:~$ sed 's/../& /g;s/00\|11//g;s/.\b\| //g'             
1110
1
11000110
01
1100011
0
00

1



1101001
0
1011101010
1111

Comments

मैंने fold(1)जोड़ियों में विभाजित करने के लिए कमांड का उपयोग करने की कोशिश की । वह भी ३४ पर बाहर आया! fold -s2|sed 's+01+0+p;s+10+1+p;d'

— joeytwiddle

@joeytwield fold -s2बराबर है fold -2, जो कि 33 बाइट्स बनाता है ... जो कि मैंने अभी-अभी शुद्ध सेड सॉल्यूशन को नीचे रखा है, वह भी। : पी

— दरवाज़े

मैंने दूसरे और तीसरे प्रतिस्थापन को एक और 4 बाइट्स शेव करने के लिए मिलाया:s/../& /g;s/00\|11\|.\b\| //g

— टोबी स्पाइट

Answer 20

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

Sp3000 के समाधान के रूप में छोटा और साफ नहीं है, लेकिन मैंने सोचा कि मैं इसे एक अलग दृष्टिकोण के रूप में पोस्ट करूंगा:

"" @
,, :{"
)  { $;
*"})";.
 ""

व्याख्या

पहला लूप बस है

""
,,

जो एक बार में दो वर्णों में पढ़ता है ( "कोई विकल्प नहीं हैं)। EOF के बाद, ,वापस आ जाएगी-1 , लेकिन हर दूसरे चरित्र में केवल ईओएफ की जांच करें। इसका मतलब है कि किसी भी मामले में स्टैक का शीर्ष तब होगा -1और नीचे का मूल्य -1या तो कुछ वर्ण कोड है, जिसकी हमें परवाह नहीं है, क्योंकि यह एक अनपेक्षित सिक्का टॉस है।

फिर और नीचे दिए गए मूल्य को एक एकल में )*बदल देता है, जिसे हमें अगले दो लूपों में सही तरीके से दर्ज करने के लिए उन दोनों मूल्यों और बी से छुटकारा पाने के लिए a) की आवश्यकता होती है। वह अगला लूप बस है-10

"}
""

जो सहायक स्टैक पर सभी मानों को स्थानांतरित करता है। यह आवश्यक है क्योंकि हम उन जोड़ियों का प्रसंस्करण शुरू करना चाहते हैं जो हम पहले पढ़ते हैं। अब अंतिम लूप:

:{"
{ $;
)";.

)सिर्फ वेतन वृद्धि कुछ डमी मूल्य सुनिश्चित करने के लिए है कि यह सकारात्मक है और अनुदेश सूचक बदल जाता है उत्तर। {अगले जोड़े के पहले अंक पर खींचता है और :इसे डुप्लिकेट करता है। अब जब हम प्रसंस्करण कर रहे हैं, यह 0सहायक स्टैक के नीचे से हुआ होगा। अन्यथा यह या तो है48 या49 । शून्य के मामले में, हम लूप से बाहर निकलते हैं और समाप्त करते हैं @, अन्यथा, आईपी पूर्व की ओर मुड़ जाता है।

{वर्तमान जोड़ी के दूसरे अंक को खींचता है। $उनके बीच XOR लेता है। यदि वह 0 है, यानी दोनों समान हैं, तो आईपी सिर्फ दक्षिण की ओर बढ़ता रहता ;है, शून्य को छोड़ देता है, और आईपी अगले प्रवाह में पश्चिम में बदल जाता है। यदि XOR था 1, यानी वे अलग-अलग थे, तो IP पश्चिम में बदल जाता है, के 1साथ डिस्क ;और पहले अंक को प्रिंट करता है .।

Answer 21

MATL , 11 9 8 बाइट्स

`-?6MD]T

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

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

`         % do...while loop
  -       %   take two inputs implicitly. Compute difference
  ?       %   if nonzero
    6M    %     push first of the two most recent inputs again
    D     %     display (and remove from stack)
  ]       %   end if
  T       %   true. Used as loop condition, so the loop is infinite
          % end loop implicitly

पुराना दृष्टिकोण, 11 बाइट्स

2YCd9L)Xz0<

इनपुट एक स्ट्रिंग है। आउटपुट को नई संख्या से अलग किया जाता है।

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

2YC      % implicitly take input as a string. Generate 2D array of length-2
         % overlapping blocks as columns, padding with a zero if needed.
d        % difference of the two values in each column of that array
9L       % predefined literal [1 2 0]. This corresponds to "1:2:end" indexing
)        % keep only values at indices 1, 3, 5, ... This reduces the set of blocks
         % to non-overlapping, and discards the last (padded) block if the input had
         % odd length
Xz       % keep only nonzero entries, corresponding to blocks that had different values
0<       % 1 if negative, 0 if possitive. Implicitly display

Answer 22

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

यह अलग l[0], l[1]और के l[2..{end}]रूप में a, bऔर c। तो इसके साथ एक स्ट्रिंग बनाता है a, तो a!=bया ''अन्यथा और f[c]अगर c[0]मौजूद है या ''अन्यथा।

f=->l{a,b,*c=l;"#{a!=b ?a:''}#{c[0]?f[c]:''}"}

Ungolfed:

def f(l)
  a = l[0]
  b = l[1]
  c = l[2..l.length]
  s = ''
  if a!=b
    s += a.to_s
  end
  if c[0]       # equivalent to !c.empty?
    s += f[c]   # no .to_s because the output will be a string
  end
  puts s
end

Answer 23

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

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

जावा की तुलना में, यह बहुत कॉम्पैक्ट है, हालांकि, मैं ब्रेनफक-गोल्फर उत्तरदाता से डरता हूं। और बग का उल्लेख करने के लिए स्वतंत्र महसूस करें। माना जाता है कि ईओएफ 0 है, इनपुट में अमान्य इनपुट नहीं है, सेल शुरू में शून्य है, और सेल वैल्यू रेंज परिमित और चक्रीय है। कोई अन्य धारणा मौजूद नहीं है।

स्पष्टीकरण:

मेमोरी सेल का नक्शा

+---------+---------+-----------------+
|1st input|2nd input|copy of 1st input|
+---------+---------+-----------------+

अनुदेश

,>,                               read two instruction at once | first to first cell |
                                  second to second cell
   [                              Until the input is EOF
    <                             look at first cell
     [->->+<<]                    move the first cell to additional cells while
                                  subtracting the second cell with this at same
                                  time
              >[                  if the second cell is nonzero (it means that first cell and
                                  the second cell is the same)
                [-]>.<            Print the copied first input
                      ]
                       >[-]       clear the first input to prevent it polluting next input
                           <<,>,  continue with next two input
                                ]

Comments

बहुत अच्छा! मैं अपने आप को एक बीएफ उत्तर लिखने की कोशिश कर रहा था। लेकिन मुझे यह बहुत अच्छा लगा

— लुइस मेन्डो

Answer 24

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

Cases[#~Partition~2,a_/;Tr@a==1:>a[[1]]]&

अनाम फ़ंक्शन जो इनपुट और आउटपुट ज़ीरो और लोगों की सूची देता है।

Comments

प्रतीक्षा करें, आप वेक्टर का योग करने के लिए Tr का उपयोग कर सकते हैं? जवाबों का एक गुच्छा संपादित करना होगा ...

— कैलक्यूलेटर 19

#&@@a1 बाइट से छोटा है a[[1]]।

— कैल्क्युलेटरलाइन

@CatsAreFluffy मैं उस के बारे में सोच रहा था, लेकिन इसके साथ टूट जाता है RuleDelayed।

— लेजियन मम्मल 978

मेरे जवाब के साथ या तो काम नहीं करता है Transpose:(

— कैलकुलेटर 19

Answer 25

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

hMf!qFTcz2

परीक्षण सूट

Comments

आप !qद्वारा nऔर फिर फ़िल्टर fnFTद्वारा प्रतिस्थापित कर सकते हैं nF#। ( hMnF#cz2, यह वह चीज थी जिसके बारे में मैंने सोचा था कि जब मैंने चुनौती को देखा था, लेकिन आपका यह मेरे लिए पर्याप्त है कि मैं इसे अलग से पोस्ट न

— करूं

@ Pietu1998 मैंने कोशिश की। यह विफल रहता है जैसे1

— isaacg

Answer 26

सी, 66 बाइट्स

main(char*p,char**x){for(p=x[1];*p&p[1];p+=2)write(1,p,*p^p[1]);}

यह मानते हुए sizeof(int) == sizeof(char *)

"चतुर" समाधान - 84 81 बाइट्स

main(int c,short**x){while(!((c=*x[1]++-12336)&~511))c>>8^c&1&&putchar(48|c&1);}

लिटिल-एंडियन मशीन पर काम करता shortहै 2 बाइट्स। इनपुट को तर्क के रूप में पारित किया जाता है। कार्यक्रम वर्णों और प्रिंटों के जोड़े पर 0x3130 के लिए और 1 के लिए 0x3031 पर प्रसारित करता है। बड़े endian पर परिणाम उलट दिया जाएगा (की जगह 48|c&1के साथ 49^c&1इसे ठीक करने के लिए)।

Answer 27

सी, 57 बाइट्स

f(char*p,char*r){for(;*p*p[1];)*r=*p++,r+=*r!=*p++;*r=0;}

हम pपरिणाम के लिए इनपुट से एक चरित्र को अस्थायी रूप से कॉपी करते हैं r, लेकिन केवल rपॉइंटर को आगे बढ़ाते हैं अगर यह अगले चरित्र से अलग हो। यदि नहीं, तो हम इसे अगले बेजोड़ जोड़ी पर, या NULअंत में लिख देंगे ।

परीक्षण कार्यक्रम:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char **argv) {
    while (*++argv) {
        char *result = malloc(1+strlen(*argv));
        f(*argv, result);
        printf("%s => %s\n", *argv, result);
        free(result);
    }
    return EXIT_SUCCESS;
}

परीक्षण उत्पादन:

$ ./74864 1110 11000110 1100011 00 1 "" 1101001 1011101010
1110 => 1
11000110 => 01
1100011 => 0
00 => 
1 => 
 => 
1101001 => 0
1011101010 => 1111

Answer 28

Befunge-93 , 40 बाइट्स

v  ,-1<
      | -<
>~1+:~1+:|
^     <  @

आप इसे यहाँ आज़मा सकते हैं । "शो" बटन के नीचे अंतरिक्ष में कोड पेस्ट करें, "शो" दबाएं, इनपुट परिभाषित करें, "रन" दबाएं। हमारा "कदम" बटन का उपयोग यह देखने के लिए करता है कि कार्यक्रम कैसे काम करता है।

Comments

मेरा पहला Befunge जवाब!

— लुइस मेन्डो

Answer 29

डॉस / विंडोज बैच, 201 162 बाइट्स

@echo off
set/pi=
:a
for /f "tokens=2" %%a in ("%i%") do goto l
exit/b
:l
for /f "tokens=1,2" %%a in ("%i:~0,4%") do if %%a neq %%b echo %%a
set "i=%i:~4%"
goto a

उदाहरण के लिए इनपुट एक जगह अलग स्ट्रिंग है 1 0 0 1 1। Cmd से प्रारंभ करें, अन्यथा स्क्रीन तुरंत बाहर निकल जाती है

Answer 30

मोम ,45 35 बाइट्स

मैं इसे 10 बाइट तक नीचे गिरा सकता था - बहुत बुरा नहीं था।

pgy~1z;L?gAF1<<?V_
>&?@yg&?~@ KQd{b

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

उदाहरण:

julia> beeswax("FairCoin.bswx")
s1110
1
Program finished!

julia> beeswax("FairCoin.bswx")
s11000110
01
Program finished!

julia> beeswax("FairCoin.bswx")
s1100011
0
Program finished!

julia> beeswax("FairCoin.bswx")
s00

Program finished!

julia> beeswax("FairCoin.bswx")
s10101001010111111100000010011001110100010110101110100001011
1110001010000111100
Program finished!

मेरा मधुमक्खीवाला गिटहब भंडार।

रोसेट्टा कोड पर मेरे मधुमक्खियों का उदाहरण।