মই গাঁথুন

Question

ভূমিকা

আমি একটি সিঁড়ি বানাতে চাই এর জন্য, আমি জঙ্কিয়ার্ড থেকে দুটি দীর্ঘ বোর্ড ফাঁকা করে ফেলা করেছি যার মধ্যে গর্ত রয়েছে এবং আমি এই গর্তগুলিতে পদক্ষেপগুলি রাখতে চাই। যাইহোক, গর্তগুলি সমানভাবে স্থাপন করা হয় নি, তাই পদক্ষেপগুলি কিছুটা উইঙ্কি হবে এবং তাদের জন্য আমার প্রয়োজনীয় রডের পরিমাণ নির্ধারণ করা আমার পক্ষে কঠিন। আপনার কাজটি আমার জন্য গণনা করা।

ইনপুট

আপনার ইনপুটটি দুটি বিট ভেক্টর, পূর্ণসংখ্যার অ্যারে হিসাবে দেওয়া হয়, যা দুটি বোর্ডকে উপস্থাপন করে। এ কোনও গর্ত ছাড়াই একটি 0অডি ( একটি দূরত্বের স্বেচ্ছাসেবী ইউনিট ) এর 1একটি অংশকে উপস্থাপন করে এবং একটি একক ছিদ্রযুক্ত একটি অডের একটি বিভাগকে উপস্থাপন করে। অ্যারেগুলি বিভিন্ন দৈর্ঘ্যের হতে পারে এবং এতে বিভিন্ন সংখ্যক 1গুলি থাকতে পারে তবে সেগুলি খালি থাকবে না।

আমি নীচে আমার সিঁড়ি নির্মাণ করব। প্রথমে, আমি দুটি বোর্ড ঠিক এক অডি আলাদা করে রেখেছি এবং তাদের বাম প্রান্তগুলি সারিবদ্ধ করছি। প্রতিটি সূচকের জন্য i, আমি দ্বিতীয় বোর্ডের th গর্ত iদিয়ে প্রথম বোর্ডের th গর্তের মধ্যবর্তী দূরত্ব পরিমাপ করি i, একটি টুকরো টুকরো কেটে দুটি গর্তের মধ্যে সংযুক্ত করি। আমি বোর্ডগুলির কোনও একটিতে ছিদ্র হয়ে যাওয়ার পরে আমি থামি।

আউটপুট

আপনার আউটপুটটি মোট I'll কমপক্ষে ছয়টি উল্লেখযোগ্য অঙ্কের আউটপুট সঠিক হওয়া উচিত।

উদাহরণ

ইনপুট [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.

এটি রিকিতে মিকিটির উত্তরের কৌশলটি ব্যবহার করে ।

(<0 1)|:একটি ম্যাট্রিক্সের তির্যক দেয়। অন্যান্য অংশের ব্যাখ্যার জন্য, FUZxxl এর উত্তর দেখুন ।

Comments

ঝরঝরে। আমি পরাজয় স্বীকার।

— FUZxxl

Answer 2

জে, 22 টি অক্ষর

র্যান্ডম্রা উত্তর দ্বারা অনুপ্রাণিত না। I.যেমন যে গর্ত খুঁজে বের করার অবিলম্বে সুস্পষ্ট উপায় অংশ সমান।

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

• I. y- সমস্ত সূচকগুলি yএকই আইটেম হিসাবে প্রায়শই পুনরাবৃত্তি হয় y। উল্লেখ্য, যদি yBooleans থেকে একটি ভেক্টর হয়, 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, অর্থাৎ স্কয়ার্ট (1 + y ²)। ঘটনাচক্রে, এই ফাংশনটি গর্তের দূরত্ব থেকে রডগুলির দৈর্ঘ্য পর্যন্ত ম্যাপ করে।
• +/ 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 বাইট

ক্রিয়াটি বাইনারি স্ট্রিংয়ে s এর I.অবস্থানগুলি ফিরিয়ে দেয় 1যা একটি বিশাল সহায়তা।

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

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

আরও ভাল জে সমাধানের জন্য 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।

— freekvd

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]। #lists তালিকাগুলির মধ্যে দুটি জিপ করে এবং এটিকে সংশ্লিষ্ট গর্তগুলির মধ্যে দূরত্বের তালিকায় পরিণত করে এবং শেষ পর্যন্ত এটির যোগফল করে।

Answer 7

সিজেম, 36 33 বাইট

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

খুব নিখুঁত পদ্ধতির ... এটি এসটিডিআইএন-এ সিজেম-স্টাইলের অ্যারে হিসাবে ইনপুটটি প্রত্যাশা করে

[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। আপনি কোন পরীক্ষা করেছেন? পাইথন 2: ([] > []) != ([] > 0)এবং পাইথন 3 এ এটি একটি ত্রুটি (অকেজো টাইপ)।

— এখুমোরো

@ 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

বাইট-সেভ করার কয়েকটি পরামর্শের জন্য @ ফ্রাইআমএইজিগম্যানকে ক্রেডিট করুন। যেমন প্রদর্শিত এই সক্রিয় আউট, আরও golfed যাবে xnor এর উত্তর ।

Comments

আপনি পরে enumerate(l)এবং স্পেসগুলি সরিয়ে ফেলতে পারেন 0.5(যা কেবল .5 হতে পারে)।

— FryAmTheEggman

@ ফ্রাইআম দ্য এজিগম্যান: একেবারে ঠিক, ধন্যবাদ! প্রস্তাবিত হিসাবে পরিবর্তন করা হয়েছে।

— ম্যাক 1

তারাযুক্ত অ্যাসাইনমেন্টটি ব্যবহার করে অন্য একটি জিনিস খুঁজে l=lambda*a:sum(((a-b)**2+1)**.5for a,b in zip(*map(i,a)))

— পেয়েছে

@ ফ্রাইআম দ্য এজিগম্যান: আবারও ধন্যবাদ! দুর্ভাগ্যক্রমে মনে হচ্ছে এটি আরও ভাল হয়ে গেছে - অনেকটা একই, তবে প্রথম ল্যাম্বদাটি দ্বিতীয় তালিকাতে পরিণত হয়েছে তালিকা বোঝার জন্য ...

— ম্যাক

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]এবং তাদের একসঙ্গে zip [(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

আহ, নতুন লাইন মিস করেছেন, ধন্যবাদ।

— 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

ECMAScript 6, 86 বাইট

এটি মূলত হ্রাস ব্যবহার করে শুরু হয়েছিল (আমি দেখতে চেয়েছিলাম এটি @ এডসি 65 উত্তরের বিপরীতে এটি একটি লুপে করা যায় কিনা)।

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 ডিজিটের শীর্ষগুলি দেয়, তাই আমি আরও সঠিক সংস্করণে আটকে থাকব। যদিও স্পষ্টতার জন্য ধন্যবাদ।

— জিওবিটস

Answer 15

জাভাস্ক্রিপ্ট (ES6) 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)))

[0] [0] 0
[0] [1,0] 0
[1,0,0] [1,1,1,1,1] 1
[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, 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