บทนำ

ฉันต้องการสร้างบันได สำหรับเรื่องนี้ฉันได้ไปจากที่เก็บขยะสองแผ่นยาวที่มีรูอยู่ในนั้นและฉันต้องการที่จะวางขั้นตอนลงในหลุมเหล่านี้ อย่างไรก็ตามหลุมไม่ได้ถูกวางอย่างเท่าเทียมกันดังนั้นขั้นตอนจะค่อนข้างสั่นคลอนเล็กน้อยและฉันพบว่ามันยากที่จะประเมินจำนวนก้านที่ฉันต้องการสำหรับพวกเขา งานของคุณคือการคำนวณสำหรับฉัน

อินพุต

อินพุตของคุณคือเวกเตอร์สองบิตที่กำหนดเป็นอาร์เรย์ของจำนวนเต็มซึ่งเป็นตัวแทนของสองบอร์ด A 0หมายถึงส่วนของหนึ่ง aud ( หน่วยระยะทางโดยพลการ ) โดยไม่มีรูและ a 1หมายถึงเซ็กเมนต์ของหนึ่ง aud ด้วยหนึ่งหลุม อาร์เรย์อาจมีความยาวแตกต่างกันและมีจำนวน1s แตกต่างกันแต่จะไม่ว่างเปล่า

ฉันจะสร้างบันไดของฉันดังนี้ ครั้งแรกฉันวางบอร์ดสองแผ่นแยกกันหนึ่งเสียงและจัดวางที่ปลายด้านซ้าย สำหรับแต่ละดัชนี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

J, 20 ไบต์

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

มันใช้เคล็ดลับในคำตอบของ MickyT ใน R

(<0 1)|:ให้เส้นทแยงมุมของเมทริกซ์ สำหรับคำอธิบายของส่วนอื่น ๆ ให้ดูคำตอบของ FUZxxl

J, 22 ตัวอักษร

ไม่ได้รับแรงบันดาลใจจากคำตอบของ randomra I.ส่วนหนึ่งเท่ากับว่าเป็นวิธีที่เห็นได้ชัดทันทีในการหาหลุม

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

• I. y- ดัชนีทั้งหมดของซ้ำได้บ่อยเท่าที่รายการที่สอดคล้องกันของy yอนึ่งถ้าyเป็นเวกเตอร์ของบูลี, I. yมีดัชนีที่เป็นy 1ยกตัวอย่างเช่นอัตราผลตอบแทนI. 1 0 0 1 1 1 0 0 10 3 4 5 8
• x u&v y- (v x) u (v y)เช่นเดียวกับ นำไปใช้เป็นที่เราได้รับx u&I. y (I. x) u (I. y)เรามาเปลี่ยนอินพุตต่อไป
• x <.&# y- เลสเบี้ยนของความยาวของและxy
• x -/@,: y- ความแตกต่างของรายการของและx yถ้าเวกเตอร์หนึ่งยาวกว่ามันจะถูกเติมด้วยศูนย์
• x $ y- รูปทรงรูปร่างที่กำหนดโดยy xโดยเฉพาะถ้าxเป็นสเกลา, องค์ประกอบที่นำมาจากx yในการใช้งานนี้x (<.&# $ -/@,:) yตรวจสอบให้แน่ใจว่าไม่มีการละเว้นรูต่อท้าย
• 4 o. y- ฟังก์ชัน%: 1 + *: yคือ sqrt (1 + y ²) ฟังก์ชั่นนี้จะจับคู่กับระยะทางจากรูถึงความยาวของแท่ง
• +/ y- yผลรวมขององค์ประกอบของ

Python, 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]))

นี้เปิดออกคล้ายกับวิธีการแก้ปัญหาของ Mac แปลงรายการของ 0 และ 1 เป็นรายการที่เรียงลำดับของดัชนีเดียวแล้วรวมระยะห่างระหว่างองค์ประกอบที่เกี่ยวข้อง

J, 32 28 ไบต์

คำกริยาI.ส่งคืนตำแหน่งของ1s ในสตริงไบนารีซึ่งเป็นความช่วยเหลือที่ยิ่งใหญ่

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

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

สำหรับการตรวจสอบการแก้ปัญหาที่ดีกว่า J คำตอบ FUZxxl ของ

R, 67

ใช้ภายนอกเพื่อสร้างความแตกต่างสำหรับหลุมที่จัดทำดัชนี Diag ส่งคืนความแตกต่างที่จำเป็น จากนั้นรวมระยะทางที่คำนวณ

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

ทดสอบการทำงานใน R Fiddle ฉันได้ห่อมันด้วยการพิมพ์เพื่อแสดงการส่งคืนที่สอดคล้องกับข้อมูลจำเพาะ

> 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
>

Haskell, 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]#

CJam, 36 33 ไบต์

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

วิธีการไร้เดียงสามาก ... มันคาดว่าอินพุตเป็นอาร์เรย์สไตล์ CJam บน STDIN

[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.";

Python, 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])

โซลูชัน recursive ระดับต่ำและไร้เดียงสาโดยไม่ต้องค้นหารายการใด ๆ

รายการป้อนข้อมูลเป็นและa หากทั้งสองเป็นที่ว่างเปล่ากลับb0

มิฉะนั้นให้xและyเป็นองค์ประกอบแรกของพวกเขา (รหัสไม่ได้กำหนดสิ่งเหล่านี้เพราะคุณไม่สามารถทำการมอบหมายใน a lambdaได้ แต่มันจะทำให้การอธิบายง่ายขึ้น) หากทั้งคู่เป็น 1 นั่นคือผลิตภัณฑ์ของพวกเขาคือ 1 ดังนั้นพวกเขาจึงมีส่วนร่วมในระยะห่างของก้าน เราติดตามระยะทางในจำนวนเชิงซ้อนiดังนั้นระยะทางนั้นคือค่าสัมบูรณ์ x*yอันที่จริงเราคำนวณโดยไม่คำนึงถึงมันแล้วคูณด้วย

จากนั้นเราจะเรียกคืน แนวคิดคือการเลื่อนทั้งสองรายการหนึ่งขั้นตอนเว้นแต่ว่าหนึ่งรายการเริ่มต้นด้วย 0 และอีกรายการหนึ่งในกรณีนี้เราจะเปลี่ยนเฉพาะรายการที่ 0 ด้วยวิธีนี้ 1 จะถูกใช้เป็นคู่เสมอ เราสามารถตรวจสอบเงื่อนไขเหล่านี้ด้วยx<yและแต่ก็สั้นเพื่อใช้ประโยชน์จากการเปรียบเทียบเป็นรายชื่อy<x สุดท้ายเราปรับรางที่ซับซ้อนระหว่างองค์ประกอบในปัจจุบันโดยa[:1]<=bx-y

Python, 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 สำหรับคำแนะนำในการประหยัด byte ปรากฎนี้สามารถแข็งแรงเล่นกอล์ฟต่อไปแสดงให้เห็นในคำตอบของ XNOR

Pyth, 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ไม่สามารถใช้ได้กับรายการที่ว่างเปล่า

Python ขนาด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

คลิป 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

ECMAScript 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

Java, 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;
}

JavaScript (ES6) 108

จุดหลักคือฟังก์ชั่น f ที่แม็พอินพุต 0..1 ในอาร์เรย์ของตำแหน่งรู จากนั้นอาร์เรย์จะถูกสแกนคำนวณความยาวแท่งทั้งหมดโดยใช้ทฤษฎีบทพีทาโกรัส |0ใกล้ถึงจุดสิ้นสุดเป็นสิ่งจำเป็นเพื่อแปลงแก่นแก้วที่สามารถทำให้เกิดเมื่ออาร์เรย์ไดรเวอร์ (ครั้งแรก) เป็นเวลานานกว่าสอง

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

ทดสอบในคอนโซล Firefox / FireBug

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

คู่, 60 59 42

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

Perl 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

APL, 35 28 ไบต์

ใช้อัลกอริทึมที่คล้ายกันกับโซลูชัน J แต่ APL มีบิวด์อินน้อยกว่า

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

อินพุตตัวอย่าง:

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