14

कल्पना कीजिए कि मेरे पास अनंत संख्या में होमवर्क की समस्याएं हैं (!) प्रत्येक को एक पूर्णांक संख्या दी गई है।

गणित समस्या अंक समस्या विनिर्देशक का उपयोग करके समस्या के सबसेट का वर्णन करने के लिए एक अंकन है।

एक MPN अभिव्यक्ति में कई चीजें शामिल हो सकती हैं:

एक एकल मूल्य। यह संख्या वाले एक सेट का प्रतिनिधित्व करता है 99 -> {99}:।
एक साधारण सीमा। यह सेट का प्रतिनिधित्व करता है जिसमें रेंज से लेकर अंत तक सभी संख्याएँ होती हैं 10~13 -> {10, 11, 12, 13}:। यदि बाएं या दाएं किनारे गायब हैं, तो उन्हें क्रमशः माना जाता है -Infinity या Infinity ~10 -> {x|x ≤ 10}:; ~ -> ℤ।
एक MPN अभिव्यक्ति, उसके बाद "स्किप" और दूसरा MPN अभिव्यक्ति। यह दो सेटों के अंतर को दर्शाता है 10~20 skip 12~14 -> {10, 11, 15, 16, 17, 18, 19, 20}:।
दो MPN भाव, एक अल्पविराम द्वारा अलग किए गए। यह दो सेटों के मिलन का प्रतिनिधित्व करता है 1,8~9,15~17 -> {1,8,9,15,16,17}:।

"स्किप" ऑपरेटर अल्पविराम ऑपरेटर की तुलना में सख्त है, इसलिए 16,110~112 skip 16 -> {16,110,111,112}(16 सेट में शामिल नहीं है {110,111,112}, इसलिए 16 को छोड़कर कोई फर्क नहीं पड़ता।)

आप विघटन के लिए कोष्ठक में भी भाव डाल सकते हैं: 1~9 skip (2~8 skip (3~7 skip (4~6 skip 5))) -> {1,3,5,7,9}

यह व्याकरण है:

<expr>  ::= "(" <expr> ")"
         || <number>
         || [<number>] "~" [<number>]
         || <expr> "skip" <expr>
         || <expr> "," <expr>

आपका कार्य एक प्रोग्राम लिखना है जो दो इनपुट लेता है:

एक MPN अभिव्यक्ति
एक संख्या

और MPN अभिव्यक्ति द्वारा वर्णित सेट में वह समस्या है या नहीं, इस पर निर्भर करते हुए कुछ सत्य या गलत मूल्य का आउटपुट देता है।

विशेष विवरण

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

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

10~20             14 -> True
10~20             20 -> True
10~20 skip 14~18  17 -> False
~ skip 6          8  -> True
16,17 skip 16     16 -> True
(16,17) skip 16   16 -> False
~10,5~            8  -> True
~10,5~            4  -> True
6 skip 6,~        6  -> True

— फल तोड़ना
स्रोत

क्या ऑपरेटरों का प्रतिनिधित्व करने के लिए अन्य पात्रों का उपयोग करना संभव है? उदाहरण के लिए ~ के बजाय # का उपयोग करें

— rahnema1

1

@ rahnema1 के लिए ~और ,, लेकिन के लिए नहीं skip।

— फल

3

4 के लिए ~ 10,5 ~ झूठा क्यों है? क्योंकि अनंत और 10 से 5 के बीच की अनंतता का संघ है, जिनमें से पहले में 4 शामिल हैं

— ev3commander

@ ev3commander संपादित। मैं हमेशा अपने परीक्षण के मामलों में गड़बड़ करता हूं। मुझे यकीन है कि अगर मैं उन्हें नहीं

— जोड़ूंगा

1

@ चैलेंजर 5 मैंने एक टेस्ट केस जोड़ा है 6 skip 6,~जो मुझे विश्वास है कि मैंने सही तरीके से व्याख्या की है। अन्य 2 उत्तर अब तक इसे संतुष्ट नहीं करते हैं (फिर, मुझे लगता है कि मैं सही ढंग से व्याख्या कर रहा हूं)। अगर मुझे गलत लगा है तो कृपया इसे सही करें और स्पष्ट करें, लेकिन मेरी समझ से, यह कुछ भी मेल खाना चाहिए (यह एक सेट का संघ है जो एक सेट के साथ कुछ भी नहीं मैच करता है जो सब कुछ मेल खाता है)। ये इस प्रकार के मामले हैं जिनके बारे में मैं पहले बात कर रहा था कि मुझे लगता है कि हमारे समाधानों का परीक्षण करने में बहुत मदद मिल सकती है।

— briantist

3

पॉवरशेल , 189 195 बाइट्स

param($m,$q)('$m',"'(\d*)~(\d*)','($q-ge(`$1)-and$q-le(`$2))'","'\(\)',$q","'((?<=,|skip )\d+|\d+(?=,| skip))','($q-eq`$1)'","'skip','-and!'"-join'-replace'|iex|% Sp* ','|%{"($_)"})-join'-or'|iex

व्याख्या

मुझे इस बात का अहसास है कि शिशुओं में एरे पैदा करने और मूल्यों के परीक्षण के लिए यह अस्थिर है।

मैंने श्रेणियों में देखा, लेकिन। नेट में उनके पास आवश्यक सीमा नहीं है (सीमा की लंबाई एक हस्ताक्षरित (32 बिट) पूर्णांक तक सीमित है, इसलिए भले ही रेंज को हस्ताक्षरित 32-बिट इंट तक सीमित करना ठीक था , मैं सभी श्रेणियों को संभालने में सक्षम नहीं था।

इसलिए मैंने शुरू और समाप्त होने के संदर्भ में बस इस बारे में सोचना शुरू कर दिया, और अंततः बूलियन परीक्षणों की एक श्रृंखला शुरू कर दी और एमपीएक्स को एक बूलियन अभिव्यक्ति में बदलने के लिए रीगेक्स की एक गुच्छा बनाना शुरू कर दिया, जिसे पावरशेल समझता है।

मैंने मूल रूप से कुछ नियमों में इसे तोड़ दिया:

रंग पहले के साथ काम करना आसान था क्योंकि वे किसी भी छोर पर अभिव्यक्ति नहीं कर सकते हैं, लेकिन खुले-एंडनेस को जल्द ही लागू करने के लिए दर्द था। आधार 2~8कहने जैसा है n >=2 && n <=8, लेकिन जब एक छोर गायब है, तो बाहर &&और गायब पक्ष को छोड़ दें । जब दोनों गायब हैं, तो मैं मूल रूप से बस इसे बदलने जा रहा था $true। मैंने जो किया वह वास्तव में गायब पक्षों के लिए बिल्कुल भी परीक्षण नहीं था, लेकिन मैंने प्रत्येक संख्या को लपेटना सुनिश्चित किया ()।
और फिर एक सीधा प्रतिस्थापन करें जो ()इनपुट मान के साथ खाली कोष्ठक को प्रतिस्थापित करता है । तो, ~8इनपुट मूल्य के साथ जैसे MPN के मामले में 55, पहले प्रतिस्थापित उत्पन्न होगा (55-ge()-and55-le(8)), फिर दूसरा प्रतिस्थापन इसे बनाने के लिए आता है (55-ge55-and55-le(8)), अनिवार्य रूप से सीमा के उस हिस्से को अशक्त करना।
आगे मुझे MPN में अलग-अलग नंबरों से निपटना था, लेकिन ध्यान रखना था कि मैं पहले से डाले गए लोगों के साथ गड़बड़ न करूं। यह वास्तव में अल्पविराम से ,अलग की गई सूचियों में संख्याएँ हैं , और पहले या बाद में अलग-अलग संख्याएँ हैं skip, इसलिए मैंने दुर्भाग्यपूर्ण लंबे लुकराउंड का उपयोग किया।
skipमूल रूप से रूप में ही है -and -notइसलिए मैं एक सीधी का स्थान लेते हैं skipकरने के लिए -and!(का उपयोग कर !के लिए आशुलिपि के रूप में -not)।
अगली मुश्किल बात शेष अल्पविराम के लिए पूर्वता का निम्न क्रम था। मैंने मूल रूप से बस उन्हें बदल दिया, -orलेकिन बाद के भावों का हिसाब नहीं 16,17 skip 16था इसलिए कोड उत्पन्न कर रहा था ($n-eq16)-or($n-eq17) -and! ($n-eq16)। इसमें कोष्ठक की आवश्यकता थी, लेकिन यह एक सीधी जगह के साथ अविश्वसनीय था। चूंकि कॉमास को छोड़कर अन्य सभी चीजों को बदल दिया गया था, और उनकी सबसे कम पूर्वता है, मैंने अभी शेष कॉमा पर पूरे उत्पन्न स्ट्रिंग को विभाजित किया, फिर प्रत्येक तत्व को कोष्ठक में लपेट दिया, और इसके साथ फिर से जुड़ गया -or।

अंततः उत्पन्न कोड को बस क्रियान्वित किया जाता है Invoke-Expression( iex) निष्पादित किया जाता है और फिर हमें बूलियन परिणाम मिलता है ( आप कोड को देख सकते हैं जो यहां परिणाम के बजाय उत्पन्न होता है )।

यह बहुत लंबा हो गया, और मुझे यकीन है कि कुछ और बाइट्स को निचोड़ने के लिए कुछ जगह है, लेकिन मैं इसे अब और नहीं देख सकता:

— briantist
स्रोत

2

पर्ल, 99 130 बाइट्स

sub f{($_,$n)=@_;s/(-?\d+)?~(-?\d+)?|(-?\d+)/!(defined$3?$n!=$3:length$1&&$1>$n||length$2&&$n>$2)+0/ge;s/skip/&&!/g;s/,/||/g;eval}

Ideone पर इसे आज़माएं।

Ungolfed:

sub f {
    my ($e, $n) = @_;

    $e =~ s/(-?\d+)?~(-?\d+)?|(-?\d+)/ (defined($3) ? $n == $3 : (!length($1) || $n >= $1) && (!length($2) || $n <= $2)) + 0 /ge;
    $e =~ s/skip/ && ! /g;
    $e =~ s/,/ || /g;

    return eval($e);
}

— डेनिस इबाव
स्रोत

1

इनपुट -2 के लिए ~ -2 के लिए विफल। डालने के दौरान भी -? तीनों से पहले d *

— Kjetil S.

@KjetilS। नकारात्मक संख्या और शून्य के लिए निश्चित।

— डेनिस इबाव

अच्छा कोड (पूर्ण विकसित व्याकरण अक्सर की जरूरत नहीं है, regexes आसान कर रहे हैं उड़ा दिया)

— Kjetil एस।

1

जावास्क्रिप्ट (ईएस 6), 221 292 287 309 274 277 278 बाइट्स

(-5 बाइट्स ओकेक्स के लिए धन्यवाद)

(j,v,m=1/0,Z=/(skip)([^,]+)/g)=>eval(j[M='replace'](/(-?\d*)~(-?\d*)/g,(e,a,b)=>(a[M]('-','#')||-m)+'<='+(T=v[M]('-','#'))+'&&'+T+'<='+(b[M]('-','#')||m))[M](Z,i=o=>o.match(Z)?i(o[M](Z,'&&!($2)')):o)[M](/,/g,'||')[M](/(^|[^=&#\d])(\d+)([^<\d]|$)/g,'$1$2=='+v+'$3')[M](/#/g,'-'))

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

टेस्ट स्निपेट

D=(j,v,m=1/0,Z=/(skip)([^,]+)/g)=>eval(j[M='replace'](/(-?\d*)~(-?\d*)/g,(e,a,b)=>(a[M]('-','#')||-m)+'<='+(T=v[M]('-','#'))+'&&'+T+'<='+(b[M]('-','#')||m))[M](Z,i=o=>o.match(Z)?i(o[M](Z,'&&!($2)')):o)[M](/,/g,'||')[M](/(^|[^=&#\d])(\d+)([^<\d]|$)/g,'$1$2=='+v+'$3')[M](/#/g,'-'))

MPN Expression:<input type="text" value="1~9 skip (2~8 skip (3~7 skip (4~6 skip 5)))" id="MPN"></input>
<br>
Integer:<input type="number" id="INT" value=6></input>
<input type="button" value="Submit" onclick="T=r=>document.getElementById(r).value;console.log(D(T('MPN'),T('INT')))"></input>

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

— आर। कप
स्रोत

@AriaAx यह अब काम करना चाहिए।

— आर। कप

@ R.Kap आप के 1/0लिए उपयोग कर सकते हैं Infinity।

— ओकेक्स

@ R.Kap मैंने 6उस अभिव्यक्ति के साथ मूल्य की कोशिश की 6 skip 6,~जिसे मैं मानता हूं कि trueयह होना चाहिए लेकिन यह रिटर्न देता है false।

— रिश्वतवादी

@briantist वास्तव में, मुझे विश्वास है कि चाहिए वापसी falseके रूप में skipकरने के लिए लागू होता है सब कुछ है कि यह (इस प्रकार 6,~के रूप में यह है कि इस मामले में) जब तक नहीं कोष्ठक के अंदर लिपटे। इसलिए, मेरा मानना है कि पूर्णांक इनपुट के बजाय इस trueपर लौटना चाहिए । (6 skip 6),~6 skip 6,~6

— आर। काप

@briantist दूसरे शब्दों में, कुछ भी6 skip 6,~ मेल नहीं खाना चाहिए क्योंकि यह सेट {6}और सेट के बीच के अंतर को दर्शाता है {6,-Infinity...Infinity}।

— आर। काप

0

रोड़ा + ई.पू., १ by३ बाइट्स

f x{{["x=",x,"\n"];replace" ","",",","||","skip\\(","&&!","skip([0-9~]+)","&&!($1)","(?<!~|\\d)(\\d+)(?!~|\\d)","x==$1","(\\d*)~(\\d*)","x>=($1)&&x<=($2)","\\(\\)",x;["\n"]}|exec"bc"}

यह पॉवरशेल उत्तर के समान है (या मुझे ऐसा लगता है, मुझे पॉवरशेल समझ में नहीं आता है)। यह संख्या को एक तर्क के रूप में और कोड को इनपुट स्ट्रीम में मान के रूप में लेता है, जैसे main { push("1~9") | f(5) }:।

मुझे लगता है कि यह काम करता है, कम से कम यह सभी परीक्षण मामलों को हल करता है। इसे सत्यापित करने के लिए नीचे दी गई स्क्रिप्ट का उपयोग किया जा सकता है।

main {
    readLines("/tmp/tests.txt") | split(sep=";") | for code, num, ans do
        push(code, " -> ")
        print(code) | replace" ","",",","||","skip\\(","&&!","skip([0-9~]+)","&&!($1)","(?<!~|\\d)(\\d+)(?!~|\\d)","x==$1","(\\d*)~(\\d*)","x>=($1)&&x<=($2)","\\(\\)",num
        a := push(code) | f(num) | head()
        result := push("OK") if [ (a = "0" and ans = "False") or (a = "1" and ans = "True") ] else push("FAIL")
        print code, " ; ", num, " -> ", a, " ", ans, " (", result, ")\n"
    done
}

और परीक्षण:

10~20;14;True
10~20;20;True
10~20 skip 14~18;17;False
~ skip 6;8;True
16,17 skip 16;16;True
(16,17) skip 16;16;False
~10,5~;8;True
~10,5~;4;True
6 skip 6,~;6;True

— fergusq
स्रोत

गणित समस्या अंकन को हल करें