एक सीढ़ी का निर्माण करें

Question

परिचय

मैं एक सीढ़ी बनाना चाहता हूं। इसके लिए, मैंने कबाड़ के दो लंबे बोर्डों से उनमें छेद के साथ मैला ढोया है, और मैं इन छेदों पर कदम रखना चाहता हूं। हालांकि, छेद समान रूप से नहीं रखे गए हैं, इसलिए चरण थोड़ा विजयी होंगे, और मुझे उनके लिए छड़ी की मात्रा का अनुमान लगाना कठिन है। आपका काम मेरे लिए गणना करना है।

इनपुट

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

मैं अपनी सीढ़ी का निर्माण इस प्रकार करूंगा। सबसे पहले, मैं दो बोर्डों को एक ऑड के अलावा अलग करता हूं, और उनके बाएं छोर को संरेखित करता हूं। प्रत्येक सूचकांक के लिए i, मैं iपहले बोर्ड के वें छेद के बीच की दूरी iको दूसरे बोर्ड के वें छेद के साथ मापता हूं , रॉड के एक टुकड़े को काटता हूं , और इसे दो छेदों के बीच संलग्न करता हूं । एक बार जब मैं किसी एक बोर्ड में छेद से बाहर निकलता हूं तो रुक जाता हूं।

उत्पादन

आपका आउटपुट रॉड की कुल मात्रा है जिसे मुझे स्टड के लिए आवश्यकता होगी, जिसे आउड्स में मापा गया है। आउटपुट कम से कम छह महत्वपूर्ण अंकों के लिए सही होना चाहिए।

उदाहरण

इनपुट पर विचार करें [0,1,1,0,1,1,1,1,0,0]और [1,0,0,1,1,1,0,0,1]। परिणामी सीढ़ी इस तरह दिखती है:

इस सीढ़ी में छड़ की कुल लंबाई 7.06449510224598औड्स है।

नियम

आप एक फ़ंक्शन या पूर्ण प्रोग्राम लिख सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

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

[0] [0] -> 0.0
[0] [1,0] -> 0.0
[1,0,0] [1,1,1,1,1] -> 1.0
[0,1,0,1] [1,0,0,1] -> 2.414213562373095
[0,1,1,0,1,1,1,1,0,0] [1,0,0,1,1,1,0,0,1] -> 7.06449510224598
[1,1,1,1,1] [0,0,1,1,0,1,0,0,1] -> 12.733433128760744
[0,0,0,1,0,1,1,0,0,0,1,1,1,0,0,1,0,1,1,0,0,0,1,0] [0,0,1,1,0,1,1,1,0,0,0,0,0,1,1,0,1,1,0,0,0,1] -> 20.38177416534678

Comments

अपनी सुरक्षा के लिए, मैं वास्तव में किसी भी सीढ़ी पर चढ़ने की सलाह नहीं देता जो उस तरह दिखता है।

— एलेक्स ए।

Answer 1

जे, 20 बाइट्स

4+/@:o.(<0 1)|:-/&I.

यह R में मिकी के जवाब में चाल का उपयोग करता है ।

(<0 1)|:मैट्रिक्स का विकर्ण देता है। अन्य भागों की व्याख्या के लिए, फूज़ेक्नल का उत्तर देखें ।

Comments

साफ। मैं हार मानता हूं।

— फ़ूजएक्सएक्सएल

Answer 2

जे, 22 अक्षर

रैंडम के जवाब से प्रेरित नहीं। I.के रूप में है कि छेद खोजने के तुरंत स्पष्ट तरीका है भाग के बराबर है।

(4+/@:o.<.&#$-/@,:)&I.

• I. y- के सभी yआइटम के रूप में अक्सर के रूप में इसी के दोहराया दोहराया y। संयोग से, अगर yबूलियन्स का एक वेक्टर है, I. yसूचकांक, जिस पर शामिल yहै 1। उदाहरण के लिए, I. 1 0 0 1 1 1 0 0 1पैदावार 0 3 4 5 8।
• x u&v y- समान (v x) u (v y)। के रूप में लागू x u&I. y, हम प्राप्त करते हैं (I. x) u (I. y)। चलो परिवर्तित इनपुट के साथ जारी रखें।
• x <.&# y- की लंबाई कम xऔर y।
• x -/@,: y- की वस्तुओं के अंतर xऔर y। यदि एक वेक्टर अधिक लंबा है, तो यह शून्य से गद्देदार है।
• x $ y- yद्वारा निर्दिष्ट आकार में फेरबदल x। विशेष रूप से, यदि xएक अदिश राशि है, तो xतत्वों से लिया जाता है y। इस उपयोग में, x (<.&# $ -/@,:) yसुनिश्चित करता है कि अनुगामी छिद्रों को अनदेखा किया गया है।
• 4 o. y- फ़ंक्शन %: 1 + *: y, अर्थात्, sqrt (1 + y is )। संयोग से, यह फ़ंक्शन छेद की दूरी से छड़ की लंबाई तक मैप करता है।
• +/ y- के तत्वों का योग y।

Answer 3

पायथन, 85

lambda*A:sum(abs(x-y+1j)for x,y in zip(*[[i for i,x in enumerate(l)if x]for l in A]))

यह मैक के समाधान के समान निकला । एक-सूचकांकों की आदेशित सूचियों के लिए 0 और 1 की सूचियों को परिवर्तित करें, और फिर संबंधित तत्वों के बीच की दूरी का योग करें।

Comments

अच्छी तरह से किया। जटिल शाब्दिक के साथ अच्छी चाल!

— मैक

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

— xnor

Answer 4

जे, 32 28 बाइट्स

क्रिया एक बाइनरी स्ट्रिंग में एस I.की स्थिति लौटाती है 1जो एक बड़ी मदद है।

   +/@,@(=/&(#\)*[:>:&.*:-/)&I.

   0 1 0 1 (+/@,@(=/&(#\)*[:>:&.*:-/)&I.) 1 0 0 1
2.41421

बेहतर J समाधान के लिए FUZxxl के उत्तर की जांच करें ।

Answer 5

आर, 67

अनुक्रमित छिद्रों के लिए एक अंतर करने के लिए बाहरी का उपयोग करता है। डायग ने आवश्यक अंतर लौटाया। फिर गणना की गई दूरियों का योग करें

function(a,b)sum((diag(outer(which(a==1),which(b==1),"-"))^2+1)^.5)

आर फिडल में टेस्ट रन । मैंने इसे एक प्रिंट में लपेटा है ताकि रिटर्न का नमूना कल्पना के साथ दिखाया जा सके।

> print((function(a,b)sum((diag(outer(which(a==1),which(b==1),"-"))^2+1)^.5))(c(0,1,1,0,1,1,1,1,0,0),c(1,0,0,1,1,1,0,0,1)),digits=10)
[1] 7.064495102
> print((function(a,b)sum((diag(outer(which(a==1),which(b==1),"-"))^2+1)^.5))(c(1,1,1,1,1),c(0,0,1,1,0,1,0,0,1)),digits=10)
[1] 12.73343313
>

Comments

अच्छा है। a==1हो सकता है a>0या !!a।

— मुक्तकव

Answer 6

हास्केल, 77 73 बाइट्स

r x=[a|(a,1)<-zip[1..]x]
i#j=sum$zipWith(\n m->sqrt((n-m)**2+1))(r i)$r j

उपयोग: [0,1,0,1] # [1,0,0,1]जो आउटपुट2.414213562373095

यह कैसे काम करता है: फ़ंक्शन rएक बोर्ड के छेदों की स्थिति की सूची देता है, जैसे r [0,1,0,1]-> [2,4]। #उन सूचियों में से दो ज़िप करता है और संबंधित छेद के बीच की दूरी की सूची में बदल जाता है और अंत में इसे जमा करता है।

Answer 7

CJam, 36 33 बाइट्स

l~]{:L,{L=},}%z{,(},0\{~-_*)mq+}/

बहुत भोली दृष्टिकोण ... यह इनपुट को STDIN पर CJam- शैली सरणियों के रूप में उम्मीद करता है

[0 1 1 0 1 1 1 1 0 0] [1 0 0 1 1 1 0 0 1]

यहां सभी उदाहरण इनपुट के लिए एक परीक्षण हार्नेस है। इनपुट फ़ील्ड में परिणाम वास्तविक कोड कहे जाने से पहले उपयोग किए जाते हैं। यदि आप मुझ पर भरोसा नहीं करते हैं तो आप उन्हें हटा सकते हैं। ;)

व्याख्या

l~]                               "Read and eval input, wrap in an array.";
   {        }%                    "Map this block onto both input arrays.";
    :L,                           "Store array in L, get its length N.";
       {L=},                      "In the range [0 .. N-1] get all elements where L is 1.";
                                  "At this point we've converted each array into a list of its
                                   non-zero indices.";
              z                   "Transpose the array, pairing up indices at the same position.";
               {,(},              "Filter the extraneous elements of the longer input.";
                    0\            "Put a 0 before the array.";
                      {        }/ "For each pair of holes...";
                       ~-         "Unwrap the pair, take the difference.";
                         _*)mq    "Square, increment, square root.";
                              +   "Add to the running total.";

Answer 8

अजगर, 86

f=lambda a,b,i=1j:a>[]<b and a[0]*b[0]*abs(i)+f(a[a[:1]<=b:],b[b[:1]<=a:],i+a[0]-b[0])

किसी भी सूची की खोज के बिना एक निम्न-स्तरीय और भोली पुनरावर्ती समाधान।

इनपुट सूची नहीं है aऔर b। यदि या तो खाली है, तो वापस लौटें 0।

अन्यथा, आइए xऔर yउनके पहले तत्व बनें (कोड वास्तव में इन्हें असाइन नहीं करता है क्योंकि आप असाइनमेंट नहीं कर सकते हैं lambda, लेकिन यह आसान समझा जाएगा)। यदि दोनों 1 हैं, अर्थात उनका उत्पाद 1 है, तो वे रॉड दूरी का योगदान करते हैं। हम जटिल संख्या में दूरी का ट्रैक रखते हैं i, ताकि दूरी निरपेक्ष मूल्य हो। वास्तव में, हम इसकी परवाह किए बिना गणना करते हैं, फिर इसे गुणा करते हैं x*y।

फिर, हम पुनरावृत्ति करते हैं। विचार यह है कि दोनों सूचियों को एक चरण में स्थानांतरित किया जाए, जब तक कि एक सूची 0 से शुरू नहीं होती है और दूसरी एक के साथ शुरू होती है, जिस स्थिति में हम केवल 0 सूची को स्थानांतरित करते हैं। इस तरह, 1 हमेशा जोड़े में खपत होती है। हम इन शर्तों की जाँच कर सकते हैं x<yऔर y<x, लेकिन यह तुलनात्मक रूप से सूची का लाभ उठाने के लिए कम है a[:1]<=b। अंत में, हम वर्तमान तत्वों के बीच जटिल विस्थापन को समायोजित करते हैं x-y।

Comments

चूंकि आप परेशान हैं कि यह आपके अन्य समाधान से 1 बाइट अधिक था, मुझे बाइट को बचाने का एक तरीका मिला। बदलें a>[]<bकरने के लिए a>0<b। यह दोनों काम करता है []और 0झूठा है, इसलिए वे बराबर हैं।

— mbomb007

इसके अलावा, क्या है a:?

— mbomb007

@ mbomb007। क्या आपने कोई परीक्षण किया? ([] > []) != ([] > 0)Python2 में : और python3 में यह एक त्रुटि है (अनियंत्रित प्रकार)।

— इखुमोरो

@ mbomb007। a:टुकड़ा का हिस्सा है [b[:1]<=a:]।

— इखुमोरो

Answer 9

पायथन, 105 102 100 बाइट्स

i=lambda l:(i for i,h in enumerate(l)if h)
l=lambda*a:sum(((a-b)**2+1)**.5for a,b in zip(*map(i,a)))

सुंदर बुनियादी, बस इनपुट सूचियों को छेद सूचकांकों की सूचियों में परिवर्तित करता है, फिर ऐसे सूचकांकों के प्रत्येक जोड़े के बीच दूरी की गणना करता है।

परीक्षण का मामला:

>>> print l([0,1,1,0,1,1,1,1,0,0], [1,0,0,1,1,1,0,0,1])
7.06449510225

बाइट-बचत सुझावों के एक जोड़े के लिए @FryAmTheEggman को क्रेडिट। पता चलता है कि इसे आगे बढ़ाया जा सकता है, जैसा कि xnor के जवाब में दिखाया गया है ।

Comments

आप रिक्त स्थान को बाद में निकाल सकते हैं enumerate(l)और 0.5(जो बस हो सकता है। 5)।

— FryAmTheEggman

@FryAmTheEggman: बिल्कुल सही है, धन्यवाद! सुझाव के अनुसार बदला गया।

— मैक

तारांकित असाइनमेंट का उपयोग करके एक और चीज़ मिली:l=lambda*a:sum(((a-b)**2+1)**.5for a,b in zip(*map(i,a)))

— FryAmTheEggman

@FryAmTheEggman: फिर से धन्यवाद! दुर्भाग्य से ऐसा लगता है कि xnor एक बेहतर हो गया है - बहुत ही, लेकिन पहले लैंबडा के साथ दूसरे में सूची बोध के रूप में लुढ़का ...

— मैक

Answer 10

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

s+0m^h^-hded2 .5CmfTm*hb@kblkQ

इनपुट के साथ इसे ऑनलाइन आज़माएं [0,1,1,0,1,1,1,1,0,0], [1,0,0,1,1,1,0,0,1]।

स्पष्टीकरण:

मैं सूचकांकों की सूचियों में सूचियों कन्वर्ट [2, 3, 5, 6, 7, 8]और [1, 4, 5, 6, 9]और उन्हें एक साथ ज़िप [(2,1), (3,4), (5,5), (6,6), (7,9)]। तब मैं मूल्यों को घटाता हूं, उन्हें वर्ग करता हूं, 1 जोड़ता हूं और सभी वर्गमूलों पर योग करता हूं।

CmfTm*hb@kblkQ
 m           Q     map each list k in input() to the following list:
    m      lk         map each value b of [0, 1, 2, ..., len(k)-1] to the value:
     *hb@kb              (b + 1) * k[b]
  fT                  filter the list for positive values
C                  zip these two resulting lists

s+0m^h^-hded2 .5...
   m            ...  map each pair of values d to: 
    ^h^-hded2 .5         ((d[0] - d[1])^2 + 1)^0.5
 +0                  insert 0 at the front of the list
s                    sum

शर्म sumआती है कि खाली सूचियों के लिए काम नहीं करता है।

Answer 11

अजगर, 116 115 बाइट्स

यह एक पुनरावर्ती समाधान है।

यह बहुत कष्टप्रद हो गया जब मैंने पाया कि index()कोई त्रुटि तब मिलती है जब कोई मूल्य नहीं मिलता है, लेकिन मैंने इसे काम किया। दुर्भाग्य से, मैं एक मेमने का उपयोग नहीं कर सकता। इसने मुझे नाराज कर दिया कि मैं list.remove()सूची वापस नहीं करता, बल्कि बदले में देता हूं None।

def f(x,y,r=0):
    try:i,j=x.index(1),y.index(1)
    except:return r
    x.pop(i);y.pop(j);return f(x,y,r+((i-j)**2+1)**.5)

यहां ऑनलाइन चलाएं: http://repl.it/c5L/2

Comments

टैब के साथ भी, वह कोड 116 बाइट्स है, न कि 112.

— ekhumoro

आह, newlines याद किया, धन्यवाद।

— mbomb007

Answer 12

क्लिप 3 , 55 47 38

[cr+`j[v[w#)#mvw2B}}(c)c]sl`{%ky1%kx1`

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

>java -jar Clip3.jar ladder.clip
{0,1,1,0,1,1,1,1,0,0}
{1,0,0,1,1,1,0,0,1}
7.064495102245980096000721459859050810337066650390625

व्याख्या

[c          .- Assign c to the lists, in order of size    -.
  r+`       .- The sum of...                              -.
   j[v[w    .- Join the lists with a function on v, w     -.
     #      .- Square root                                -.
      )     .- 1 plus                                     -.
       #    .- The square of                              -.
        mvw .- The distance between v and w               -.
       2
     B      .- (one-half, so #...B means square root)     -.
   }}(c)c   .- Apply joining function to the lists        -.
  ]sl`{     .- c is the (sorted by size) list of...       -.
    %ky1    .- Indices of y (the second input) which are 1-.
    %kx1    .- Indices of x (the first input) which are 1 -.
  `

यदि हम इनपुट प्रारूप के बारे में बहुत उदार हैं, तो हम प्रत्येक को हटाकर इसे 36 बाइट्स तक कम कर सकते हैं k। इसके लिए इनपुट की आवश्यकता होती है जो नियंत्रण वर्ण वर्णों की एक स्ट्रिंग हो \0और \1।

Answer 13

ईसीएमएस्क्रिप्ट 6, 86 बाइट्स

यह मूल रूप से कम का उपयोग करके शुरू हुआ (मैं यह देखना चाहता था कि क्या यह @ edc65 उत्तर के विपरीत एक लूप में किया जा सकता है)।

f=(c,b,a=[0,...c],j)=>a.reduce((c,v,i)=>c+=v&&(j=b.indexOf(1,j)+1,v=i-j,j)?Math.sqrt(1+v*v):0)

लेकिन @ edc65 का उपयोग करने mapऔर &&tमूल्य को वापस करने के लिए मैं इसे बहुत कम करने में सक्षम था।

f=(a,b,j,c=0)=>a.map((v,i)=>c+=v&&(j=b.indexOf(1,j)+1,v=i+1-j,j)&&Math.sqrt(1+v*v))&&c

f=(a,b,j,c=0)        //variables note the j can be undefined
=>a.map((v,i)=>      //loop through the first array
c+=                  //add 
v&&                  //test to see if we have a hole
(j=b.indexOf(1,j)+1, //if so see if there is a whole on the other board
v=i+1-j,             //calculate index difference
j)                   //the last var gets evaluated so check to see if indexOf returned -1
&&Math.sqrt(1+v*v))  //calculate 
&&c                  //return sum

Comments

मुझे अभी भी एक मामले को खोजना है जब उपयोगकर्ता प्रबंधित संचायक के साथ बीट्स मैप को कम करता है।

— edc65

@ edc65 शायद सच है, reduceशब्दार्थ को अधिक स्पष्ट करता है, लेकिन इसके अलावा यह वास्तव में उपयोग करने के लिए अजीब है। बेशक, कब से कोड गोल्फरों ने शब्दार्थ के बारे में चिंता की।

— qw3n

Answer 14

जावा, 151

यह बस aलोगों की तलाश में साथ चलता है, फिर साथ चलता है bजब यह एक को पाता है। यदि floatसटीकता स्वीकार्य है, तो मैं एक युगल बाइट्स बचा सकता हूं, लेकिन मैं doubleपरीक्षण आउटपुट से मेल खाता था।

double d(int[]a,int[]b){double z=0;for(int x=-1,y=0,d=b.length;x++<a.length&y<d;z+=a[x]>0?Math.sqrt((y-x)*(y++-x)+1):0)for(;y<d&&b[y]<1;y++);return z;}

व्हॉट्सएप के साथ:

double d(int[]a,int[]b){
    double z=0;
    for(int x=-1,y=0,d=b.length;
            x++<a.length&y<d;
            z+=a[x]>0?Math.sqrt((y-x)*(y++-x)+1):0)
        for(;y<d&&b[y]<1;y++);
    return z;
}

Comments

छह महत्वपूर्ण अंक पर्याप्त सटीकता है, इसलिए यह फ्लोट आपको देता है कि, इसके लिए जाएं।

— झगरब

@Zgarb अधिकांश इनपुट पर बार-बार जोड़ मुझे केवल 4-5 अंक सबसे ऊपर देते हैं, इसलिए मैं अधिक सटीक संस्करण पर टिकूंगा। हालांकि, स्पष्टीकरण के लिए शुक्रिया।

— Geobits

Answer 15

जावास्क्रिप्ट (ईएस 6) 108

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

F=(a,b,f=a=>a.map(v=>++u*v,u=0).filter(x=>x))=>
  f(a,b=f(b)).map((v,i)=>t+=Math.sqrt((w=b[i]-v)*w+1|0),t=0)&&t

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

;[[[0],[0]]
 ,[[0],[1,0]]
 ,[[1,0,0],[1,1,1,1,1]]
 ,[[0,1,0,1],[1,0,0,1]]
 ,[[0,1,1,0,1,1,1,1,0,0],[1,0,0,1,1,1,0,0,1]]
 ,[[1,1,1,1,1],[0,0,1,1,0,1,0,0,1]]
 ,[[0,0,0,1,0,1,1,0,0,0,1,1,1,0,0,1,0,1,1,0,0,0,1,0],[0,0,1,1,0,1,1,1,0,0,0,0,0,1,1,0,1,1,0,0,0,1]]]
.forEach(v=>console.log('['+v[0]+']','['+v[1]+']',F(...v)))

[०] [०] ०
[०]
[१०२] ० [१०,०] [११,१,१,१,१] १
[०,१,०,१] [१०,० , 1] 2.414213562373095
[0,1,1,0,1,1,1,1,0,0] [1,0,0,1,1,1,0,0,1] 7.06449510224598
[1,1 1,1,1] [0,0,1,1,0,1,0,0,1] 12.733433128760744
[0,0,0,1,0,1,1,0,0,0,1,1 , 1,0,0,1,0,1,1,0,0,0,1,0] [0,0,1,1,0,1,1,1,0,0,0,0, 0,1,1,0,1,1,0,0,0,1] 20.38177416534678

Answer 16

ऑक्टेव, 60 59 42

@(a,b)trace(sqrt((find(a)'-find(b)).^2+1))

Answer 17

पर्ल 98

sub l{$r=0;@a=grep$a->[$_],0..$#$a;@b=grep$b->[$_],0..$#$b;$r+=sqrt 1+(shift(@a)-shift@b)**2 while@a&&@b;$r}

पठनीय:

sub l {
    $r = 0;
    @a = grep $a->[$_], 0 .. $#$a;
    @b = grep $b->[$_], 0 .. $#$b;
    $r += sqrt 1 + (shift(@a) - shift @b) ** 2 while @a && @b;
    $r
}

परिक्षण:

use Test::More;
for (<DATA>) {
    my ($A, $B, $r) = /\[ ([0-9,]+) \] \s \[ ([0-9,]+) \] \s -> \s ([0-9.]+) /x;
    $a = [split /,/, $A];
    $b = [split /,/, $B];
    cmp_ok l(), '==', $r, "test $_";
}
done_testing($.);
__DATA__
[0] [0] -> 0.0
[0] [1,0] -> 0.0
[1,0,0] [1,1,1,1,1] -> 1.0
[0,1,0,1] [1,0,0,1] -> 2.414213562373095
[0,1,1,0,1,1,1,1,0,0] [1,0,0,1,1,1,0,0,1] -> 7.06449510224598
[1,1,1,1,1] [0,0,1,1,0,1,0,0,1] -> 12.733433128760744
[0,0,0,1,0,1,1,0,0,0,1,1,1,0,0,1,0,1,1,0,0,0,1,0] [0,0,1,1,0,1,1,1,0,0,0,0,0,1,1,0,1,1,0,0,0,1] -> 20.38177416534678

Answer 18

एपीएल, 35 28 बाइट्स

जे समाधान के लिए एक समान एल्गोरिथ्म का उपयोग करता है, लेकिन एपीएल के पास कम निर्मित हैं।

{+/4○⊃-/{⍵⍴¨⍨⌊/⍴¨⍵}⍵/¨⍳¨⍴¨⍵}

उदाहरण इनपुट:

      {+/4○⊃-/{⍵⍴¨⍨⌊/⍴¨⍵}⍵/¨⍳¨⍴¨⍵}(1 0 0 1)(0 1 0 1)
2.414213562