तथ्य के बाद सहायक उपकरण!

Question

_{यह चुनौती गणित से प्रेरित तथ्य है। प्रोग्रामिंग नहीं है ।}

---

एक तथ्य के लिए गणितीय संकेतन, या एक तथ्य एक विस्मयादिबोधक चिह्न है !। विस्मयादिबोधक चिह्न notकई प्रोग्रामिंग भाषाओं में भी एक सामान्य प्रतीक है ।

चुनौती:

एक स्ट्रिंग लें, जिसमें अंक और वर्ण हों: + !इनपुट के रूप में और निम्नलिखित को आउटपुट करें:

विस्मयादिबोधक चिह्न के सामने सब कुछ एक गणितीय अभिव्यक्ति के रूप में मूल्यांकन किया जाना चाहिए, इसलिए 2+2होगा 4।

एक एकल विस्मयादिबोधक चिह्न के बाद सब कुछ सामान के रूप में जोड़ा जाना चाहिए जो इसके सामने है, इसलिए: 2+2!5देना चाहिए 45, क्योंकि 2+2=4, और 5एक सहायक है। 2+2!5+5देना चाहिए 410।

के बाद से !भी मतलब है not, कुछ भी है कि है नहीं इस तथ्य के बाद एक सहायक चाहिए नहीं संलग्न किया। तो, 2+2!!5देना चाहिए 4, क्योंकि 5एक सहायक नहीं है। अब, not(not(true))==trueतो 2+2!!!5देना चाहिए 45। 2+2!!5!5+5देना चाहिए: 410क्योंकि 2+2=4, उसके बाद एक भाज्य और उसके बाद !5!5+5। पहला 5एक तथ्य नहीं है, लेकिन 5+5एक और विस्मयादिबोधक चिह्न के बाद है, और इसलिए एक तथ्य है, फिर भी।

स्पष्टीकरण:

• विस्मयादिबोधक चिह्न एक +तरफ दोनों तरफ नहीं होंगे।
• +संख्याओं के लिए अग्रणी नहीं होगा (यह 5, नहीं +5)।
• यदि आप पहले के सामने अभिव्यक्ति का परिणाम हैं, तो आप वैकल्पिक रूप से एक अग्रणी शून्य शामिल कर सकते हैं !। दोनों 4और 04इनपुट के लिए स्वीकार किए जाते हैं उत्पादन कर रहे हैं:0+0!4

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

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

!
   <- Empty string

5
5

12!
12

!87
87

!!5
   <- Empty string

5+5!2+2
104

5+5!!2+2
10

1!2!3!4!5!6!7!8!9
12468

10+10!!2+2!!3+3!4+4
208

2!!3!5
25

2!!3!5!7
25

10!!!!!!!5
105

यह कोड-गोल्फ है इसलिए बाइट्स में सबसे छोटा कोड (प्रत्येक भाषा में) जीतता है! स्पष्टीकरण को दृढ़ता से प्रोत्साहित किया जाता है!

Comments

umm ... हम कहते हैं कि हमारे पास 2 है! 3! 5 यहाँ 5 है या 3 का सहायक नहीं है?

— आधिकारिक

@officialaimm इट 25(देखें जोड़ा गया परीक्षण मामला)। 2!!3!5!7इससे भी महत्वपूर्ण बात यह है कि 25, क्योंकि !बाईं ओर सम संख्या है 7(इसलिए आप संख्या के ठीक सामने रन को नहीं गिनेंगे, लेकिन इसके सभी !बाएं)।

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

क्या आउटपुट एक गणितज्ञ हो सकता है Row?

— नगीनिस

बेनाम: उम ... तो इस चुनौती वास्तव में factorials के साथ कुछ नहीं करना है?

— DLosc

Answer 1

रेटिना , 35 31 29 बाइट्स

ETHproductions से कुछ प्रेरणा लेकर 4 बाइट्स बचाए ।

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

\d+|\+
$*
1+
$.&
1`!

!\d*!?

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

Comments

आप कुछ बाइट्स को इस

— लियो

@ लियो वास्तव में साफ है, धन्यवाद। :)

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

Answer 2

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

मार्टिन एंडर को धन्यवाद दो बाइट्स बचाए ।

let f =
x=>x.replace(/[^!]+/g,eval).replace(/!(\d*)!?\d*/g,"$1")

<input value="2+2!5+5" oninput="try{O.value=f(value)}catch(e){}"><br>
<input id=O value="410" disabled>

किसी तरह सुधार हो सकता है ...

Comments

फ़ंक्शन तर्क का अच्छा उपयोग replace।

— नील

@ धन्यवाद, लेकिन मुझे एक बेहतर तरीका मिला :-)

— ETHproductions

आपका कोड स्निपेट मुझे गलत उत्तर दे रहा है 1+1!5। मुझे लगता है कि आप evalसे पहले बिट के लिए भूल गया !।

— मूल्य इंक

@ValueInk आह, मुझे नहीं लगता कि इसे ठीक करने का कोई आसान तरीका है।

— ETHproductions

Answer 3

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

ṣ”!µḢW;m2$VṾ$L¡€

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

व्याख्या

यहां मुख्य अवलोकन यह है कि हम "ऑर्डर से बाहर" चरण चला सकते हैं; रकमों का मूल्यांकन करने के बजाय हम जिन्हें पसंद नहीं करते हैं, उन्हें अनदेखा करते हुए, हम अमान्य स्थितियों में रकमों की अनदेखी कर सकते हैं, फिर बाकी का मूल्यांकन कर सकते हैं।

ṣ”!µḢW;m2$VṾ$L¡€
ṣ”!                Split input on '!'
   µ               Set as the new default for missing arguments
    Ḣ              Take the first element, removing it from the default
     W;  $         Cons with
       m2            every odd-numbered element of {the tail of the !-split input}
               €   For each remaining element
          VṾ$      Evaluate and de-evaluate it
             L¡      a number of times equal to its length

मूल्यांकन की तरह एक राशि "10+10"है, जैसे एक नंबर करने के लिए इसे का मूल्यांकन करेंगे 20, है, तो यह एक स्ट्रिंग के लिए डी-मूल्यांकन "20"। उस प्रक्रिया को दोहराने से कोई अतिरिक्त प्रभाव नहीं पड़ता है (यह आदर्श नहीं है)। इस प्रकार, हम प्रभावी रूप से स्ट्रिंग के प्रत्येक तत्व का मूल्यांकन करते हैं, अशक्त स्ट्रिंग को छोड़कर , जो कि अविकसित रहता है क्योंकि इसकी एक शून्य लंबाई होती है।

Comments

प्रत्येक आइटम का सशर्त मूल्यांकन करने के लिए यह एक बढ़िया चाल है। आप किसी भी तरह से तार्किक और प्रत्येक आइटम और इसके eval-deval'd मान ले सकते हैं? (मुझे लगता है कि खाली स्ट्रिंग जेली में

— मिथ्या है

@ETHproductions: जेली की साक्षी यह संभावना नहीं बनाती है कि बाइट्स बचाएंगे; यदि संभव हो तो दो बार एक ही मूल्य का उपयोग करने से बचें, और यदि आप एक मूल्य का पुन: उपयोग करना चाहते हैं, तो आपको सामान्य रूप से कम से कम µकहीं अतिरिक्त रखना होगा (और µलूप के अंदर काम नहीं करना है, जिसका अर्थ है कि आपको कुछ चाहिए होगा और भी अधिक क्रिया)। मैंने इसे काम करने के लिए प्रबंधित किया, जैसा कि ṣ”!µḢW;m2$ȧVṾ$$€, लेकिन यह कोई छोटा नहीं है (और डॉलर के संकेतों की विशेषता ढेर है जो तब होता है जब आप जेली को नियंत्रण संरचनाओं के लिए अपनी क्षमता के किनारे पर धक्का देते हैं।)

Answer 4

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

ṣ”!µḊm2;@ḢW$LÐfVṾ€

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

कैसे?

ṣ”!µḊm2;@ḢW$LÐfVṾ€ - Main link: string
ṣ”!                - split on '!' characters
   µ               - monadic chain separation (call that x)      e.g. ['1+1','0+0','0+0','0+0','','1+0','','','']
    Ḋ              - dequeue x (all but the leftmost entry of x) e.g.       ['0+0','0+0','0+0','','1+0','','','']
     m2            - modulo 2 index into that result             e.g.       ['0+0',      '0+0',   '1+0',   '']
           $       - last two links as a monad
         Ḣ         -     head x (the leftmost entry of x)        e.g.  '1+1'
          W        -     wrap                                    e.g. ['1+1']
       ;@          - concatenate with reversed arguments         e.g. ['1+1','0+0',      '0+0',   '1+0',   '']
             Ðf    - filter keep:
            L      -     length (keep that have non-zero length) e.g. ['1+1','0+0',      '0+0',   '1+0']
               V   - eval as jelly code (vectorises)             e.g. [  2,    0,          0,       1]
                      Yes, addition is just + and decimal numbers are just strings of digits in Jelly believe it or not!
                Ṿ€ - uneval €ach (creates a string from each one)e.g. [ '2',  '0',        '0'     ,'1']
                      without the € it would uneval the list and hence yield commas too)
                   - implicit print (prints the resulting list [of characters and possibly
                      lists of characters] as if it were all one string.)

Comments

मुझे नहीं लगता कि यह 0+0इनपुट के बीच में शाब्दिक के लिए काम करता है (ऐसी जगह जहां इसे खारिज नहीं किया जा रहा है); यह अशक्त स्ट्रिंग पैदा करता है, भले ही यह एक अंक 0.

आह, सच - मुझे एक लंबे समाधान के लिए जाना होगा :(

— जोनाथन एलन

तय किया जाना चाहिए (संभवतः गोल्फ अब)।

— जोनाथन एलन

Answer 5

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

r'!/{_{'+/1b}&}%(\2%

इसे ऑनलाइन आज़माएं! (लाइनफ़ीड-अलग टेस्ट सूट।)

Answer 6

रूबी , 58 56 + 1 = 59 57 बाइट्स

-pझंडे का उपयोग करता है । टूटलमैन से -2 बाइट्स ।

i=0;$_=' '+$_;gsub(/!?([^!]*)/){eval$1if(2>i+=1)||i%2<1}

इसे ऑनलाइन आज़माएं! (कोड की एक अतिरिक्त लाइन जोड़ी गई ताकि यह सभी इनपुट लाइनों को ले जाए और आउटपुट को विभिन्न लाइनों में प्रिंट कर सके।)

Comments

मुझे लगता है कि आप कोष्ठकों को चारों ओर छोड़ सकते हैं eval$1, नहीं?

— टर्टलमैन

@ टटलमैन हुह। मुझे नहीं पता कि मुझे क्या समस्या हो रही थी जिससे मुझे पैरेंस जोड़ने में मदद मिली (वे उस समय मौजूद नहीं थे जब मैंने प्रोग्राम लिखना शुरू किया था), लेकिन ऐसा लगता है कि मैं वास्तव में उन्हें ड्रॉप कर सकता हूं।

— वैल्यू इंक

Answer 7

बैच, 192 184 बाइट्स

@echo off
set/ps=
call:c . "%s:!=" "%"
echo(%s%
exit/b
:c
set s=
if not %2=="" set/as=%2
:l
shift
shift
if "%1"=="" exit/b
if %1=="" goto l
set/at=%1
set s=%s%%t%
goto l

खाली तारों को संभालना असुविधाजनक है।

Answer 8

पिप , 18 बाइट्स

मुझे लगता है कि यह सबसे कम हो जाता है ... हालांकि मैंने कहा कि तीन पुनरावृत्तियों के बारे में भी।

{VaX++v%2+!v}Ma^'!

कमांड-लाइन तर्क के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

                    a is 1st cmdline arg; global variable v is -1 (implicit)
              a^'!  Split a on !
{           }M      Map this function to the resulting list (note that inside function,
                    a is the function arg):
    ++v              Increment v (so that v tracks the 0-based index of the current
                     element)
       %2            We want to keep the elements where v%2 is 1...
         +!v         ... and also v=0, where v%2 is 0, but adding !v makes it 1
  aX                 String-multiply the argument by the above quantity (turning elements
                     we don't want into empty string)
 V                   Eval it (eval'ing empty string gives nil, but that's okay because
                     nil doesn't output anything)
                    Autoprint the resulting list, concatenated together (implicit)

Answer 9

आर, 95 बाइट्स

function(x)for(e in strsplit(gsub('!([^!]*)![^!]*','\\1!',x),'!')[[1]])cat(eval(parse(text=e)))

शायद सुधार के लिए कुछ जगह है, लेकिन इस समय यह सबसे अच्छा है जिसके साथ मैं आ सकता हूं।