43

एक प्रोग्राम या फ़ंक्शन लिखें जो सकारात्मक पूर्णांक की गैर-रिक्त सूची में लेता है। आप मान सकते हैं कि यह एक उचित सुविधाजनक प्रारूप में इनपुट है जैसे "1 2 3 4"या [1, 2, 3, 4]।

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

उदाहरण के लिए, पाई इसके लिए 1 2 3 4है:

आपके कोड का उत्तर देने वाला प्रश्न है: क्या पाई चार्ट कभी द्विभाजित है ? यही है, क्या कभी सर्कल की एक तरफ से दूसरी तरफ पूरी तरह से सीधी रेखा है, इसे दो में सममित रूप से विभाजित करते हैं?

यदि कोई कम से कम एक द्विभाजक है तो एक सत्य मूल्य का उत्पादन करने की आवश्यकता है और यदि कोई नहीं है तो एक मिथ्या मूल्य का उत्पादन करता है ।

1 2 3 4उदाहरण में, बीच में एक द्विशताब्दी है 4 1और 2 3इसलिए आउटपुट सत्य होगा।

लेकिन इनपुट के लिए 1 2 3 4 5कोई द्विभाजक नहीं है, इसलिए उत्पादन मिथ्या होगा:

अतिरिक्त उदाहरण

अलग से नंबर की व्यवस्था करने से बायसेक्टर हटाए जा सकते हैं।
जैसे 2 1 3 4→ मिथ्या:

यदि केवल एक नंबर इनपुट सूची में है, तो पाई द्विभाजित नहीं है।
जैसे 10→ मिथ्या:

कई बायसेक्टर हो सकते हैं। जब तक शून्य से अधिक हैं आउटपुट सत्य है।
उदाहरण 6 6 12 12 12 11 1 12→ सत्य: (यहाँ 3 द्विभाजक हैं)

यदि वे नेत्रहीन स्पष्ट नहीं हैं, तो भी अस्तित्व मौजूद हो सकता है।
जैसे 1000000 1000001→ मिथ्या:

उदा 1000000 1000001 1→ सत्य:

( पाई चार्ट बनाने के लिए nces.ed.gov पर धन्यवाद ।)

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

Truthy
1 2 3 4
6 6 12 12 12 11 1 12
1000000 1000001 1
1 2 3
1 1
42 42
1 17 9 13 2 7 3
3 1 2
10 20 10

Falsy
1 2 3 4 5
2 1 3 4
10
1000000 1000001
1
1 2
3 1 1
1 2 1 2 1 2
10 20 10 1

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर पहले जवाब है।

code-golf math arithmetic combinatorics decision-problem code-golf sequence number-theory binary code-golf number-theory set-theory code-golf hashing code-golf game card-games code-golf ascii-art code-golf arithmetic array-manipulation jelly code-golf string array-manipulation code-golf sorting code-challenge code-golf number date binary code-golf arithmetic code-golf math number linear-algebra polynomials code-golf ascii-art code-golf grid decision-problem code-golf string combinatorics code-golf string kolmogorov-complexity arithmetic date code-golf number data-structures code-golf ascii-art kolmogorov-complexity code-golf string ascii-art code-golf ascii-art kolmogorov-complexity code-golf array-manipulation

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

30

मेरा मानना है कि आप पाई संप्रदाय का मतलब है ?

— एलेक्स ए।

@ हेलकाहोम्बा, क्या आप इसे काम करने के लिए सेक्टरों को पुनर्व्यवस्थित कर सकते हैं, और क्या इसका मतलब है कि "अलग-अलग संख्याओं को व्यवस्थित करने से आप बायसेक्टर्स को हटा सकते हैं"?

— सोलोमन उको

@SolomonUcko आप क्षेत्रों को पुनर्व्यवस्थित नहीं कर सकते हैं।

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

1

केवल [2 1 3 4] झूठे मामलों का वास्तव में मूल्यांकन किया जाना है। अन्य झूठे मामलों को आसानी से खारिज कर दिया जाता है क्योंकि उनकी राशि विषम है (या उनकी लंबाई <2 है)।

— बेनी जोबिगन

12

जे, 18 बाइट्स

5 बाइट्स डेनिस के लिए धन्यवाद।

+/e.[:,/2*+/\-/+/\

@ हेलकाहोम्बा : नहींं।

प्रयोग

>> f =: +/e.[:,/2*+/\-/+/\
>> f 6 6 12 12 12 11 1 12
<< 4
>> f 10 20 10 1
<< 0

Ungolfed

black_magic  =: +/\-/+/\
doubled_bm   =: 2 * black_magic
flatten      =: ,/
sum          =: +/
is_member_of =: e.
f =: sum is_member_of monadic flatten doubled_bm

पिछला 23-बाइट संस्करण:

[:+/[:+/+/=+:@-/~@(+/\)

प्रयोग

>> f =: [:+/[:+/+/=+:@-/~@(+/\)
>> f 6 6 12 12 12 11 1 12
<< 4
>> f 10 20 10 1
<< 0

Ungolfed

black_magic =: -/~@(+/\)
double      =: +:
equals      =: =
sum         =: +/
monadic     =: [:
of          =: @
f =: monadic sum monadic sum (sum equals double of black_magic)

व्याख्या

सभी सबस्ट्रिंग के योग की गणना ब्लैक_कैम द्वारा की जाती है। +/\आंशिक रकम की गणना करें।

उदाहरण के लिए, a b c dबन जाता है a a+b a+b+c a+b+c+d।

-/~फिर एक घटाव इनपुट के आधार पर तालिका का निर्माण करती है, तो x y zहो जाता है:

x-x x-y x-z
y-x y-y y-z
z-x z-y z-z

जब लागू किया जाता है a a+b a+b+c a+b+c+d, तो परिणाम होगा:

    0  -b -b-c -b-c-d
    b   0   -c   -c-d
  b+c   c    0     -d
b+c+d c+d    d      0

इसमें उन सभी पदार्थों के योगों की गणना की गई है जिनमें सम्‍मिलित नहीं है a।

यह पर्याप्त होने की गारंटी देता है, क्योंकि यदि एक द्विध्रुव समाहित होता है a, तो दूसरा द्विध्रुव सम्‍मिलित नहीं होगा aऔर आसपास भी नहीं लिपटेगा ।

— लीक नन
स्रोत

3

कुछ पुनर्गठन के साथ, आप 13 बाइट्स प्राप्त कर सकते हैं:+/e.&,2*+/\\.

— ज़र्गब

10

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

Ḥ+\©_Sf®

एक गैर-रिक्त सूची (सत्य) या एक रिक्त सूची (मिथ्या) लौटाएं। इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

Ḥ+\©_Sf®  Main link. Argument: A (list)

Ḥ         Double all integers in A.
 +\       Take the cumulative sum of 2A.
   ©      Copy; store the result in the register.
    _S    Subtract the sum of A from each partial sum of 2A.
      f®  Filter; intersect this list with the list in the register.

— डेनिस
स्रोत

7

जूलिया, 34 30 29 बाइट्स

!x=sum(x)∈cumsum!(x,2x).-x'

1 बाइट को बंद करने के लिए @ गेलो को धन्यवाद!

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

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

X में 2x का संचयी योग जमा करने के बाद , हम पंक्ति वेक्टर x को कॉलम वेक्टर x से घटाते हैं , सभी संभावित अंतरों के मैट्रिक्स को उपजते हैं। अनिवार्य रूप से, यह x के सभी आसन्न उपसमूहों के योगों की गणना करता है जिसमें पहले मूल्य, उनके नकारात्मक और विकर्ण में 0 का समावेश नहीं होता है।

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

— डेनिस
स्रोत

15

आइए देखें कि डेनिस किसी और को देने से पहले 5 उत्तर देता है।

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

6

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

f=lambda l,s=0:l>[]and(sum(l)==s)|f(l[1:],s+l[0])|f(l,s+l.pop())

पुनरावर्ती रूप से सामने या अंत से तत्वों को हटाने की कोशिश करता है जब तक कि जो शेष रहता है वह उस राशि के बराबर होता है जो हटा दिया गया था, जो संग्रहीत है s। सूची की लंबाई में समय घातांक लेता है।

डेनिस ने 3 बाइट्स बचाए pop।

— XNOR
स्रोत

एक अजीब विकल्प जो सूची देता है:f=lambda l,s=0:l and(sum(l)==s)*l+f(l[1:],s+l[0])+f(l,s+l.pop())

— xnor

5

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

f l=elem(sum l/2)$scanr(:)[]l>>=scanl(+)0

विचार यह जांचने के लिए है कि lकिसकी राशि के बराबर का सबलिस्ट है sum l/2। हम इन सब्लिस्ट्स के रूप में उत्पन्न करते हैं scanr(:)[]l>>=scanl(+)0। आइए देखें कि यह कैसे काम करता हैl=[1,2,3]

>> scanr(:)[]l
[[1,2,3],[2,3],[3],[]] 
-- the suffixes of l

>> scanl(+)0 [2,3,4]
[0,2,5,9]
-- the cumulative sums of the input

>> scanr(:)[]l>>=scanl(+)0
[0,1,3,6,0,2,5,0,3,0]
-- the cumulative sums of the suffixes of l, flattened to a single list

पुराने 43 बाइट्स:

f l|c<-scanl1(+)l=elem(sum l/2)$(-)<$>c<*>c

cसंचयी रकमों की सूची तैयार करता है। फिर, यह जाँचता है कि क्या इनमें से कोई भी दो sum l/2अंतरों की सूची का एक तत्व है या नहीं यह जाँच कर अलग होता है (-)<$>c<*>c।

— XNOR
स्रोत

4

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

}sQmysd.:

इसे पायथ कंपाइलर में टेस्ट करें ।

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

       .:  Generate the list of all adjacent sublists.
   m       Map over the result:
     sd       Add the integers of the sublist.
    y         Double the sum.
 sQ        Compute the sum of the input.
}          Check if it belongs to the list of doubled sublist sums.

— डेनिस
स्रोत

4

दरअसल, 21 बाइट्स

;Σ@2*;lR@τ╗`╜V♂Σi`Míu

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

यह प्रोग्राम 0झूठे मामलों के लिए, और सच्चे मामलों के लिए एक सकारात्मक पूर्णांक प्रिंट करता है ।

स्पष्टीकरण:

;Σ@2*;lR@τ╗`╜V♂Σi`Míu
;Σ                     sum of copy of input
  @2*                  double values in other copy
     ;lR               copy, range(1, len(input)+1)
        @τ             append other copy to itself
          ╗            save in reg0
           `╜V♂Σi`M    map: generate cyclic cumulative sums
                   íu  1-based index of sum of input (0 if not found)

गैर-प्रतिस्पर्धी संस्करण, 10 बाइट्स

;Σ@2*σ;)-∩

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

यह प्रोग्राम झूठे मामलों के लिए एक खाली सूची और अन्यथा गैर-रिक्त सूची को आउटपुट करता है। यह अनिवार्य रूप से डेनिस के जेली उत्तर का एक बंदरगाह है । यह गैर-प्रतिस्पर्धात्मक है क्योंकि संचयी योग और वेक्टरकृत अंतर कार्यक्षमता चुनौती के बाद की तारीख है।

स्पष्टीकरण:

;Σ@2*σ;)-∩
;Σ          sum of copy of input
  @2*       multiply values in other copy by 2
     σ;     two copies of cumulative sum
       )-   subtract sum of input from each element in one copy
         ∩  set intersection with other copy

— मेगो
स्रोत

4

पायथन 2, 76 74 70 66 बाइट्स

def f(x):n=sum(x);print n in[2*sum(x[k/n:k%n])for k in range(n*n)]

4 8 बाइट्स से गोल्फिंग के लिए @xnor को धन्यवाद !

Ideone पर इसका परीक्षण करें । (बड़े परीक्षण के मामलों को छोड़कर)

— डेनिस
स्रोत

मुझे एहसास हुआ कि आप कर सकते n=sum(x)हैं n in ...; इसके लिए एक बड़े मूल्य का उपयोग करने के लिए दुख नहीं होता है n।

— xnor

ऊह, यह चतुर है। धन्यवाद!

— डेनिस

3

MATL , 10 बाइट्स

EYst!-Gs=z

आउटपुट बायसेक्टर्स की संख्या है।

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

व्याख्या

डेनिस जूलिया जवाब के रूप में एक ही दृष्टिकोण ।

E       % Implicit input. Multiply by 2 element-wise 
Ys      % Cumulative sum 
t!-     % Compute all pairwise differences. Gives a 2D array 
Gs      % Sum of input 
=       % Test for equality, element-wise 
z       % Number of nonzero elements. Implicit display

— लुइस मेंडो
स्रोत

3

माणिक, 60 53 बाइट्स

->a{a.any?{r=eval a*?+;a.rotate!.any?{|i|0==r-=2*i}}}

इनपुट सरणी के प्रत्येक घुमाव को ले कर सभी संभावित विभाजन उत्पन्न करता है और फिर लंबाई 1 के सभी स्लाइस ले रहा है । इनपुट सरणी का आकार nकहां nहै। फिर जांचता है कि क्या इनपुट ऐरे के कुल योग के साथ कोई विभाजन मौजूद है।

— Ventero
स्रोत

2

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

a=>a.map(_=>a.slice(--n).map(m=>s.push(t+=m),t=0),s=[],n=a.length)&&s.includes(t/2)

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

— नील
स्रोत

2

दिल्लोग एपीएल, 12 बाइट्स

+/∊2×+\∘.-+\

इसे TryAPL के साथ टेस्ट करें ।

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

+/∊2×+\∘.-+\  Monadic function train. Right argument: y (vector)

     +\   +\  Yield the cumulative sum of y.
       ∘.-    Compute all differences of all partial sums.
              This computes the sums of all adjacent subvectors of y that do not
              contain the first value, their negatives, and 0's in the diagonal.
   2×         Multiply all differences by 2.
+/            Yield the sum of y.
  ∊           Test for membership.

— डेनिस
स्रोत

2

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

k=t=1
for x in input():t<<=x;k|=t*t
print k&k/t

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

मैं २.75५ साल बाद अपने पुराने समाधान को २५% से अधिक करने के लिए एक नई विधि का उपयोग कर वापस आ रहा हूं ।

यह 1-बाइट लंबा संस्करण थोड़ा साफ है।

k=t=0
for x in input():t+=x;k|=4**t
print k&k>>t

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

विचार संचयी रकम के सेट tको बिट्स के रूप में संग्रहीत करना है k, 2*tयह इंगित करने के लिए कि tसंचयी योग है। फिर, हम जांचते हैं कि क्या कोई दो संचयी रकम इस सूची tको थोड़ा-थोड़ा करके (आधी) रकम से आधी (अंतिम ) अलग-अलग है kऔर &परिणाम देखने के लिए मूल के साथ बिटवाइज़ कर रही है, जो नॉनजेरो (सत्य) है।

— XNOR
स्रोत

1

एपीएल, 25 चरस

~~सूची में मान लिया गया है X ← 1 2 3 4।~~

(+/X)∊∘.{2×+/⍺↑⍵↓X,X}⍨⍳⍴X←⎕

स्पष्टीकरण:

पहले ध्यान दें कि एपीएल दाएं से बाएं के रूप का मूल्यांकन करता है। फिर:

X←⎕ उपयोगकर्ता इनपुट लेता है और इसे स्टोर करता है X
⍴X की लंबाई देता है X
⍳⍴X संख्या 1 से ⍴X
⍺और ⍵में {2×+/⍺↑⍵↓X,X}एक dyadic समारोह हम ब्रेसिज़ के अंदर परिभाषित कर रहे हैं करने के लिए छोड़ दिया और सही तर्क हैं।
- अब ⍺↑⍵↓X,Xभाग के लिए: X,Xसिर्फ एक्स को अपने साथ समेटना; ↑और ↓ले और ड्रॉप कर रहे हैं।
- +/कम कर देता है / +अपने अधिकार पर सूची में गुना
तो 2 {2×+/⍺↑⍵↓X,X} 1= 2×+/2↑1↓X,X= 2×+/2↑1↓1 2 3 4 1 2 3 4=

= 2×+/2↑2 3 4 1 2 3 4= 2×+/2 3= 2×5= 10।
∘.brace⍨idxबस है idx ∘.brace idx। ( ⍨विकर्ण नक्शा है; ∘.बाहरी उत्पाद है)

तो यह हमें एक देता ⍴Xद्वारा ⍴Xमैट्रिक्स सभी जुड़ा उप-सूचियों का दो बार रकम शामिल है।
```
 4  6  8  2
10 14 10  6
18 16 14 12
20 20 20 20
```
आखिरी बात हमें यह देखना है कि क्या Xइस मैट्रिक्स के अंदर कहीं का योग है।
जो हम साथ करते हैं (+/X)∊matrix।

— user2070206
स्रोत

1

ब्रेकीलॉग , 6 बाइट्स

sj+~+?

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

सफलता या विफलता के माध्यम से आउटपुट, मुद्रण true.या false.यदि प्रोग्राम के रूप में चलाया जाता है।

s         A contiguous sublist of the input
 j        with all of its items duplicated
  +       sums to
   ~+     the sum of the elements of
     ?    the input.

— असंबंधित स्ट्रिंग
स्रोत

1

सी, 161 145 129 बाइट्स

@LeakyNun की बदौलत कुछ बाइट्स बचाए गए
@ceilingcat की बदौलत कुछ बाइट्स बचाए गए

i;j;k;t;r;s;f(x,n)int*x;{for(t=i=k=r=0;i<n;)t+=x[i++];for(;++k<n;i=n)for(;i--;r|=2*s==t)for(s=0,j=i;j<i+k;)s+=x[j++%n];return r;}

अघोषित ऑनलाइन प्रयास करें

int f(int*x,int n)
{
    int t=0;

    for(int i=0;i<n;i++)
    {
        t += x[i];
    }

    for(int k=1;k<n;k++) // subset-size
    {
        for(int i=0,s;i<n;i++) // where to start
        {
            s=0;

            for(int j=i;j<i+k;j++) // sum the subset
            {
                s+=x[j%n];
            }

            if(2*s==t) return 1; // TRUE
        }
    }

    return 0; // FALSE
}

— Khaled.K
स्रोत

शायद आप पहले के स्तर तक चर की घोषणाओं से आगे बढ़, और बदलकर कुछ बाइट्स बचा सकते हैं i<n;i++करने के लिए i++<n(हालांकि आप कुछ ऑफसेट से निपटने के लिए आवश्यकता हो सकती है।

— लीकी नून

0

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

f l|x<-[0..length l]=any(sum l==)[2*(sum$take a$drop b l)|a<-x,b<-x]

फ़ंक्शन fपहले दिए गए सूची के सभी संभावित स्लाइस की रकम की एक सूची बनाता है। फिर यह सूची तत्वों की कुल राशि की तुलना करता है। अगर हमें कुल राशि के कुछ बिंदु आधे पर मिलते हैं, तो हम जानते हैं कि हमें एक लाभ मिल गया है। मैं इस तथ्य का भी उपयोग कर रहा हूं कि यदि आप takeया dropअधिक तत्व सूची में हैं, तो हास्केल त्रुटि नहीं करता है।

— flawr
स्रोत

0

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

!FreeQ[Outer[Plus,#,-#],Last@#/2]&@Accumulate@#&

बेनामी फ़ंक्शन, कई अन्य उत्तरों के लिए कार्रवाई के समान।

Outer[Plus, #, -#], जब अभिनय Accumulate@#(जो लगातार इनपुट सूची पर कार्य करता है, क्रमिक योगों की एक सूची देता है) अनिवार्य रूप से एक ही तालिका उत्पन्न करता है, जैसा कि लीकी नून के जवाब के तल पर है।

!FreeQ[..., Last@#/2]जांच करता है कि (Last@#)/2है नहीं जिसके परिणामस्वरूप तालिका से अनुपस्थित है, और Last@#यानी इनपुट सूची के सभी तत्वों का योग लगातार योग की पिछले है।

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

— LLlAMnYP
स्रोत

मुझे लगता है कि !FreeQ[2Tr/@Subsequences@#,Tr@#]&काम करना चाहिए, लेकिन मेरे पास अगले 10 दिनों तक परीक्षण करने के लिए 10.4 उपलब्ध नहीं होंगे।

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

@MartinEnder यह निश्चित रूप से ऐसा लगता है कि यह काम करेगा, लेकिन मैं 10.2 पर हूं, इसलिए मेरे पास यही है

— LLLAMnYP

0

एपीएल (एनएआरएस), चार्ट्स 95, बाइट्स 190

{1≥k←≢w←⍵:0⋄s←+/⍵⋄∨/{s=2×s-+/⍵}¨↑¨{⍵⊂w}¨{(k⍴2)⊤⍵}¨{1≥≢⍵:⍵⋄⍵,∇{(1+2×(↑⍵))×2*0..¯2+≢⍵}⍵}2*0..k-1}

4 तत्वों के इनपुट के एक सरणी पर विचार करें: 1 2 3 4. हम उस सेट के इस अभ्यास विभाजन के लिए उपयोगी कैसे चुन सकते हैं? कुछ लोग सोचते हैं कि इन 4 तत्वों के विभाजन का उपयोग हम बाईं ओर बाइनरी नंबर में कर सकते हैं:

0001,0010,0100,1000 2^(0..4) 1 2 4  8 
0011,0110,1100,                3 6 12
0111,1110,                       7 14
1111                               15

(1001 या 1011 ecc उस सेट में हो सकता है, लेकिन पहले से ही हमारे पास 0110 और 0100 ecc है) इसलिए एक टोपी सिर्फ एक फ़ंक्शन लिखने के लिए है कि इनपुट ऐरे के तत्व की संख्या से इन बाइनरी नंबर का निर्माण करें ... यह होगा:

c←{1≥≢⍵:⍵⋄⍵,∇{(1+2×(↑⍵))×2*0..¯2+≢⍵}⍵}

इनपुट 1 2 4 8 [2 ^ 0..lenBytesArgument-1] 3 6 12, 7 14, 15; इसलिए इन नंबरों के बाइनरी का पता लगाएं और उनका उपयोग करके इनपुट ऐरे के सही विभाजन का पता लगाएं ... मैंने केवल उस इनपुट 4 तत्वों के लिए c फ़ंक्शन का परीक्षण किया, लेकिन ऐसा लगता है कि यह अन्य तत्वों की संख्या के लिए ठीक है ...

परीक्षा:

  f←{1≥k←≢w←⍵:0⋄s←+/⍵⋄∨/{s=2×s-+/⍵}¨↑¨{⍵⊂w}¨{(k⍴2)⊤⍵}¨{1≥≢⍵:⍵⋄⍵,∇{(1+2×(↑⍵))×2*0..¯2+≢⍵}⍵}2*0..k-1}
  f¨(1 2 3 4)(6 6 12 12 12 11 1 12)(1000000 1000001 1)(1 2 3)(1 1)(42 42)
1 1 1 1 1 1 
  f¨(1 2 3 4 5)(2 1 3 4)(,10)(1000000 1000001)(,1)(1 2)(3 1 1)
0 0 0 0 0 0 0

— RosLuP
स्रोत

क्या मेरी पेशाब की बीमारी हो गई है?

अतिरिक्त उदाहरण

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

स्कोरिंग

जे, 18 बाइट्स

प्रयोग

Ungolfed

पिछला 23-बाइट संस्करण:

प्रयोग

Ungolfed

व्याख्या

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

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

जूलिया, 34 30 29 बाइट्स

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

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

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

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

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

दरअसल, 21 बाइट्स

गैर-प्रतिस्पर्धी संस्करण, 10 बाइट्स

पायथन 2, 76 74 70 66 बाइट्स

MATL , 10 बाइट्स

व्याख्या

माणिक, 60 53 बाइट्स

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

दिल्लोग एपीएल, 12 बाइट्स

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

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

एपीएल, 25 चरस

स्पष्टीकरण:

ब्रेकीलॉग , 6 बाइट्स

सी, 161 145 129 बाइट्स

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

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

एपीएल (एनएआरएस), चार्ट्स 95, बाइट्स 190