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

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

การส่งออกของคุณจะเป็นดิสก์ในรูปแบบของสามตัวเลขX, และY ,, และเป็นจำนวนเต็มทั้งหมดและแทนจุดศูนย์กลางของดิสก์และแสดงถึงรัศมี ระยะห่างระหว่างจุดที่กำหนดทุกจุดและจุดศูนย์กลางจะต้องน้อยกว่าหรือเท่ากับและจะต้องไม่มีดิสก์ดังกล่าวที่มีขนาดเล็กลงซึ่งเป็นไปตามเงื่อนไขนี้RXYRXYRRR

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

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

กรณีทดสอบ

Input   (Possible) Output(s)
(x,y)   (X,Y,R)
-------------------------
(0,0)   (0,0,0)
-------------------------
(0,1)   (0,0,1)
(1,0)   (1,1,1)
-------------------------
(1,4)   (4,4,3)
(3,2)
(4,1)
(4,5)
(5,2)
(7,4)
-------------------------
(-1,0)  (0,0,2)
(2,0)   (1,0,2)
-------------------------
(-1,0)  (1,0,2)
(2,1)   (0,1,2)
-------------------------
(0,0)   (1,0,1)
(1,1)   (0,1,1)

ไบต์ที่น้อยที่สุดจะเป็นผู้ชนะ

เยลลี่ , 25 24 22 21 20 18 ไบต์

«/r»/Œpµ³_²§½ṀĊ,)Ṃ

ขอบคุณ @EriktheOutgolfer ที่บอกให้ฉันรู้)ประหยัด 1 ไบต์

ขอบคุณ @Dennis สำหรับการบันทึก 2 ไบต์

ลองออนไลน์!

คำอธิบาย

«/r»/Œpµ³_²§½ṀĊ,)Ṃ      Main link. Arg: points
                        e.g. [[1,4],[3,2],[3,1]]
«/                      Find minimums by coordinate
                        e.g. [1,1]
   »/                   Find maximums by coordinate
                        e.g. [3,4]
  r                     Inclusive ranges by coordinate
                        e.g. [[1,2,3],[1,2,3,4]]
     Œp                 Cartesian product of the x and y ranges
                        e.g. [[1,1],[1,2],[1,3],[1,4],...,[3,4]]
       µ                    Chain, arg: center
                            e.g. [1,3]
        ³                   Get the original points
                            e.g. [[1,4],[3,2],[3,1]]
         _                  Subtract the center from each
                            e.g. [[0,1],[2,-1],[2,-2]]
          ²                 Square each number
                            e.g. [[0,1],[4,1],[4,4]]
           §                Sum each sublist
                            e.g. [1,5,8]
            ½               Square root of each number
                            e.g. [1,2.24,2.83]
             Ṁ              Find the maximum
                            e.g. 2.83
              Ċ             Round up
                            e.g. 3
               ,            Pair with the center point
                            e.g. [3,[1,3]]
                )       Do the above for all points
                        e.g. [[3,[1,1]],[3,[1,2]],[3,[1,3]],...,[3,[3,4]]]
                 Ṃ      Find the lexicographically smallest pair
                        e.g. [3,[1,1]]

Brachylog v2, 19 ไบต์

;Az{\-ᵐ~√ᵐ+}ᵐ≤ᵛ√;A≜

ลองออนไลน์!

โปรแกรมนี้เขียนได้ง่าย - Brachylog เกือบจะสมบูรณ์แบบสำหรับปัญหาประเภทนี้ - แต่ยากต่อการตีกอล์ฟ มันจะไม่แปลกใจเลยถ้ามีการบันทึกไบต์ที่นี่เหมือนบางสิ่งที่ฉันทำดูเหมือนจะมีผลกระทบใด ๆ (และมันมีคำแนะนำแผนที่ซ้อนกันโดยปกติแล้วเป็นสัญญาณว่าคุณควรใช้สมาชิก / findall แต่ฉันไม่สามารถทำได้ ดูวิธีการทำ)

นี่คือการส่งฟังก์ชั่น การป้อนข้อมูลจากอาร์กิวเมนต์ซ้ายเพื่อฟังก์ชั่นในรูปแบบเอาท์พุทจากการโต้แย้งสิทธิในรูปแบบ[[x,y],[x,y],…] [r,[[x,y]]](ถ้าคุณต้องการลองใช้ตัวเลขลบในอินพุตโปรดทราบว่า Brachylog ใช้_สำหรับเครื่องหมายลบไม่ใช่-นี่คือความสับสนเนื่องจากฟังก์ชัน→โปรแกรมเต็มรูปแบบที่ wrapper มาพร้อมกับ Brachylog ร้องขอโดยใช้อาร์กิวเมนต์บรรทัดคำสั่งZจะแสดงตัวเลขติดลบ ในเอาต์พุตที่มีเครื่องหมายลบปกติ)

คำอธิบาย

;Az{\-ᵐ~√ᵐ+}ᵐ≤ᵛ√;A≜
;A                   Append something
  z                    to every element of the input
   {       }ᵐ        such that for each resulting element:
     -                 Subtracting
    \ ᵐ                  corresponding elements {of the (input, appended) element}
       ~√              and un-squarerooting
         ᵐ               {the result of} each {subtraction}
          +            and summing {the resulting square numbers}
             ≤       {lets us find} a number at least as large as
              ᵛ        every element {of the list of sums}
               √     which can be square-rooted;
                ;A   append the same list as initially to it.
                  ≜  Find the first integer solution to the above, lexicographically.

สิ่งนี้น่าสนใจที่เราขอให้ Brachylog ค้นหาค่าคุณสมบัติบางอย่าง (ในกรณีนี้รัศมีของดิสก์ที่อยู่ตรงกลางตรงจุดAที่เหมาะกับทุกจุดอินพุต) แต่แทบจะไม่วางข้อกำหนดใด ๆ ลงไป (สิ่งที่เราต้องการคือ รัศมีนั้นเป็นตัวเลข) อย่างไรก็ตาม Brachylog จะคำนวณรัศมีภายในเป็นสัญลักษณ์แทนการพยายามใช้ตัวเลขที่เป็นรูปธรรมดังนั้นเมื่อถึงขั้นสุดท้าย≜แล้วจะบรรลุสองสิ่งในครั้งเดียว: ครั้งแรกมันช่วยให้มั่นใจว่ามีเพียงจำนวนเต็มเท่านั้นที่ใช้สำหรับพิกัดของAและรัศมี (บังคับให้รัศมีกำลังสองเป็นจำนวนจตุรัสและอธิบายการใช้≤ᵛเพื่อค้นหา "สูงสุดหรือสูงกว่า"); วินาทีมันจะหารัศมีที่มีขนาดเล็กที่สุดที่เป็นไปได้ (ขณะที่รัศมีมาก่อนในเอาต์พุต)

สิ่งหนึ่งที่ไม่ได้ระบุในโปรแกรมเลยก็คือทุกจุดจะถูกวัดเทียบกับศูนย์กลางของดิสก์เดียวกัน ตามที่เขียนไว้ไม่มีข้อ จำกัด ใด ๆ ที่เราไม่ได้ใช้ศูนย์ที่แตกต่างกันสำหรับแต่ละจุด อย่างไรก็ตามลำดับ tiebreak (ซึ่งในกรณีนี้ถูกตั้งค่าโดยที่สามᵐและข้อ จำกัด ของโครงสร้างจะถูกประเมินก่อนที่ข้อ จำกัด ของค่านัยโดยนัย≜) ต้องการAให้สั้นที่สุดเท่าที่จะเป็นไปได้ (เช่นองค์ประกอบเดียวดังนั้นเราจึงใช้สิ่งเดียวกัน จัดกึ่งกลางในแต่ละครั้งพยายามลองใช้ความยาวเป็นศูนย์Aก่อน ผลก็คือเราได้รับข้อ จำกัด ที่มีประโยชน์ (ที่เรามีเพียงดิสก์เดียว) "ฟรี"

การแก้ปัญหานี้เกิดขึ้นเพื่อพูดคุยกับทุกมิติโดยไม่มีการเปลี่ยนแปลงซอร์สโค้ด ไม่มีข้อสันนิษฐานว่าสิ่งต่าง ๆ เป็นแบบสองมิติ ดังนั้นหากคุณต้องการทรงกลมที่มีจำนวนเต็มน้อยที่สุดคุณก็สามารถมีมันได้เช่นกัน

Perl 6 , 81 ไบต์

{min [X]([Z]($^p)>>.minmax).map:{$p.map({(@_ Z-$_)>>².sum**.5}).max.ceiling,$_}}

ลองออนไลน์!

((X1, Y1), (X2, Y2), ...)นำรายการของจุดที่เป็นรายการ 2 องค์ประกอบ (R, (X, Y))ส่งกลับรายการ ใช้แนวทางเดียวกันกับคำตอบ Jelly ของ Pietu1998:

[X]([Z]($^p)>>.minmax)  # All possible centers within the bounding box
.map:{ ... }            # mapped to
$p.map({(@_ Z-$_)>>².sum**.5}).max  # maximum distance from any point
.ceiling                # rounded up,
,$_                     # paired with center.
min                     # Find minimum by distance.

วิธีการจะเป็นประโยชน์ที่นี่เป็นผลตอบแทนminmax Rangeผลิตภัณฑ์ของคาร์ทีเซียนของช่วงโดยตรงให้คะแนนทุกจุดด้วยพิกัดจำนวนเต็ม

05AB1E , 26 ไบต์

øεWsàŸ}`âεUIεX-nOt}àîX‚}{н

ท่าเรือ@ Pietu1998 's คำตอบวุ้น

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

ø                    # Zip the (implicit) input, swapping the rows and column
                     #  i.e. [[1,4],[3,2],[3,1]] → [[1,3,3],[4,2,1]]
 ε    }              # Map each to:
  W                  #  Push the smallest value (without popping the list)
                     #   i.e. [[1,3,3],[4,2,1]] → [1,1]
   s                 #  Swap so the list is at the top of the stack again
    à                #  Pop the list and push the largest value
                     #   i.e. [[1,3,3],[4,2,1]] → [3,4]
     Ÿ               #  Take the inclusive range of the min and max
                     #   i.e. [[1,2,3],[1,2,3,4]]
`                    # After the map, push both lists separated to the stack
 â                   # And take the cartesian product of the two lists
                     #  i.e. [[1,2,3],[1,2,3,4]]
                     #   → [[1,1],[1,2],[1,3],[1,4],[2,1],[2,2],[2,3],[2,4],[3,1],[3,2],[3,3],[3,4]]
  ε             }    # Map each pair to:
   U                 #  Pop and store the current value in variable `X`
    I                #  Push the input
     ε     }         #  Map each pair in the input to:
      X              #   Push variable `X`
       -             #   Subtract it from the current pair
                     #    i.e. [3,2] - [1,3] → [2,-1]
        n            #   Take the square of each
                     #    i.e. [2,-1] → [4,1]
         O           #   Sum the lists
                     #    i.e. [4,1] → 5
          t          #   Take the square-root of each
                     #    i.e. 5 → 2.23606797749979
            à        #  Pop the converted list, and push its largest value
                     #   i.e. [[3.0,2.23606797749979,2.0],[2.0,2.0,2.23606797749979],...,[2.0,2.0,3.0]]
                     #    → [3.0,2.23606797749979,...,3.0]
             î       #  Round it up
                     #   i.e. [3.0,2.23606797749979,...,3.0] → [3.0,3.0,3.0,4.0,4.0,3.0,3.0,4.0,4.0,3.0,3.0,3.0]
              X‚     #  Pair it with variable `X`
                     #   i.e. [[3.0,[1,1]],[3.0,[1,2]],...,[3.0,[3,4]]]
                 {   # After the map, sort the list
                  н  # And take the first item (which is output implicitly)
                     #  i.e. [[3.0,[1,1]],[3.0,[1,2]],...,[3.0,[3,4]]] → [3.0,[1,1]]

Matlab, 73 ไบต์

function g(x);[r,~,d]=fminimax(@(a)pdist2(x,a),[0 0]);[round(r) ceil(d)]

เพียงแค่หาทางออกที่เล็กที่สุด (จุดลอยตัว) และปัดไปยังจุดที่ใกล้ที่สุดแล้วฉายรัศมี (กรณีที่เลวร้ายที่สุดสำหรับปัญหาขั้นต่ำสุด) ฉันไม่ทราบแน่ชัดว่าจะให้โซลูชันที่ถูกต้องสำหรับกรณีที่เป็นไปได้ทั้งหมด (ภายในความแม่นยำ) แต่สำหรับกรณีทดสอบควรใช้งานได้ (ถ้าฉันไม่ได้พิมพ์ผิดพลาด)

โทรมาด้วย

g([1 4;3 2;4 1;4 5;5 2;7 4])

Pyth , 34 33 ไบต์

hSm+.EeSm@s^R2-Vdk2Qd*Fm}FhM_BSdC

เอาต์พุตอยู่ในรูปแบบ [R,x,y]

ลองออนไลน์ได้ที่นี่หรือตรวจสอบทุกกรณีการทดสอบในครั้งเดียวที่นี่

hSm+.EeSm@s^R2-Vdk2Qd*Fm}FhM_BSdCQ   Implicit: Q=eval(input())
                                     Trailing Q inferred
                                CQ   Transpose (group x and y coordinates separately)
                       m             Map each in the above, as d, using:
                              Sd       Sort d
                            _B         Pair with its own reverse
                          hM           Take the first element of each, yielding [min, max]
                        }F             Generate inclusive range
                     *F              Cartesian product of the above two lists, yielding all coordinates in range
  m                                  Map each coordinate in the above, as d, using:
        m          Q                   Map each coordinate in input, as k, using:
              -Vdk                       Take the difference between x and y coordinates in d and k
           ^R2                           Square each
          s                              Sum
         @        2                      Take the square root
      eS                               Take the largest of the result
    .E                                 Rounded up
   +                d                  Prepend to d
 S                                   Sort the result, first element as most significant
h                                    Take first element

แก้ไข: บันทึกไบต์โดยจัดรูปแบบเอาท์พุทใหม่รุ่นก่อนหน้า:

heDm+d.EeSm@s^R2-Vdk2Q*Fm}FhM_BSdC

ภาษา Wolfram (Mathematica) , 66 ไบต์

นี่คือวิธีการที่กำลังดุร้าย ฉันพิจารณาBoundingRegion[#,"MinDisk"]&ฟังก์ชั่นที่สั้นกว่ามากแต่ไม่มีวิธีใดที่จะบังคับพิกัดจำนวนเต็ม & รัศมี

Minimize[{r,RegionWithin[{x,y}~Disk~r,Point@#]},{x,y,r},Integers]&

ลองออนไลน์!

Java 10, 283 279 277 257 ไบต์

C->{int M=1<<31,m=M,X=M,Y=M,x=M-1,y=x,t,a,b,r[]={x};for(var c:C){x=(t=c[0])<x?t:x;X=t>X?t:X;y=(t=c[1])<y?t:y;Y=t>Y?t:Y;}for(;y<=Y;y++)for(t=x;t<=X;r=m<r[0]?new int[]{m,t,y}:r,m=M,t++)for(var c:C){a=c[0]-t;b=c[1]-y;a*=a;m=(a=(int)Math.ceil(Math.sqrt(a+=b*=b)))>m?a:m;}return r;}

-20 ไบต์ขอบคุณที่@nwellnhof 's Math.hypotเคล็ดลับของการใช้

[R,X,Y]ผลอาร์เรย์อยู่ในการสั่งซื้อ

ลองออนไลน์

คำอธิบาย:

C->{                  // Method with 2D int-array as parameter & int-array as return-type
  int M=1<<31,        //  Minimum `M`, starting at -2,147,483,648
      m=M,            //  Temp integer, starting at -2,147,483,648 as well
      X=M,            //  Largest X coordinate, starting at -2,147,483,648 as well
      Y=M,            //  Largest Y coordinate, starting at -2,147,483,648 as well
      x=M-1,          //  Smallest X coordinate, starting at 2,147,483,647
      y=x,            //  Smallest Y coordinate, starting at 2,147,483,647 as well
      t,a,            //  Temp integers, starting uninitialized
      r[]={x};        //  Result-array, starting at one 2,147,483,647
  for(var c:C){       //  Loop over the input-coordinates
    x=(t=c[0])<x?t:x; //   If the X coordinate is smaller than `x`, change it
    X=t>X?t:X;        //   If the X coordinate is larger than `X`, change it
    y=(t=c[1])<y?t:y; //   If the Y coordinate is smaller than `y`, change it
    Y=t>Y?t:Y;}       //   If the Y coordinate is larger than `Y`, change it
 for(;y<=Y;y++)       //  Loop `y` in the range [`y`,`Y`]:
   for(t=x;t<=X       //   Inner loop `t` in the range [`x`,`X`]:
          ;           //     After every iteration:
           r=m<r[0]?  //      If `m` is smaller than the first value:
              new int[]{m,t,y}
                      //       Replace the result with `m,t,y`
             :        //      Else:
              r,      //       Leave `r` unchanged
           m=M,       //      Reset `m` to -2,147,483,648 for the next iteration
           t++)       //      And increase `t` by 1
     for(var c:C)     //    Inner loop over the input-coordinates
       m=(a=(int)Math.ceil(Math.hypot(c[0]-t,c[1]-y)))
                      //     Subtract `t` from the X coordinate;
                      //     subtract `y` from the Y coordinate;
                      //     take the hypot (<- sqrt(x*x+y*y)) of those
                      //     ceil it
                      //     And set `a` to this value
          >m?         //     If `a` is larger than `m`:
           a          //      Set `m` to `a`
          :           //     Else:
           m;         //      Leave `m` unchanged
  return r;}          //  Return the result `r`

Javascript, 245 ไบต์

a=>{[b,c,d,e]=a.reduce(([j,k,l,m],[h,i])=>[j>h?j:h,k<h?k:h,l>i?l:i,m<i?m:i],[,,,,]);for(f=c;f<b;f++){for(g=e;g<d;g++){s=a.reduce((o,[p,q])=>o>(r=(p-f)**2+(q-g)**2)?o:r);n=n?n[2]>s?[f,g,s]:n:[f,g,s]}}return [n[0],n[1],Math.ceil(Math.sqrt(n[2]))]}

(ค่อนข้าง) รุ่นที่อ่านได้มากขึ้น:

a=>{
    [b,c,d,e]=a.reduce(([j,k,l,m],[h,i])=>[j>h?j:h,k<h?k:h,l>i?l:i,m<i?m:i],[,,,,]);
    for(f=c;f<b;f++){
        for(g=e;g<d;g++){
            s=a.reduce((o,[p,q])=>o>(r=(p-f)**2+(q-g)**2)?o:r);
            n=n?n[2]>s?[f,g,s]:n:[f,g,s]
        }
    }
    return [n[0],n[1],Math.ceil(Math.sqrt(n[2]))]
}

เพียงแค่หากล่องที่มีขอบเขตและทดสอบแต่ละพิกัดในกล่องนั้นว่าดีที่สุดหรือไม่

ฉันสามารถบันทึก 8 ไบต์ด้วยคำตอบโดยประมาณโดยแทนที่:

Math.ceil(Math.sqrt(n[2])) กับ ~~(n[2]+1-1e-9)

Ruby , 113 ไบต์

->l{a=l.flatten;(z=*a.min..a.max).product(z).map{|x,y|[l.map{|u,v|(((x-u)**2+(y-v)**2)**0.5).ceil}.max,x,y]}.min}

ลองออนไลน์!

ถ่าน , 65 ไบต์

≔Ｅθ§ι¹ζ≔Ｅθ§ι⁰ηＦ…·⌊η⌈ηＦ…·⌊ζ⌈ζ⊞υ⟦ικ⟧≔Ｅυ⌈ＥθΣＥιＸ⁻§λξν²ηＩ§υ⌕η⌊ηＩ⌈Ｘ⌊η·⁵

ลองออนไลน์! การเชื่อมโยงคือการสร้างรหัสเวอร์ชัน คำอธิบาย:

≔Ｅθ§ι¹ζ

รับ Y zพิกัดลงใน

≔Ｅθ§ι⁰η

รับ x hพิกัดลงใน

Ｆ…·⌊η⌈ηＦ…·⌊ζ⌈ζ⊞υ⟦ικ⟧

วนรอบช่วงที่ครอบคลุมตั้งแต่ระดับต่ำสุดจนถึงสูงสุดhและzสร้างรายการของศูนย์ดิสก์ที่มีศักยภาพทั้งหมด

≔Ｅυ⌈ＥθΣＥιＸ⁻§λξν²η

วนรอบจุดศูนย์กลางแผ่นดิสก์ทั้งหมดจากนั้นวนรอบจุดเดิมทั้งหมดจากนั้นวนรอบพิกัดทั้งสองแบบลบ, สี่เหลี่ยมจัตุรัส, ผลรวม, ใช้เวลาสูงสุดและบันทึกรายการผลลัพธ์

Ｉ§υ⌕η⌊η

ค้นหาตำแหน่งของเส้นผ่าศูนย์กลางที่น้อยที่สุดและพิมพ์ศูนย์ดิสก์ที่เกี่ยวข้อง

Ｉ⌈Ｘ⌊η·⁵

พิมพ์เส้นผ่านศูนย์กลางสูงสุดที่น้อยที่สุด แต่ปัดไปจนถึงจำนวนเต็มถัดไป