परिष्कृत विभाजन


19

पूर्णांक की एक सरणी पर विचार करें:

[1, 0, 9, 1, 3, 8]

इस सूची को लगातार उदात्त में विभाजित करने के कई तरीके हैं। यहाँ तीन हैं:

A: [[1, 0, 9], [1, 3, 8]]
B: [[1], [0, 9], [1, 3], [8]]
C: [[1, 0], [9, 1], [3, 8]]

हम एक विभाजन Y को और दूसरे विभाजन X के शोधन को कहेंगे यदि X को इसके कुछ उपविभागों को एक साथ जोड़कर Y से प्राप्त किया जा सकता है ।

तो Bएक परिशोधन है A: यदि हम पहले दो और अंतिम दो उपविजेताओं को एक साथ जोड़ते हैं, तो हम प्राप्त करते हैं A। लेकिन Cहै नहीं के एक शोधन A: हम अलग करना होगा 9और 1आदेश ठीक करने के लिए में Aसे। इसके अलावा, कोई भी विभाजन तुच्छ रूप से स्वयं का परिशोधन है।

ध्यान दें कि हमें किसी भी बिंदु पर किसी भी उदात्त या तत्व को पुनर्व्यवस्थित करने की अनुमति नहीं है।

चुनौती

दो विभाजनों (पूर्णांक की सूचियों की सूची) को देखते हुए Xऔर Y, यह निर्धारित करें कि क्या Yशोधन है X

आप यह मान सकते हैं कि विभाजनों में केवल पूर्ण से 0लेकर पूर्णांक शामिल होंगे 9। आपको लगता है कि मान नहीं करना चाहिए Xऔर Yएक ही सूची का विभाजन कर रहे हैं (अगर वे नहीं हैं, वे भी एक दूसरे के शोधन नहीं हैं)। Xऔर / या Yखाली हो सकता है लेकिन इसमें कभी भी खाली सब्लिस्ट नहीं होंगे।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेने और STDOUT (या निकटतम वैकल्पिक), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम आउटपुट कर सकते हैं, एक प्रोग्राम या फ़ंक्शन लिख सकते हैं।

इनपुट किसी भी सुविधाजनक स्ट्रिंग या सूची प्रारूप में लिया जा सकता है। चूंकि तत्व केवल एकल-अंक पूर्णांक होंगे, इसलिए आप सब्लिस्ट के भीतर एक सीमांकक को छोड़ना चुन सकते हैं, लेकिन सुनिश्चित करें कि अग्रणी 0s संभव हैं। आप लेने के लिए Xऔर Yविपरीत क्रम में चुन सकते हैं ।

आउटपुट सत्य होना चाहिए अगर Yकोई शोधन Xऔर मिथ्या है अन्यथा।

आपका कोड उचित डेस्कटॉप मशीन पर 1 सेकंड में नीचे दिए गए प्रत्येक परीक्षण मामलों को हल करने में सक्षम होना चाहिए। (यह सरल ब्रूट बल समाधानों से बचने के लिए केवल एक शुद्धता जांच है।)

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

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

प्रत्येक परीक्षण का मामला अपनी लाइन पर है, जैसा लिखा है X Y। मैं कुछ क्षैतिज स्थान बचाने के लिए GolfScript / CJam-style array अंकन का उपयोग कर रहा हूं:

Truthy:

[] []
[[0]] [[0]]
[[1 0 9 1 3 8]] [[1 0 9] [1 3 8]]
[[1 0 9 1 3 8]] [[1 0 9 1 3] [8]]
[[1 0 9 1 3 8]] [[1] [0] [9] [1] [3] [8]]
[[1 0 9] [1 3 8]] [[1 0 9] [1 3 8]]
[[1 0 9] [1 3 8]] [[1] [0 9] [1 3] [8]]
[[9 8 8 5 8 2 7] [5] [1 4] [2 0 0 6 0 8 4 2 6 4 2 3 7 8 7 3 9 5 7 9 8 2 9 5] [3 9 8] [7 1 4 9 7 4 5 9] [3 3 3] [9 0 7 8] [3 9 4 7 2 7 8 0 3 0] [8 2 2 7 3 9 3 2] [2 9 0 8 5 4 1 8 5 5 6 2 0 9 2 7 7 9 2 7] [3 6] [1 2 7 7 4 4 2 9]] [[9 8] [8] [5 8 2] [7] [5] [1 4] [2] [0 0 6] [0] [8 4 2] [6 4] [2] [3] [7 8] [7 3] [9] [5 7 9] [8 2] [9 5] [3] [9 8] [7 1 4] [9 7] [4 5 9] [3 3] [3] [9 0] [7 8] [3] [9] [4] [7 2] [7 8] [0] [3 0] [8 2] [2] [7 3] [9 3] [2] [2] [9] [0] [8 5 4] [1 8] [5 5] [6] [2 0] [9] [2] [7 7 9] [2 7] [3 6] [1 2] [7 7] [4 4 2] [9]]

Falsy:

[[0]] []
[[0]] [[1]]
[[1 0 9]] [[1 0 9] [1 3 8]]
[[1 0 9] [1 3 8]] [[1 0 9 1 3 8]]
[[1 0 9] [1 3 8]] [[1 0 9]]
[[1 0 9] [1 3 8]] [[1 0] [9]]
[[1 0 9] [1 3 8]] [[1 0] [9 1] [3 8]]
[[1] [0 9] [1 3] [8]] [[1 0 9] [1 3 8]]
[[9 8 8 5 8 2 7] [5] [1 4] [2 0 0 6 0 8 4 2 6 4 2 3 7 8 7 3 9 5 7 9 8 2 9 5] [3 9 8] [7 1 4 9 7 4 5 9] [3 3 3] [9 0 7 8] [3 9 4 7 2 7 8 0 3 0] [8 2 2 7 3 9 3 2] [2 9 0 8 5 4 1 8 5 5 6 2 0 9 2 7 7 9 2 7] [3 6] [1 2 7 7 4 4 2 9]] [[9 8] [8] [5 8 2] [7] [5 1] [4] [2] [0 0 6] [0] [8 4 2] [6 4] [2] [3] [7 8] [7 3] [9] [5 7 9] [8 2] [9 5] [3] [9 8] [7 1 4] [9 7] [4 5 9] [3 3] [3] [9 0] [7 8] [3] [9] [4] [7 2] [7 8] [0] [3 0] [8 2] [2] [7 3] [9 3] [2] [2] [9] [0] [8 5 4] [1 8] [5 5] [6] [2 0] [9] [2] [7 7 9] [2 7] [3 6] [1 2] [7 7] [4 4 2] [9]]

लीडरबोर्ड

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

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

# Language Name, N bytes

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

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

<script>site = 'meta.codegolf'; postID = 5314; isAnswer = true; QUESTION_ID = 51719</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

संबंधित चुनौतियां


स्वीकार्य इनपुट प्रारूप होगा [[[1 0 9] [1 3 8]] [[1] [0 9] [1 3] [8]]]या [["109" "138"] ["1" "09" "13" "8"]]नहीं?
डेनिस

@ डेनिस एक सरणी में पूरे इनपुट लपेटकर अजीब लगता है। मुझे उस मानक अभ्यास के बारे में पता नहीं है लेकिन यह एक मेटा प्रश्न के लायक हो सकता है। उन बाहरी कोष्ठकों के बिना यह निश्चित रूप से ठीक है।
मार्टिन एंडर

मैं एक मेटा सवाल लिखने की कोशिश करूँगा।
डेनिस

जवाबों:


6

सीजाम, 13 10 9 बाइट्स

lr.-F-U-!

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

@ Edc65 के सरल इनपुट प्रारूप का सुझाव देने के लिए @ MartinButner का धन्यवाद ।

इनपुट प्रारूप में सुधार और 3 एडिटोनल बाइट्स को बंद करने के लिए @ jimmy23013 को धन्यवाद।

आई / ओ

इनपुट

उपविजेताओं को ;एक-दूसरे से और उनके द्वारा अलग किया जाता है ,:

1;0;9,1;3;8
1,0;9,1;3,8

उत्पादन

1

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

lr e# Read line and a whitespace-separated token from STDIN.
.- e# Vectorized difference. Pushes the differences of corresponding code points.
F- e# Remove all occurrences of 15 (';' - ',') from the array.
U- e# Remove all occurrences of 0 from the array.
!  e# Push 1 if the resulting array is empty and 0 if not.

अलग-अलग लंबाई के तारों के लिए, .-सरणी में वर्ण छोड़ देंगे, जो पूर्णांक 0 या 15 के बराबर नहीं हो सकते।


आप उपयोग कर सकते हैं ;विभाजक के रूप में ... ll.m27m0-!
jimmy23013

@ jimmy23013: मैं नहीं देखता कि क्यों नहीं। ,और ;दोनों सामान्य सरणी वाक्यविन्यास हैं (और उनमें से कोई भी CJam द्वारा उपयोग नहीं किया गया है)। धन्यवाद!
डेनिस

9

पायथ, 19 बाइट्स

&gF_m{.u+NYdYQqFsMQ

इसे ऑनलाइन आज़माएं: प्रदर्शन या टेस्ट हार्नेस

मैं इनपुट के रूप में Pyth के tuple / सूची प्रारूप का उपयोग कर रहा हूं। बस परीक्षण मामलों के रिक्त स्थान को अल्पविराम से बदलें।

स्पष्टीकरण:

                     implicit: Q is the evaluated input
    m        Q       map each input list d to:
      .u   dY          reduce with intermediate states over d, initial value = []
        +NY              update initial value N with sum of N and Y (current element of d)
     {                 generate a set
   _                 invert
 gF                  check, if the first element is >= (superset) than the second
&                    and
                sMQ  check, if the joined lists of the input
              qF     are equal

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

Input: [[1,0,9],[1,3,8]],[[1],[0,9],[1,3],[8]]

यह .u+NYdYभाग सभी निरंतर सब्लिस्ट की गणना करता है, जिसमें पहला तत्व होता है।

[[1,0,9],[1,3,8]]     => [[], [1,0,9], [1,0,9,1,3,8]]
[[1],[0,9],[1,3],[8]] => [[], [1], [1,0,9], [1,0,9,1,3], [1,0,9,1,3,8]]

Bका शोधन है A, अगर प्रत्येक निरंतर सबलिस्ट है A(भी Bकेवल एक अपवाद है) का एक निरंतर सबलिस्ट है ।

तो मैं बस जाँच करता हूँ, अगर निरंतर उपविदों का Aसेट B( gF_m.u+NYdYQ) (के ) के निरंतर उप विभाजनों के सेट का सबसेट है ।

एकमात्र अपवाद है, यदि पहली इनपुट सूची में दूसरी इनपुट सूची की तुलना में कम तत्व हैं। उदाहरण के लिए इनपुट के लिए <Fm.u+YdYQवापस आ जाएगी ।True[[1]],[[1],[2]]

इसलिए मैं यह भी जांचता हूं कि क्या शामिल सूचियां भी समान हैं &...qFsMQ


7

जावास्क्रिप्ट ( ईएस 6 ), 67 70

3 बाइट्स संपादित करें thx @apsillers को बचाया

परीक्षण करने के लिए फ़ायरफ़ॉक्स में नीचे स्निपेट चलाएँ

f=(a,b)=>a+''==b // same values in the lists ?
&![...a.join(' ')].some((c,p)=>c<','&b.join(c)[p]>c) // splits in a are present in b?

// TEST

out=x=>O.innerHTML += x+'\n';

OK=[
[[],[]],
[[[0]],[[0]]],
[[[1,0,9,1,3,8]],[[1,0,9],[1,3,8]]],
[[[1,0,9,1,3,8]],[[1,0,9,1,3],[8]]],
[[[1,0,9,1,3,8]],[[1],[0],[9],[1],[3],[8]]],
[[[1,0,9],[1,3,8]],[[1,0,9],[1,3,8]]],
[[[1,0,9],[1,3,8]],[[1],[0,9],[1,3],[8]]],
[[[9,8,8,5,8,2,7],[5],[1,4],[2,0,0,6,0,8,4,2,6,4,2,3,7,8,7,3,9,5,7,9,8,2,9,5],[3,9,8],[7,1,4,9,7,4,5,9],[3,3,3],[9,0,7,8],[3,9,4,7,2,7,8,0,3,0],[8,2,2,7,3,9,3,2],[2,9,0,8,5,4,1,8,5,5,6,2,0,9,2,7,7,9,2,7],[3,6],[1,2,7,7,4,4,2,9]],[[9,8],[8],[5,8,2],[7],[5],[1,4],[2],[0,0,6],[0],[8,4,2],[6,4],[2],[3],[7,8],[7,3],[9],[5,7,9],[8,2],[9,5],[3],[9,8],[7,1,4],[9,7],[4,5,9],[3,3],[3],[9,0],[7,8],[3],[9],[4],[7,2],[7,8],[0],[3,0],[8,2],[2],[7,3],[9,3],[2],[2],[9],[0],[8,5,4],[1,8],[5,5],[6],[2,0],[9],[2],[7,7,9],[2,7],[3,6],[1,2],[7,7],[4,4,2],[9]]]
];

KO=[
[[[0]],[]],
[[[0]],[[1]]],
[[[1,0,9]],[[1,0,9],[1,3,8]]],
[[[1,0,9],[1,3,8]],[[1,0,9,1,3,8]]],
[[[1,0,9],[1,3,8]],[[1,0,9]]],
[[[1,0,9],[1,3,8]],[[1,0],[9]]],
[[[1,0,9],[1,3,8]],[[1,0],[9,1],[3,8]]],
[[[1],[0,9],[1,3],[8]],[[1,0,9],[1,3,8]]],
[[[9,8,8,5,8,2,7],[5],[1,4],[2,0,0,6,0,8,4,2,6,4,2,3,7,8,7,3,9,5,7,9,8,2,9,5],[3,9,8],[7,1,4,9,7,4,5,9],[3,3,3],[9,0,7,8],[3,9,4,7,2,7,8,0,3,0],[8,2,2,7,3,9,3,2],[2,9,0,8,5,4,1,8,5,5,6,2,0,9,2,7,7,9,2,7],[3,6],[1,2,7,7,4,4,2,9]],[[9,8],[8],[5,8,2],[7],[5,1],[4],[2],[0,0,6],[0],[8,4,2],[6,4],[2],[3],[7,8],[7,3],[9],[5,7,9],[8,2],[9,5],[3],[9,8],[7,1,4],[9,7],[4,5,9],[3,3],[3],[9,0],[7,8],[3],[9],[4],[7,2],[7,8],[0],[3,0],[8,2],[2],[7,3],[9,3],[2],[2],[9],[0],[8,5,4],[1,8],[5,5],[6],[2,0],[9],[2],[7,7,9],[2,7],[3,6],[1,2],[7,7],[4,4,2],[9]]]
];

dump=l=>l.map(x=>'['+x+']').join(',');

out('YES');
OK.forEach(l=>out(f(l[0],l[1])+' a['+dump(l[0])+'] b['+dump(l[1])+']'));
out('NO');
KO.forEach(l=>out(f(l[0],l[1])+' a['+dump(l[0])+'] b['+dump(l[1])+']'));
<pre id=O></pre>


इन दिनों में से एक मैं कार्रवाई में अपने भयानक समाधान देखने के लिए फ़ायरफ़ॉक्स डाउनलोड करने जा रहा हूं। :)
एलेक्स ए।

@AlexA। आप इसके बिना कैसे रह सकते हैं?
edc65

Repl.it का उपयोग करें, मुझे लगता है कि ES6 का समर्थन करता है: D
मार्क K Cowan

मुझे पसंद है कि आपने कैसे नाम दिया चर OKऔर KO
rr-

7

सी, ६ ९ 69५

2 स्ट्रिंग मापदंडों के साथ एक फ़ंक्शन, 0 या 1 लौटाता है।

पैरामीटर प्रारूप: सबलिस्ट को रिक्त स्थान ('') के साथ अलग किया गया, सूची तत्वों को अल्पविराम से अलग किया गया।

उदाहरण: "1,0,9 1,3,8" "1,0 9,1,3,8"

f(char*a,char*b){for(;*a-44?*a&&*b==*a:*b<48;a++)b++;return!(*b|*a);}

कम गोल्फ वाला

int f(char *a, char *b)
{
    // expected in a,b: digit,separator,digit... with separator being ' ' or ','
    for(; *a; a++,b++)
       // ' ' or digit in a must be the same in b
       // comma in a must be comma or space in b
       if (*a != ',' ? *b != *a : *b > *a) return 0;
    return !*b; // must have a null in *b too
}

टेस्ट Ideone (पुराना)


1
इनपुट प्रारूप का चतुर विकल्प। मैंने इसे एक और हास्केल उत्तर के लिए उधार लिया है।
निमि

मैंने अपने जेएस उत्तर के लिए इनपुट के लिए आपके विचार को छोड़ दिया, और यह आपके सी संस्करण की तुलना में एक बाइट तक लंबा हो गया जब तक कि मैंने इसे ईएस 6 में अपग्रेड नहीं किया ... जिसने उम्मीद की होगी ...
मार्क के कोवान

6

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

[]#[]=1<2
[x]#[y]=x==y
x@(a:b)#(c:d:e)|a==c=b#(d:e)|1<2=x#((c++d):e)
_#_=2<1

लौटाता है Trueया False। उदाहरण उपयोग: [[1,0,9],[1,3,8]] # [[1,0],[9]]-> False

सरल पुनरावर्ती दृष्टिकोण: यदि पहले तत्व मेल खाते हैं, तो पूंछ के साथ चलें, और फिर से शुरू करें लेकिन दूसरी सूची के सामने दो तत्वों को मिलाएं। आधार मामले हैं: दोनों सूची खाली -> True; एक ही तत्व के साथ दोनों सूची -> उनकी तुलना करें; केवल एक सूची खाली है -> False


6

CJam, 19 बाइट्स

q~]{_,,\f>:sS.+}/-!

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

आई / ओ

इनपुट

[[1 0 9] [1 3 8]] [[1] [0 9] [1 3] [8]]

उत्पादन

1

विचार

प्रत्येक विभाजन को निम्नलिखित दो गुणों का अवलोकन करके विशिष्ट रूप से पहचाना जा सकता है:

  • सभी उपनलिस्टों को सम्‍मिलित करके बनाई गई सूची।

  • सूची के चरम सहित "कटिंग पॉइंट्स"।

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

यह सत्यापित करने के लिए कि किसी दिए गए विभाजन को दूसरे की तुलना में महीन है, हमें केवल यह सत्यापित करना है कि ऊपर के रूप में दर्शाया गया कोइर्सर विभाजन, महीन एक का सबसेट है और दोनों विभाजनों की सबसे बड़ी सूची मेल खाती है।

कोड

q~]   e# Read from STDIN and evaluate.
{     e# For each array P from the input:
  _,, e#   Push [0 ... L], where L == length(P) - 1.
  \f> e#   Push [P[0:] ... P[L]].
  :s  e#   Stringify each P[k:] (flattens).
  S.+ e#   Vectorized concatenation. This appends a space to the first element.
}/    e#
-!    e# Push the logical NOT of the difference A-B to check if A is a subset of B.

इनपुट फॉर्म I / O उदाहरण के लिए, स्टैक रखता है

["109138 " "138"] ["109138 " "09138" "138" "8"]

निष्पादित करने से पहले -!

ध्यान दें कि प्रत्येक सरणी के पहले तत्व में एक अनुगामी स्थान है। यह सुनिश्चित करता है कि हम पहले इनपुट की पूरी सूची की दूसरी की पूरी सूची के साथ तुलना करें।


5

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

l~L\{+_a2$1<={;1>L}&}/+!

कलन विधि

यहां हम केवल एक लालची एल्गोरिथ्म का उपयोग करके यह देखते हैं कि पहली Nसूची की पहली उप-सूची बनाने के लिए दूसरी सूची की पहली उप-सूचियों को एक साथ मिलाया जा सकता है या नहीं। एक बार ऐसा Nपाए जाने के बाद, हम पहली Nउप-सूची को दूसरी सूची से हटाते हैं और पहली सूची से पहली उप-सूची और प्रक्रिया को दोहराते हैं।

आदर्श रूप से, यदि दूसरी सूची पहले का शोधन थी, तो हमें स्टैक पर 2 खाली सूचियों के साथ छोड़ दिया जाना चाहिए। हम सिर्फ उसके लिए जाँच करते हैं और 1यदि ऐसा है तो प्रिंट करते हैं। किसी भी अन्य संयोजन में, दूसरी सूची की उप-सूचियों पर पूरी तरह से चलने के बाद, हम 2 खाली सूचियों के साथ समाप्त नहीं होंगे। इस प्रकार 0ऐसे मामलों के लिए एक मुद्रित किया जाएगा।

कोड विस्तार

l~L\{+_a2$1<={;1>L}&}/+!
l~L\                       e# Read the line, evaluate the two lists and put an empty list
                           e# between them
    {               }/     e# Iterate over all sub-lists of the second list
     +                     e# Append the current sub-list to whatever is on stack. Originally
                           e# an empty array, but eventually the sum of first N sub-lists
      _a                   e# Copy this and wrap it in an array
        2$                 e# Copy the first list on top of stack
          1<               e# Get only its first element wrapped in an array. This approach
                           e# is exception safe in case the array was already 0 length
            ={    }&       e# If we have a match, remove both first sub-lists
              ;            e# Remove the first N sub-lists array
               1>          e# Remove the first element from the first array
                 L         e# Put an empty array on stack to repeat the process
                      +!   e# If we are left with two empty arrays, sum them and do logical
                           e# not to get 1. If any of the arrays is non-empty, logical not
                           e# gives 0

इसे यहाँ ऑनलाइन आज़माएँ या यहाँ पूरा परीक्षण सूट चलाएं


3

सी, 120 114 बाइट्स

#define C(x),x+=(*x/93)*(1+!!x[1])|1
o;R(char*s,char*t){for(o=1;*s;o&=*s==t[2*(*t==93&&93>*s)]C(s)C(t));return o;}

मैंने अभी हाल ही में गोल्फ नहीं खेला है, इसलिए मैंने सोचा कि मैं इसे आज़माऊंगा।

हम एक फ़ंक्शन को परिभाषित करते हैं, R(char* s, char* t)जो 1अगर tएक परिष्कृत विभाजन है s, और 0अन्यथा। sऔर tप्रारूप में होने की उम्मीद की जाती है, [DDDD...][DDDD...]...जहां प्रत्येक Dएक अन्य एकल-तत्व तत्व है।

परीक्षण कोड:

#include "stdio.h"

int main(int argc, char** argv) {
    char* str1, *str2;
    str1 = "[109][138]";
    str2 = "[1][09][13][8]";
    printf("Input: %s, %s --> %d\n", str1, str2, R(str1, str2));

    str1 = "[109][138]";
    str2 = "[1][19][13][8]";
    printf("Input: %s, %s --> %d\n", str1, str2, R(str1, str2));

    str1 = "[109][138]";
    str2 = "[10][91][3][8]";
    printf("Input: %s, %s --> %d\n", str1, str2, R(str1, str2));
}

उपरोक्त प्रिंट निम्न हैं:

Input: [109][138], [1][09][13][8] --> 1
Input: [109][138], [1][19][13][8] --> 0
Input: [109][138], [10][91][3][8] --> 0

यह काम करने लगता है, कम से कम।


3

हास्केल, 52 50 53 बाइट्स

x#y=and$zipWith(\a b->a==b||a==',')(x++"..")(y++"..")

मेरे अन्य समाधान से पूरी तरह से अलग है । @ Edc65 के उत्तर के समान चतुर इनपुट प्रारूप का उपयोग करता है , अर्थात तत्वों को अलग किया जाता है ,और सूची के साथ

प्रयोग उदाहरण: "1,0,9,1,3,8" # "1,0,9 1,3,8"-> True

दूसरा पैरामीटर पहले का शोधन है, अगर उनके पास हर स्थिति में समान तत्व हैं या पहला है ,। मुझे ..दोनों मापदंडों के लिए एक अद्वितीय अंत टोकन (-> ) संलग्न करना होगा, क्योंकि zipWithलंबे समय तक पैरामीटर को काटता है और उदाहरण के "1,2,3" # "1,2"लिए भी होगा True


1
(\a b->a==b||a>b)बस है (>=)
एलेफल्फा

काम के "."बजाय सिर्फ जोड़ना नहीं होगा ".."?
गर्वित हैकेलर

यह विफल रहता है "2"#"1"क्योंकि फ़ंक्शन केवल जाँचता है कि मान बड़े हैं, बराबर नहीं
गर्वित हैकर

@alephalpha: ओह डियर, मुझे इस बात को नजरअंदाज करने की कितनी बेवकूफी है। लेकिन यह वैसे भी गलत है। अन्य टिप्पणियाँ देखें।
nimi

@proudhaskeller: लानत आखिरी मिनट संपादन। हाँ, यह एक बग है। ठीक कर दिया। पता लगाने के लिए धन्यवाद। Btw, एक एकल डॉट "."काम नहीं है, क्योंकि यह एक गलती के लिए देना होगा होगा "2,1" # "2"जो पहले का विस्तार होगा "2,1." # "2."और उसके बाद से छोटा किया जा zipWithकरने के लिए "2," # "2."। पहले स्ट्रिंग में एक अल्पविराम सब कुछ मेल खाता है।
निम्मी

2

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

f@__=1<0;{}~f~{}=1>0;{a_,b___}~f~{c__,d___}/;a==Join@c:={b}~f~{d}

1
अच्छा समाधान है। FYI करें, मुझे एक 59-बाइट समाधान मिला है जो पुनरावृत्ति (या एकाधिक परिभाषा) का उपयोग नहीं करता है।
मार्टिन एंडर

2

नियमित अभिव्यक्ति के साथ गणित मजेदार है!

ईएस 6 जावास्क्रिप्ट, 53 वर्ण

(a,b)=>RegExp('^'+a.replace(/,/g,'[ ,]')+'$').test(b)

विंटेज जावास्क्रिप्ट, 70 वर्ण

function f(a,b){return RegExp('^'+a.replace(/,/g,'[ ,]')+'$').test(b)

Edc65 के उत्तर के समान इनपुट प्रारूप का उपयोग करता है

पूर्ण डेमो यहां सभी परीक्षण मामलों सहित।


चतुर! इस कार्य के लिए नियमित अभिव्यक्तियों के बारे में कभी नहीं सोचा।
edc65

मैंने एक पर्ल प्रोग्राम लिखा है जो एक पुनरावर्ती फ़ंक्शन का उपयोग करके पूर्णांक को कारक बनाता है जो कि एक नियमित अभिव्यक्ति का उपयोग करते हुए प्रमुख कारक पाए गए ... वे सुंदर नहीं हैं और निश्चित रूप से तेज़ नहीं हैं, लेकिन वे कुछ अच्छा सामान कर सकते हैं!
मार्क के कोवन

मैंने एक पार्सर जनरेटर भी लिखा, जो एक भाषा विनिर्देश को एक नियमित अभिव्यक्ति में परिवर्तित करता है, और उस नियमित अभिव्यक्ति का उपयोग निर्दिष्ट भाषा में अभिव्यक्ति को पार्स करने के लिए किया जा सकता है। मूल रूप से, "निष्पादन योग्य" नियमित-अभिव्यक्ति के लिए एक मानव-पठनीय भाषा कल्पना "संकलन"। github.com/battlesnake/d-slap AngularJS समझ के भावों को पार्स करने के लिए नियमित रूप से उत्पन्न अभिव्यक्ति लगभग 400-500 अक्षर लंबी है ...
मार्क के कोवान

2

मैथेमेटिका, 55 बाइट्स

Equal@@Join@@@#&&SubsetQ@@(Accumulate[Length/@#]&)/@##&

यह एक अनाम फ़ंक्शन को परिभाषित करता है, दो विभाजनों को एक ही सूची में , रिवर्स ऑर्डर (यानी Yपहले, Xदूसरे) में ले जाता है।

व्याख्या

Equal@@Join@@@#

यह जाँचता है कि दोनों विभाजन वास्तव में एक ही सूची के विभाजन हैं।

SubsetQ@@(Accumulate[Length/@#]&)/@##

यह इस सवाल पर मैथेमेटिका के ऊपर मेरे दृष्टिकोण का एक गढ़ रूप है , जिसने इस चुनौती को प्रेरित किया। मूल रूप से, एक विभाजन को कई सूचकांकों के रूप में परिभाषित किया जाता है जहां विभाजन को सम्मिलित किया जाता है, और यह जाँच करता है कि सभी विभाजन स्थिति उपनल की लंबाई को जमा करके Xभी दिखाई देते हैं Y


2

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

कुछ काफी बाइट-बचत के लिए xnor का धन्यवाद!

अनाम फ़ंक्शन जो फॉर्म के दो तार लेता है "1,0,9 1,3,8"( edc65 के C उत्तर से लिया गया है ) और रिटर्न Trueया False। नया संस्करण map(None)अब पायथन 3 में काम नहीं करता है।

lambda a,b:all(i in[j,","]for i,j in map(None,a,b))

परीक्षण सूट:

>>> def runTests(f):
    assert f("1,0,9 1,3,8","1 0,9 1,3 8")
    assert not f("1,0,9 1,3,8","1,0 9,1 3,8")
    assert f("1 0,9 1,3 8","1 0,9 1,3 8")
    assert not f("1 0,9 1,3 8","1,0,9 1,3,8")
    assert not f("1 0,9 1,3 8","1 0,9 1,3")
    assert not f("1 0,9 1,3,8","1 0,9 1,3")
    print("All tests pass.")


>>> runTests(lambda a,b:all(i in[j,","]for i,j in map(None,a,b)))
All tests pass.

पिछला 92-बाइट समाधान जो इनपुट के रूप में लेता है "109 138":

def R(a,b):
 r=1
 for i in b.split():r&=a.find(i)==0;a=a[len(i):].strip()
 return r and""==a

मुझे लगता है कि आप कोई भी मैपिंग करके स्पष्ट लंबाई की जांच करने से बच सकते हैं । मामला जब एक सूची दूसरे से लंबी होती है तो खारिज कर दिया जाता है, जहां एक सूची में एक सूची होती है, Noneलेकिन दूसरे सूचकांक में एक संख्या होती है, क्योंकि i==j or"0">i>jपकड़ नहीं हो सकती है।
xnor

जब तक मैं कुछ याद कर रहा हूँ, दूसरा परीक्षण बस हो सकता है i==','। इससे आप परीक्षणों को जोड़ i in[',',j]सकते हैं ( जैसा कि हम नहीं कर सकते i in ','+j) क्योंकि jहो सकता है None
xnor

@xnor वाह, धन्यवाद। # 1 मेरे साथ नहीं हुआ क्योंकि मैं अब पायथन 3 में सोचने के आदी हूँ; # 2 मेरे साथ नहीं हुआ क्योंकि "अगर bउस स्थान पर कोई संख्या है तो क्या होगा ?" ... यह भूल जाना कि इस इनपुट प्रारूप के साथ, यह संभव नहीं है।
DLosc
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.