175

गणित में एक विस्मयादिबोधक चिह्न का !अर्थ अक्सर फैक्टरियल होता है और यह तर्क के बाद आता है।

प्रोग्रामिंग में एक विस्मयादिबोधक चिह्न का !अर्थ अक्सर नकारात्मकता होता है और यह तर्क से पहले आता है।

इस चुनौती के लिए हम केवल इन कार्यों को शून्य और एक पर लागू करेंगे।

Factorial
0! = 1
1! = 1

Negation
!0 = 1
!1 = 0

शून्य या अधिक की एक स्ट्रिंग ले लो !की, जिसके बाद 0या 1, शून्य या अधिक के बाद !की ( /!*[01]!*/)।
उदाहरण के लिए, इनपुट हो सकता है !!!0!!!!या !!!1या !0!!या 0!या 1।

!'पहले रों 0या 1कर रहे हैं negations और !बाद s' factorials हैं।

फैक्टरियल की उपेक्षा से अधिक पूर्वता है इसलिए फैक्टरियल हमेशा पहले लागू होते हैं।
उदाहरण के लिए, !!!0!!!!वास्तव में इसका मतलब है !!!(0!!!!), या अभी तक बेहतर है !(!(!((((0!)!)!)!)))।

सभी भाज्य और निषेध के परिणामी अनुप्रयोग को आउटपुट करें। उत्पादन हमेशा रहेंगे 0या 1।

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

0 -> 0
1 -> 1
0! -> 1
1! -> 1
!0 -> 1
!1 -> 0
!0! -> 0
!1! -> 0
0!! -> 1
1!! -> 1
!!0 -> 0
!!1 -> 1
!0!! -> 0
!!!1 -> 0
!!!0!!!! -> 0
!!!1!!!! -> 0

बाइट्स में सबसे छोटा कोड जीतता है।

— केल्विन के शौक
स्रोत

18

लेकिन 0! = 1!, तो कई गुटों को संभालने की बात क्या है?

— 9

30

@boboquack क्योंकि यह चुनौती है।

— केल्विन के शौक

11

? <= '1'; ... php में 75% समय सही।

— aslum

10

मैं यहां गलत हो सकता हूं, लेकिन किसी भी संख्या के साथ किसी भी संख्या के साथ इसे हटाए जाने और इसे 1 के साथ बदलने के बाद कोई संख्या नहीं हो सकती है? जैसे 0 !!!! = 1 !! = 0 !!!!!!!! = 1 !!! = 1! = 0! = 1 आदि

— अल्बर्ट रेनशॉ

2

@AlbertRenshaw यह सही है।

— केल्विन के शौक

43

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

Input[]/.!x_:>1-x

उपयोगकर्ता प्रॉम्प्ट से इनपुट लेता है। अंतर्निहित मुद्रण के लिए गणित का नोटबुक वातावरण ग्रहण करता है। इसे एक कमांड-लाइन स्क्रिप्ट Print[...]बनाने के लिए, इसे एक तर्कहीन फ़ंक्शन बनाने के लिए या इसमें लपेटें (जो तब प्रॉम्प्ट से इनपुट लेता है), संलग्न करें &।

गणितज्ञ के पास आवश्यक संचालकों (आवश्यक पूर्ववर्तीता के साथ) दोनों हैं, इसलिए हम इनपुट को केवल "eval" कर सकते हैं (जो स्वचालित रूप से किया जाता है Input[]), लेकिन तार्किक निषेध ऑपरेटर पूर्णांक पर काम नहीं करता है (इसलिए यह अविकसित रहेगा)। यदि !xपरिणाम में कोई लेफ्ट है, तो हम इसे बदल देते हैं 1-x।

मूल्यांकन के बारे में कुछ मजेदार तथ्य:

मैथेमेटिका में वास्तव में डबल फैक्टरियल ऑपरेटर भी होता है !!, जो गणना करता है n*(n-2)*(n-4)*..., लेकिन इसे लागू किया जाता है 0या 1यह अभी भी देता है 1, इसलिए यह कोई फर्क नहीं पड़ता कि 0!!!!!वास्तव में पार्स किया जाएगा ((0!!)!!)!।
भले ही मैथेमैटिका निकलता है !0और !1अविकसित होता है, यह जानता है कि !यह स्व-विलोम है, इसलिए यह स्वचालित रूप से सभी जोड़े को रद्द कर देगा !। बाद ToExpressionहम कर रहे हैं हमेशा से एक के साथ छोड़ दिया 0, 1, !0, !1।

— मार्टिन एंडर
स्रोत

3

कब से एक REPL स्निपेट को डिफ़ॉल्ट रूप से अनुमति दी गई थी?

— लेजिओनमल 978

2

@ LegionMammal978 जाहिर तौर पर दिसंबर 2015 से, लेकिन मैं इसके बारे में भूलता रहता हूं। निष्पक्ष होने के लिए, यह "स्निपेट" नहीं है कि यह नहीं मानता है कि इनपुट पहले से ही मेमोरी में कहीं संग्रहीत है। और नोटबुक वातावरण को मान लेना तो निहित उत्पादन वाली भाषा से बहुत अलग नहीं है।

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

बस उत्सुक, एक मेटा लिंक प्रदान किया जा सकता है? (जानकारी को खोजने की कोशिश करना तनावपूर्ण है, फिर भी एसई क्यू एंड ए प्रारूप की एक और समस्या ...)

— लीजनमैमल 978

@ LegionMammal978 यह पहले से ही जवाब में है।

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

शुद्ध ksh समाधान x=${x/[01]!*/1};echo $(($x))- एक उचित उत्तर पोस्ट करने की अनुमति नहीं है :(

— DarkHeart

28

[बैश] + यूनिक्स उपयोगिताओं, 21 17 बाइट्स

sed s/.!!*$/1/|bc

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

टेस्ट केस चलता है:

for x in 0 1 '0!' '1!' '!0' '!1' '!0!' '!1!' '0!!' '1!!' '!!0' '!!1' '!0!!' '!!!1' '!!!0!!!!' '!!!1!!!!'; do ./excl <<<"$x"; done

0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0

— मिशेल स्पेक्टर
स्रोत

पुराने संस्करण काम करता है, यह एक नहीं है

— गायों

मैंने TIO लिंक का इस्तेमाल किया

— गायों ने

जब मैंने इसे अपने लिनक्स बॉक्स पर आज़माया तो @KritiiLithos ने काम किया। समस्या स्पष्ट रूप से थी कि TIO को सिम्युलेटेड इनपुट लाइन के अंत में एक नई लाइन की आवश्यकता है। यह एक भ्रामक स्थिति है, इसलिए मैंने TIO लिंक निकाला। यदि आप इसे वहां आज़माना चाहते हैं, तो यहां फिर से लिंक है (लेकिन इनपुट के अंत में एक नई पंक्ति

— मिशेल स्पेक्टर

2

लेकिन अगर कोई भाग गया है तो क्या होगा mkdir -p 's/.!!'{bunch,of,different,directories}\$/1? फिर आपको पाथनाम एक्सपेंशन मिलेगा और सेड निर्देशिकाओं को पढ़ने का प्रयास करेगा, जैसे कि वे फाइल थे, मानक इनपुट पढ़ने के बजाय, और यह कुछ भी आउटपुट करेगा! :)

— वाइल्डकार्ड

1

@Wildcard मैं पूरी तरह से सहमत हूं। उत्पादन स्क्रिप्ट में, मैं हमेशा इस तरह की स्थितियों में उद्धरण का उपयोग करता हूं। (इस मामले में, मैं वास्तव में केवल भागने की बजाय, sed के तर्क के आसपास डबल-कोट्स डालूंगा। यह बैकस्लैश का उपयोग करने की तुलना में पढ़ना आसान है, और यह कुछ विशेष चरित्र को याद करने की संभावना से बचता है।)

— मिशेल स्पेक्टर

22

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

1 बाइट बचाने के लिए लियो को धन्यवाद।

0!
1
!!

^1|!0

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

व्याख्या

0!
1

बारी 0!में 1। हम किसी अन्य अनुगामी !एस के बारे में परवाह नहीं करते हैं , परिणामी संख्या वैसी ही है जैसे कि हमने सभी वास्तविकताओं को लागू किया था।

!!

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

^1|!0

इस रेगेक्स के मैचों की संख्या की गणना करें, जो 1या तो है या 0वांछित परिणाम देता है।

— मार्टिन एंडर
स्रोत

एक ही बायटेकाउंट के लिए वैकल्पिक समाधान: \d.+...

— गाय

@KritiiLithos को पूरी तरह से बचने का एक तरीका मिला।

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

आप ^इससे पहले!0

— सिंह

17

ग्रिम , 14 12 9 बाइट्स

e`\0!~\!_

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

व्याख्या

यह एक पैटर्न के खिलाफ इनपुट से मेल खाता है, मैच के 1लिए मुद्रण और 0बिना किसी मैच के।

e`\0!~\!_
e`         Match entire input against this pattern:
    !      not
  \0       a sole 0
     ~     xor
      \!   exclamation mark
        _  followed by this pattern matched recursively.

विचार यह है। यदि इनपुट एक अंक से शुरू होता है, तो पुनरावर्ती भाग \!_हमेशा विफल रहता है, और \0!सफल होता है जब तक कि हमारे पास एक भी न हो 0। उनका xor तब तक सफल होता है जब तक कि इनपुट सिंगल न हो 0। यदि इनपुट ए के साथ शुरू होता है !, तो \0!हमेशा सफल होता है, और \!_पुनरावर्ती मैच सफल होने पर सफल होता है। उनका एक्सोर ठीक उसी समय सफल होता है जब पुनरावर्ती मैच विफल हो जाता है, इस प्रकार यह नकारात्मक हो जाता है।

— Zgarb
स्रोत

16

ब्रेनफक, 85 72 (84) बाइट्स

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

संख्यात्मक रूप से लौटने के लिए, या

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

ASCII पाठ के लिए। > मेमोरी रैपिंग से बचने के लिए उपसर्ग भी किया जा सकता है।

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

Loops over the input.
On 1, ends.
On "!", toggles bool a stored as 0 or 255.
On "0", toggles if there is no trailing bit, then ends.

Memory labels  | BOOL | INPUT | FLAG |

,                   first input 
[                     # loop on INPUT
  >-[-----<->]<++     subtract 49 == "1"

  [                     # case not "1"
    >++++[-<++++>]      add 16 since 49 take 16 == "!"

    +                   set FLAG
    <                   move to INPUT
    [                     # case "0"
      [+],                clear and new INPUT
      [                     # case "0!"
        [-]>-<              clear INPUT and FLAG
      ]
    ]
  ]

  >                   move to FLAG
  [                     # case "!" or "0" without tail
    <<+[-->]>[<]        not the BOOL
    ,                   take new input
    >-                  clear FLAG
  ]
  <                   move to INPUT
]

+.                    return 0 or 1

या पाठ प्रतिक्रिया के लिए, अंतिम पंक्ति को बदलें

-[-----<+>]<--.       add 49 for "0" or "1" conversion and return

— रूपर्ट टॉम्ब्स
स्रोत

14

Brainfuck - कई बाइट्स का रास्ता (232 बाइट्स)

स्पष्ट रूप से कोड गोल्फ में जीतने के लिए गलत भाषा। मुख्य रूप से मैंने इस एसोलैंग का उपयोग करते हुए किसी की कमी देखी। एक अच्छा ऑनलाइन दुभाषिया bf इंटरपेटर है या आप वास्तव में देख सकते हैं कि इस bf विज़ुअलाइज़र का उपयोग करके प्रोग्राम क्या करता है ।

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

— CodyCode
स्रोत

3

तुम पागल आदमी !!

— आलमो

इसे प्यार करो, क्या आप ऐसा कर सकते हैं? XD

— स्टीफन नोल्ड

जानकारी: नीचे बहुत कम समाधान हैं।

— user202729

14

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

बच गए 2 बाइट्स जर्ब के लिए धन्यवाद!

lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2

क्रमशः:

x[-1]!='0'
अगर xसाथ समाप्त होता है 1या !⇔ xसाथ अंत नहीं है 0, भाज्य भाग मान होना चाहिए 1, और0
^len(x.rstrip('!'))%2
एक "सशर्त नहीं" के रूप में एक्सोर की संपत्ति का शोषण करें। इस मामले में स्थिति यह है कि यदि प्रारंभिक !एस की लंबाई विषम है। हालाँकि, .rstripसंख्या को स्ट्रिंग से हटाया नहीं जाता है, इसलिए गणना की गई लंबाई 1 से ऑफसेट है, इसलिए स्थिति उलटी है
चरण 2 में 1 की भरपाई बदलकर सही है !=करने के लिए ==चरण 1 में Zgarb एक फर्क तुलना ऑपरेटर का उपयोग करने के बजाय एक और उलट लागू करने, 2 बाइट्स बचत का सुझाव दिया।

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

— busukxuan
स्रोत

के इनपुट पर विफल रहता है !!0; यह वर्तमान में लौट रहा है 1।

— मूल्य इंक

@ValueInk पर अभी काम होना चाहिए

— Busukxuan

1

lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2 अतिरिक्त उलट से बचा जाता है।

— जर्बद

15

पार किया गया 44 अभी भी नियमित 44 है

— Rɪᴋᴇʀ

3

मुझे लगता है कि वह कह रहा है कि इस्तेमाल किए गए फ़ॉन्ट में एक पार किया हुआ 44 पार नहीं दिखता है ... :) 4 जी के क्षैतिज भाग के साथ क्रॉस आउट भाग ओवरलैप हो जाता है।

— जेफ़सी

13

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

s=>+eval(s.replace(/.!+$/,1))

गैर-रेगेक्स विधि ( 41 31 बाइट्स)

नीचे मेरा प्रारंभिक दृष्टिकोण है। यह थोड़ा और दिलचस्प है, लेकिन नील (10 बाइट्स सहेजे गए) द्वारा महत्वपूर्ण अनुकूलन के बाद भी ~~काफी लंबा है~~ ।

f=([c,...s])=>1/c?c|s>'':1-f(s)

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

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

let f =

s=>+eval(s.replace(/.!+$/,1))

;[
  "0", "1", "0!", "1!", "!0", "!1", "!0!", "!1!", "0!!",
  "1!!", "!!0", "!!1", "!0!!", "!!!1", "!!!0!!!!", "!!!1!!!!"
].map(
  s => console.log(s, '=>', f(s))
)

स्निपेट का विस्तार करें

— Arnauld
स्रोत

मैं आपके गैर-रेगेक्स विधि से केवल 10 बाइट बचा सकता हूं, इसलिए यह अभी भी बहुत लंबा है f=([c,...s])=>1/c?c|s>'':1-f(s):।

— नील

@ नील, चूंकि यह मेरे पहले प्रयास से कहीं बेहतर है, इसलिए मैंने आपके सुझाव को शामिल करने के लिए स्वतंत्रता ली।

— अरनौलद

हा, मेरा भी यही विचार था लेकिन आपने इसे बेहतर तरीके से पूरा किया। :)

— देवसन

11

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

VeMḂ$

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

मोनाडिक फ़ंक्शन एक स्ट्रिंग की उम्मीद करता है। प्रमुख !s के साथ इनपुट के कारण 1STDOUT को मुद्रित किया जा सकता है, इसलिए TIO लिंक जो मैं देता हूं वह एक परीक्षण दोहन है जो इनपुट-आउटपुट जोड़े को आउटपुट की पहली पंक्ति के नीचे प्रिंट करता है।

कैसे?

VeMḂ$ - Monadic link: string
V     - eval the string
          - the implicit input of 0 causes !...! to evaluate to 1 (which gets printed),
          - the result is the evaluation of the rest: "0"=0; "0!"=1; "1"=1; "1!"=1; ...
 e    - exists in?
    $ - last two links as a monad:
  M   -     Maximal indexes - the "0" and "1" characters are greater than "!",
                            - so this results in a list of one item [i] where
                            - i is the 1-based index of the 0 or 1 character.
   Ḃ  -     %2 (vectorises) - [i%2], so a 0 if we need to logically negate and a 1 if not
                            - hence we check equality with e rather than inequality.

— जोनाथन एलन
स्रोत

10

05AB1E , 9 बाइट्स

कोड:

.V¹'!ÜgG_

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें!

स्पष्टीकरण:

.V         # Evaluate the input as 05AB1E code. This computes the factorial part.
   '!Ü     # Remove trailing exclamation marks..
  ¹        # ..from the first input
      g    # Get the length of the resulting string
       G   # Do the following length - 1 times:
        _  #   Negate the number

— अदनान
स्रोत

10

रेटिना , 13 बाइट्स

कुछ अजीब दृष्टिकोण, लेकिन यह छोटा है और यह काम करता है।

0$
!1
!!

^\d

पहले दो लाइनों के साथ हम एक न खत्म होने वाली की जगह 0के साथ!1 : इस प्रतिस्थापन के साथ अब हम जानते हैं कि अंकों से हमारे स्ट्रिंग के भाग के बाद 1 के बराबर है।

अगली दो पंक्तियाँ, के जोड़े निकालें ! : डबल नकार खुद को मिटा देता है, और हम पहले से ही पिछले चरण के साथ फैक्टरियल के लिए जिम्मेदार हैं।

अंतिम पंक्ति, स्ट्रिंग की शुरुआत में एक अंक का मिलान करें और मैचों की संख्या लौटाएं: यदि सभी को समाप्त कर दिया गया है तो हमें एक मैच मिलेगा (और जैसा कि हमने पहले कहा था कि हमें पता है कि यह 1 के बराबर है), अगर अभी भी है यह मेल नहीं खाता।

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

— सिंह
स्रोत

1

क्या अंतिम अंक हमेशा एक 1 नहीं होगा? उस स्थिति में, आप इसके 1बजाय उपयोग कर सकते हैं \d।

1

@ ais523 नहीं, क्योंकि पहला भाग केवल एक अंत 0 को प्रतिस्थापित करेगा, इसलिए उदाहरण के लिए इनपुट 0!अंतिम पंक्ति तक अपरिवर्तित रहेगा

— लियो

1

वास्तव में सुंदर समाधान, अच्छा काम! :)

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

10

रूबी, 12 + 1 = 39 24 15 13 बाइट्स

-nझंडे का उपयोग करता है । @ बाइट्स -9 बाइट्स के लिए धन्यवाद !

p~/!*$|0$/%2

— मूल्य स्याही
स्रोत

चूंकि आप केवल लंबाई की जाँच करते हैं, आप जाँच शून्य को हटा सकते हैं, बजाय जाँच! "0" पहले और उसके बाद एक एकल शून्य।

— जीबी

@ जीबी यह एक अद्भुत विचार है! हालाँकि, मुझे एक समाधान मिला, जो मेरे regex को संशोधित करने 0 या लाइन की स्थिति को देखने के लिए छोटा है

— मूल्य इंक

तब आप केवल अनुगामी जाँच कर सकते थे '!' या शून्य या पंक्ति का अंत: p ~ /! + $ | 0 $ | $ /% 2 सिर्फ 14 बाइट्स है।

— GB

और फिर "0 $ | $" एक और बाइट को बचाने के लिए "0! $" बन सकता है।

— जीबी

1

बेहतर अभी तक !*$दो से छोटा है!

— वैल्यू इंक

9

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

कोड + -pध्वज के 19 बाइट्स ।

s/\d!+/1/;$_=0+eval

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

पर्ल का नकारात्मक रिटर्न undefया 1, इसलिए मैं 0+परिणाम 0+undefरिटर्न का आंकलन करने के लिए उपयोग करता हूं 0। इसके अलावा, कोड के बारे में कहने के लिए बहुत कुछ नहीं।

— बापू
स्रोत

2

बस यही लिखा है। एक +1 है।

— प्रिमो

@primo खुशी है कि एक बार देखने के लिए मैं तुम्हारे पीछे 20 बाइट्स नहीं हूँ! धन्यवाद :)

— दादा

9

सी, 68 62 61 53 बाइट्स

c;e(char*a){for(c=1;*a<34;a++)c^=1;c=a[1]?c:*a&1^!c;}

कुछ दुरुपयोग के साथ कुछ और बाइट्स निचोड़

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

— Ahemone
स्रोत

1

मुझे लगता है कि आप निकाल सकते हैं intसमारोह से और आप बदल सकते हैं *a==33करने के लिए *a<34।

— गायों ने

काश *a%2की तुलना में कम है*a-48

— गाय

पारितोषिक के लिए धन्यवाद। मैं वापसी के आसपास ब्रैकेट्स को हटाकर और इसे असाइन करके एक अन्य चरित्र को भी समाप्त करने में सक्षम था।

— अहमोन

मुझे पूरा यकीन है कि 1 बाइट बचाने के for(;*a<34;a++)लिए छोटा किया जा सकता हैfor(;*a++<34;)

— अल्बर्ट रेनशॉ

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

— अहम

6

पर्ल 6 , 32 28 23 बाइट्स

{m/(\!)*(1|0.)*/.sum%2}

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

{                     }  # A lambda.
{m/            /      }  # Match the lambda argument against the regex:
   (\!)*                 #   Zero or more `!`.
                         #     (First capture will be an array with one element per negation).
        (1|0.)*          #   A `1`, or a `0` and another character, zero or more times.
                         #     (Second capture will be a one-element array if the factorial
                         #     part evaluates to 1, and an empty array otherwise.)
                .sum     # Add the lengths of the two captures,
                    %2   # and return that sum modulo 2.

— SMLS
स्रोत

6

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

f('!':b)="10"!!read[f b]
f[a]=a
f _='1'

एक फ़ंक्शन को परिभाषित करता है f, जो एक स्ट्रिंग लेता है और एक चरित्र देता है। इसे ऑनलाइन आज़माएं!

व्याख्या

तीन मामले हैं: इनपुट के साथ शुरू होता है !, इनपुट की लंबाई 1 है, और बाकी सब कुछ।

f('!':b)=    -- If input has head '!' and tail b,
 "10"!!      -- we index into the string "10"
  read[f b]  -- using f b converted to int. This essentially inverts f b.
f[a]=        -- If input has only one character, we know it's a digit,
 a           -- so we can just return it.
f _=         -- In all other cases, we know the input is a digit followed by !s,
 '1'         -- so we can return '1'.

— Zgarb
स्रोत

वापसी प्रकार के रूप में स्ट्रिंग से इंटेगर में स्विच करें f('!':b)=[1,0]!!f b;f"0"=0;f _=1:।

— निमि

6

Befunge, 24 बाइट्स

~"!"-:#v_$1+
*+2%!.@>0~`

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

यह !स्टड से पढ़े गए पात्रों की संख्या की गिनती से शुरू होता है । पहले चरित्र है कि नहीं है एक !या तो एक हो 0या 1, लेकिन के लिए परीक्षण की प्रक्रिया में! हम 33 घटाया गया होगा, जिससे यह या तो 15 या 16 हम तो एक और चरित्र को पढ़ने, कि या तो एक हो जाएगा !या EOF, और तुलना करें यदि यह 0 (यानी ईओएफ) से कम है।

उन तीन डेटा बिंदुओं को लेना - विस्मयादिबोधक गणना ( c ), अंक मान, ( d ), और फ़ाइल की स्थिति ( e ) - हम परिणाम की गणना इस प्रकार कर सकते हैं:

!((c + d*e) % 2)

डिजिट मान को एंड-ऑफ-द-फाइल स्थिति से गुणा करना इसका मतलब यह है कि यदि अंकों का अनुसरण किया गया है तो इसे शून्य में बदल दिया जाएगा !, इस प्रकार इसे एक ही मोडुलो 2 मान के रूप में दिया जाता है 1(जो याद रखें कि 16 में परिवर्तित हो गया है)। लेकिन modulo 2 को लागू करने से पहले, हम प्रारंभिक विस्मयादिबोधक गणना जोड़ते हैं, जो modulo 2 को प्रभावी रूप से टॉगल करता है क्योंकि कई बार उनके !उपसर्ग थे । और आखिरकार हम अपने आधारभूत मूल्यों के लिए परिणाम नहीं देते हैं 0और 1हम इसकी आवश्यकता के विपरीत हैं।

कोड को और अधिक विस्तार से देखना:

~                Read a character from stdin.
 "!"-            Subtract 33 (ASCII for '!').
     :  _        Make a duplicate and check if zero (i.e. is it a '!').
         $1+     If so, drop the duplicate, increment a counter, and repeat.
       v         Otherwise move to the second line, leaving the digit value on the stack.
       >0~`      Read one more character and check if less than 0 (i.e. EOF).
*                Multiple by the digit value, making it zero if not followed by EOF.
 +               Add to the exclamation count.
  2%             Modulo 2 the result.
    !            Then not that value.
     .@          And finally write to stdout and exit.

— जेम्स होल्डरनेस
स्रोत

6

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

f('!':b)=1-f b
f"0"=0
f _=1

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

प्रत्येक अग्रणी !बाकी अभिव्यक्ति के लिए आउटपुट को पूरक करता है, जैसा कि किया जाता है 1-। हम तब तक झूमते रहते हैं जब तक कि हम एक अंक नहीं मार देते। यदि शेष बस है "0", तो परिणाम 0. है। अन्यथा, यह एक है 1या एक या एक से अधिक है !, तो परिणाम 1 है।

— XNOR
स्रोत

5

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

->s{(s=~/!*$|0$/)%2}

स्पष्टीकरण:

पहला मामला, मुझे कुछ मिला! ' अंत में, उन्हें हटा दें, लंबाई modulo 2 प्राप्त करें।
दूसरा मामला, नहीं '!', यदि अंतिम वर्ण शून्य है तो उसे हटा दें, लंबाई modulo 2 प्राप्त करें
यदि अंतिम वर्ण 1 है, तो पहले मामले में वापस

(-1 बाइट चोरी @Value इंक के विचार)

— जीबी
स्रोत

बहुत बढ़िया, मैंने इस पहेली को 10 मिनट तक देखा, लेकिन ज्यादा समय नहीं हुआ और फिर इसके बारे में भूल गया। अब इसे फिर से सक्रिय प्रश्नों में देखा गया और इस तरह के अच्छे दृष्टिकोण को देखकर खुशी हुई।

— akostadinov

4

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

œr”!LḂ=V

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

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

व्याख्या

œr”!LḂ=V
œr”!      Take {the input}, with all trailing ! deleted
    L     Take the length of this
     Ḃ    Take the parity of that length
      =   Return 0 if unequal, 1 if equal to:
       V    the value of {the input} when eval'ed as a niladic Jelly program

सबसे पहले, ध्यान दें कि इनपुट में हमेशा कुछ संख्या होती है !, उसके बाद एक अंक, इसके बाद और अधिक !, ताकि यदि हम अनुगामी को हटा दें !और लंबाई ले लें, तो हम एक प्लस के साथ !कार्यक्रम में अग्रणी संख्या को समाप्त करेंगे । इसकी समता लेने पर 0 वापस आ जाएगी यदि विषम संख्या में थे !, या 1 यदि सम संख्या थी !। 0 की तुलना एक "नहीं" फ़ंक्शन है, जबकि 1 की तुलना पहचान समारोह है; इस प्रकार œr”!LḂ=प्रभावी !रूप से "संचालकों के रूप में अग्रणी व्यवहार करें" सवाल का हिस्सा है।

दूसरे हाफ के लिए, फैलीटोरियल को संभालना, !जेली में एक फैक्टोरियल ऑपरेशन है, इसलिए यदि प्रोग्राम में कोई अग्रणी नहीं है !, तो हम सीधे एक सरल eval( V) के साथ समस्या को हल कर सकते हैं । यदि कार्यक्रम में अग्रणी होता है !, तो उन्हें 0 के भाज्य (संभवतः कई बार) लेने के रूप में व्याख्या की जाएगी, 1 का वापसी मूल्य का उत्पादन, जो मानक आउटपुट पर मुद्रित किया जाएगा और एक अंक देखने के बाद छोड़ दिया जाएगा; इस प्रकार, उनके पास उस फ़ंक्शन के रिटर्न मूल्य पर कोई प्रभाव नहीं पड़ता है जो मेरे प्रश्न के लिए प्रस्तुत है।

बहुत अच्छी और बढ़िया व्याख्या।

— एलपेड्रो

4

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

lambda s:(s[1::2]>s[::2])^ord(s[-1])%2

TryItOnline!

एक अनाम फ़ंक्शन एक इनपुट स्ट्रिंग ले रहा है sऔर एक पूर्णांक 0या वापस कर रहा है 1।

s[1::2] इनपुट स्ट्रिंग का एक स्लाइस है जो इंडेक्स 1 पर शुरू होता है और इसका स्टेप साइज दो होता है:
'Like this' -> 'ieti'

s[::2] समान है लेकिन 0 के डिफ़ॉल्ट सूचकांक पर शुरू होता है:
'Like this' -> 'Lk hs'

परीक्षण (s[1::2]>s[::2])जांच करता है कि 0 आधारित सूचकांक '0'या '1'अजीब है, यानी अगर हम पूरक की जरूरत है।
यह काम करता है क्योंकि स्ट्रिंग्स के ऑर्डर को खाली स्ट्रिंग की तुलना में किसी भी गैर-खाली स्ट्रिंग के साथ और एएससीआईआई के आदेश के साथ शाब्दिक रूप से जांचा जाता है, इसलिए '1'>'0'>'!'। यह सरल से बाइट कम है s.index(max(s))%2।

यह ord(s[-1])%2देखने के लिए कि क्या अंतिम वर्ण '0'(मान्य इनपुट के लिए) नहीं है, और एक पूर्णांक में परिणाम होता है (जबकि एक ही लंबाई (s[-1]!='0')एक बूलियन लौटाएगा)।
यह काम करता है क्योंकि इनपुट का अंतिम वर्ण, s[-1]एक होगा '0','1' या '!'जो ASCII कोड क्रमश: 48, 49, और 33 अंक है, जो 0, 1, और 1 सापेक्ष 2 हैं।

इसके ^बाद ऊपर दिए गए दो मानों पर एक बिटवाइज़ एक्सक्लूसिव या ऑपरेशन करता है, एक इनपुट के बाद एक पूर्णांक लौटाता है, दाईं ओर एक पूर्णांक होता है। यदि बायां सत्य है तो दायें का पूरक लौटाया जाता है, यदि बायीं ओर गलत है तो दायां लौटाया जाता है, आवश्यकतानुसार।

— जोनाथन एलन
स्रोत

4

जावा 7, 105 82 81 बाइट्स

int a(char[]a){int b=0,c=0;for(;a[b++]<34;c^=1);return(b<a.length?1:a[b-1]&1)^c;}

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

पुराना रेगेक्स-ईश समाधान

int a(String a){a=a.replace("0!","1").replaceAll("1.*","1");int b=a.length()-1;return b%2^a.charAt(b)&1;}

— प्रहार
स्रोत

2

c^=1सुपर चालाक है। अगर मैंने कभी देखा है तो यह एक अप्रयुक्त ऑपरेटर है।

— Addison Crump

3

सीजेएम , 12 11 बाइट्स

r_W='0=!\~;

इसे ऑनलाइन आज़माएं! टेस्ट सूट ( 1प्रत्येक सही परीक्षण मामले के लिए प्रिंट )।

r      e# Read input.
_W='0= e# Duplicate and check whether the string ends in '0'. This is the
       e# only case in which the factorial part results in 0.
!      e# Negate this to get the actual result of the factorial part.
\      e# Swap with the input.
~      e# Evalute the input as CJam code. The leading `!` will apply the logical
       e# negations to the factorial result. The 0 or 1 will then push a junk value
       e# which is potentially negated a few times as well, by the factorials.
;      e# Discard the junk value.

— मार्टिन एंडर
स्रोत

3

हास्केल , 67 65 बाइट्स

f s|foldr(\_->not)(last s`elem`"1!")$fst.span(<'0')$s="1"|1<3="0"

इसे ऑनलाइन आज़माएं!उपयोग:f "!!!0!!!!"

@Nimi की बदौलत दो बाइट्स बचाए।

— Laikoni
स्रोत

3

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

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

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

Ungolfed:

% 0: inverter count
% 1: result
% 2: if/else flag; tmpspace in inner loop 0

>1,[
    ->2++++[<-------->-]<1 subtract 33 (!)
    [ 
        % we've reached the number
        ---------------
        % now it's either 0 or 1

        % check next char; If it's not 0 then it's '!'
        % 0! = 1! = 1!...! so we only need to determine if at least one ! exists
        >2,
                [<[-]+>-]<1

        % apply inversions
        <0
        [->1
            % invert cell 1 once each iteration
                       % cell 1 is 0 or 1
            -          % cell 1 is 255 or 1
            [>+<+]     % cell 1 is 0; cell 2 is 1 iff cell 1 should be 1
            >2[-<+>]<1 % cell 1 is 1 or 0
        <0]

        % print result
        >1>++++++[-<++++++++>]<1.

        >>2+< % tape={0 r 0 1}
    ]
    >2-[ % we haven't seen the number yet
        <<0+>1,>2 % add to inverter count
        [-]
    ]<1
]

— रे
स्रोत

2

बैच, 62 बाइट्स

@set/ps=
@set s=%s:0!=1%
@set s=%s:!!=%
@cmd/cset/a%s:1!=1%

STDIN पर इनपुट लेता है। बैच वास्तव में !इस चुनौती के लिए अग्रणी सही ढंग से समझता है , लेकिन अनुगामी !को इससे निपटने की आवश्यकता है, जिसमें तीन कदम हैं:

बदले 0!के लिए1
के जोड़े हटाएं !!(यह !!अंक के लिए पहले भी सुरक्षित है)
किसी भी शेष अनुगामी को हटाएँ !(जो अब तक केवल एक के बाद एक हो सकता है 1)

— नील
स्रोत

2

आईबीएम / लोटस नोट्स फॉर्मूला - 77 बाइट्स

@Eval(@Left(a;@If(@Like(a;"%1%");"1";"0"))+@If(@Ends(a;"!");"1";@Right(a;1)))

नोट्स फॉर्मूला के लिए कोई TIO नहीं है, इसलिए सभी परीक्षण मामलों का स्क्रीनशॉट नीचे दिखाया गया है:

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

@Eval() अभिव्यक्ति के रूप में एक स्ट्रिंग का मूल्यांकन करता है

पहले हम जांचते हैं कि क्या इनपुट स्ट्रिंग फील्ड (इनपुट) aमें है 1या 0सभी वर्णों को बाईं ओर ले जायें जो भी हो वह !वर्णों का एक स्ट्रिंग होगा । हमें परवाह नहीं है कि कितने। @Eval()उस का ख्याल रखना होगा।

अगला हम यह देखने के लिए देखते हैं कि क्या !स्ट्रिंग के अंत में है। अगर वहाँ हम 1करने के लिए संलग्न है! स्ट्रिंग के हैं ( 0!और 1!दोनों 1 हैं - इससे कोई फर्क नहीं पड़ता कि !अंत में कितने वर्ण हैं) अन्यथा हम अंतिम चरित्र को अपरिवर्तित करते हैं क्योंकि यह एक नहीं !है या एक 1या एक हो सकता है 0।

अब हमारे पास एक स्ट्रिंग है जिसमें प्रमुख व्युत्क्रम हैं और एक संख्या है जो परिभाषित करता है कि क्या कोई तथ्यात्मक चरित्र हैं इसलिए हम इसे फ़ीड कर सकते हैं @Eval()और उपरोक्त परिणाम प्राप्त कर सकते हैं ।

— ElPedro
स्रोत

2

सेड, ३६ 33 31 बाइट्स

शुद्ध सेड, कोई बीसी / शेल बर्तन नहीं। GNU sed <4.3 पर काम करता है; बीएसडी और जीएनयू 4.3+ पर 33 बाइट्स।

s/.!!*$/1/
:
s/!0/1/
s/!1/0/
t

अगर आप से परिचित हैं तो सीधा पर्याप्त है sed ; जो नहीं कर रहे हैं के लिए टिप्पणी की:

# Since 0! == 1! == 1 and factorial has precedence, just collapse any trailing "!" 
s/.!!*$/1/
# Define an anonymous label
:
# Invert 0 if needed
s/!0/1/
# Invert 1 if needed
s/!1/0/
# If a change was made, go back to the anonymous label.
t

परीक्षा:

% cat 109248.sed
s/.!!*$/1/
:l
s/!0/1/
s/!1/0/
tl
% wc -c 109248.sed
      33 109248.sed
% cat cases
0
1
0!
1!
!0
!1
!0!
!1!
0!!
1!!
!!0
!!1
!0!!
!!!1
!!!0!!!!
!!!1!!!!
% sed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
% gsed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
%

— केविन
स्रोत

IIRC कुछ (सभी?) संस्करण sedआपको एक लेबल नाम के रूप में नल स्ट्रिंग का उपयोग करने की अनुमति देता है। यदि आप यहां काम कर सकते हैं, तो यह आपको दो बाइट्स बचा सकता है। वास्तव में, मुझे यकीन नहीं है कि लेबल की भी आवश्यकता है; जब तक मैंने कुछ याद नहीं किया, तब तक पहली पंक्ति ही बेकार है, इसलिए आप लेबल की आवश्यकता के बजाय कार्यक्रम की शुरुआत में वापस कूदने में सक्षम हो सकते हैं।

@ ais523 मैंने भी ऐसा सोचा था, लेकिन जाहिर है कि यह बीएसडी संस्करणों में काम नहीं करता है। मैन पेज कहता है "यदि कोई लेबल निर्दिष्ट नहीं है, तो स्क्रिप्ट के अंत तक शाखा," और यहां तक कि जब मैं कोशिश कर रहा था तब भी काम नहीं कर रहा था।

— केविन

GNU sed एक लेबल को सिर्फ :(फीचर के रूप में लिया गया बग का अधिक) होने देता है, जिस स्थिति में दोनों tऔर b! कमांड लेबल की स्थिति पर जाते हैं। साथ ही, एक सीड कोड को अन्य भाषाओं के समान, कम से कम एक संस्करण सीड के लिए काम करना चाहिए, इसलिए आपको बीएसडी के लिए भी काम करने वाले कोड बनाने की आवश्यकता नहीं है।

— शीशमारा

2

PHP 7.1, 58 55 54 37 35 बाइट्स

नोट: IBM-850 एन्कोडिंग का उपयोग करता है

echo!!$argn[-1]^strspn($argn,~Ì)%2;

इस तरह से चलाएं:

echo '!!!0!!!!' | php -nR 'echo!!$argn[-1]^strspn($argn,~Ì)%2;';echo
> 0

व्याख्या

echo
  strspn($a=$argv[1],~Ì) # Count the number of leading exclamation marks.
  % 2                    # Make 0 (even) or 1 (odd).
  ^ !!$a[-1];            # Negate with factorial part (truthy value of the 
                         # last char):
                         # - "0" is considered falsy.
                         # - "1" or "!" is considered truthy.

बदलाव

IBM-850 एन्कोडिंग का उपयोग करके 3 बाइट्स सहेजे गए
रेग्ज को थोड़ा बदलकर एक बाइट को बचाया
सहेजे गए 17 बाइट्स, लंबे फ़ंक्शन नामों के बिना नया संस्करण और वापसी
सहेज कर 2 बाइट्स -R(जो $argnउपलब्ध करता है)

— aross
स्रोत

1

बीन , 24 बाइट्स

Hexdump:

00000000 26 4a c1 53 a0 17 53 d0 80 a0 5d 20 80 0a a1 80  &JÁS .SÐ. ] ..¡.
00000010 81 00 25 3a ae a1 ab 24                          ..%:®¡«$
00000018

समतुल्य जावास्क्रिप्ट:

+eval(a.replace(/.!+$/,1))

अपने पैर की उंगलियों पर कदम रखने के लिए क्षमा करें, अरनौल ।

स्पष्टीकरण:

इनपुट की पहली पंक्ति को बिना स्ट्रिंग वाले स्ट्रिंग के रूप में लेता है a, और उसके बाद किसी भी अंक को एक या एक से अधिक के !साथ बदलता है 1, ताकि बाकी evalजावास्क्रिप्ट द्वारा घ में हो सके ।

डेमो , या परीक्षण सूट की कोशिश करो

— पैट्रिक रॉबर्ट्स
स्रोत

गणित तथ्य है। प्रोग्रामिंग नहीं है

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

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

[बैश] + यूनिक्स उपयोगिताओं, 21 17 बाइट्स

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

व्याख्या

ग्रिम , 14 12 9 बाइट्स

व्याख्या

ब्रेनफक, 85 72 (84) बाइट्स

Brainfuck - कई बाइट्स का रास्ता (232 बाइट्स)

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

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

गैर-रेगेक्स विधि ( 41 31 बाइट्स)

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

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

कैसे?

05AB1E , 9 बाइट्स

रेटिना , 13 बाइट्स

रूबी, 12 + 1 = 39 24 15 13 बाइट्स

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

सी, 68 62 61 53 बाइट्स

पर्ल 6 , 32 28 23 बाइट्स

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

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

व्याख्या

Befunge, 24 बाइट्स

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

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

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

व्याख्या

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

जावा 7, 105 82 81 बाइट्स

पुराना रेगेक्स-ईश समाधान

सीजेएम , 12 11 बाइट्स

हास्केल , 67 65 बाइट्स

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

Ungolfed:

बैच, 62 बाइट्स

आईबीएम / लोटस नोट्स फॉर्मूला - 77 बाइट्स

सेड, ३६ 33 31 बाइट्स

PHP 7.1, 58 55 54 37 35 बाइट्स

व्याख्या

बदलाव

बीन , 24 बाइट्स

स्पष्टीकरण:

डेमो , या परीक्षण सूट की कोशिश करो