เขียนฟังก์ชั่นที่ใช้ 4 จุดบนเครื่องบินเป็นอินพุทและคืนค่าจริงถ้า if 4 คะแนนเป็นรูปสี่เหลี่ยมจัตุรัส คะแนนจะมีพิกัดรวมที่มีค่าสัมบูรณ์ <1,000

คุณสามารถใช้การแทนค่าตามสมควรของ 4 คะแนนเป็นอินพุตได้ คะแนนไม่ได้ระบุไว้ในคำสั่งซื้อใด ๆ

รหัสที่สั้นที่สุดชนะ

ตัวอย่างสี่เหลี่ยม:

(0,0),(0,1),(1,1),(1,0)    # standard square
(0,0),(2,1),(3,-1),(1,-2)  # non-axis-aligned square
(0,0),(1,1),(0,1),(1,0)    # different order

ตัวอย่างที่ไม่ใช่สี่เหลี่ยม:

(0,0),(0,2),(3,2),(3,0)  # rectangle
(0,0),(3,4),(8,4),(5,0)  # rhombus
(0,0),(0,0),(1,1),(0,0)  # only 2 distinct points
(0,0),(0,0),(1,0),(0,1)  # only 3 distinct points

คุณสามารถคืนค่าจริงหรือเท็จสำหรับสี่เหลี่ยมจัตุรัสที่เสื่อม (0,0),(0,0),(0,0),(0,0)

Python 176 90 79 ไบต์

def S(A):c=sum(A)/4.0;return set(A)==set((A[0]-c)\*1j\*\*i+c for i in range(4))

ฟังก์ชัน S รับรายการตัวเลขที่ซับซ้อนเป็นอินพุต (A) หากเรารู้ทั้งจุดศูนย์กลางและมุมหนึ่งมุมของสี่เหลี่ยมเราสามารถสร้างตารางใหม่ได้โดยหมุนมุม 90,180 และ 270 องศารอบจุดศูนย์กลาง (c) ในการหมุนระนาบเชิงซ้อน 90 องศาเกี่ยวกับต้นกำเนิดจะทำโดยการคูณจุดโดยฉัน หากรูปร่างดั้งเดิมของเราและจตุรัสที่สร้างใหม่มีจุดเท่ากันก็จะต้องเป็นสี่เหลี่ยมจัตุรัส

J, 28 17 25 27 27

J ไม่มีฟังก์ชั่นจริงๆ แต่นี่เป็นคำกริยาที่ใช้เวกเตอร์ของจุดจากระนาบเชิงซ้อน:

4 8 4-:#/.~&(/:~&:|&,&(-/~))

วิธีการคือการผสมผสานของMichael Spencer (ทำงานเฉพาะกับความยาวระหว่างจุดยอด แต่ตอนนี้เขากำลังทำรูปสี่เหลี่ยมขนมเปียกปูนของฉัน 2) และEelvex's (ตรวจสอบขนาดชุด) อ่านจากขวาไปซ้าย:

• -/~ คำนวณความแตกต่างของจุดทั้งหมด
• , เรียบ
• | แยกขนาด
• /:~ จัดเรียง
• #/.~ นับและนับ
• 4 8 4 -:ต้องมีระยะห่างเท่ากับ 4 เท่า (ที่ 0), 8 บิตใหญ่กว่า (ความยาว 1, ด้านข้าง), 4 ใหญ่กว่า (ความยาวsqrt 2, เส้นทแยงมุม)

สาธิต:

   NB. give the verb a name for easier use
   f =: 4 8 4-:#/.~&(/:~&:|&,&(-/~))

   NB. standard square
   f 0 0j1 1j1 1
1

   NB. non-axis-aligned square
   f 0 2j1 3j_1 1j_2
1

   NB. different order
   f 0 1j1 0j1 1
1

   NB. rectangle
   f 0 0j2 3j2 3
0

   NB. rhombus 1
   f 0 3j4 8j4 5
0

   NB. rhombus 2
   f 0 1ad_60 1ad0 1ad60
0

เพื่อประโยชน์ของหน่วยความจำวิธีการก่อนหน้าของฉัน (ต้องการจุดยอดสั่งซื้อ แต่สามารถตรวจจับรูปหลายเหลี่ยมปกติของคำสั่งใด ๆ ):

*./&(={.)&(%1&|.)&(-1&|.)

ดูประวัติสำหรับคำอธิบายและการสาธิต วิธีการในปัจจุบันอาจจะขยายไปยังรูปหลายเหลี่ยมอื่น ๆ ที่4 8 4มีลักษณะเหมือนการแจกแจงทวินาม

Python, 71 42

lambda A: len(set(A))==4 and len(set(abs(i-j)for i in A for j in A))==3

อัปเดต 1) ต้องใช้ 4 คะแนนที่ต่างกัน (ก่อนหน้านี้จะให้ผลบวกปลอมสำหรับคะแนนซ้ำ - มีคนอื่นหรือไม่?) 2) เพื่อกำหนดฟังก์ชั่นต่อสเปค

สำหรับสี่เหลี่ยมจัตุรัสเวกเตอร์ระหว่างจุดสองจุดใดต้องเป็น 0 (จุดเดียวกัน) ด้านข้างหรือเส้นทแยงมุม ดังนั้นเซตของขนาดของเวกเตอร์เหล่านี้ต้องมีความยาว 3

# Accepts co-ordinates as sequences of complex numbers

SQUARES=[
 (0+0j,0+1j,1+1j,1+0j),  # standard square
 (0+0j,2+1j,3-1j,1-2j),  # non-axis-aligned square
 (0+0j,1+1j,0+1j,1+0j)   # different order
]

NONSQUARES=[
 (0+0j,0+2j,3+2j,3+0j),  # rectangle
 (0+0j,3+4j,8+4j,5+0j),  # rhombus
 (0+0j,0+1j,1+1j,0+0j),   # duplicated point
 (0+0j,1+60j,1+0j,1-60j)  # rhombus 2 (J B)
] 

test = "lambda A: len(set(A))==4 and len(set(abs(i-j)for i in A for j in A))==3"
assert len(test)==71

is_square=lambda A: len(set(A))==4 and len(set(abs(i-j)for i in A for j in A))==3    

for A in SQUARES:
    assert is_square(A)

for A in NONSQUARES:
    assert not is_square(A)

Haskell, 100 ตัวอักษร

นี่คือวิธีที่ฉันจะเขียนคำตอบ J ของ JB ใน Haskell ไม่มีความพยายามที่จะสร้างความเสียหายให้กับการอ่านได้โดยการลบตัวละครที่ไม่จำเป็นมันคือประมาณ 132 ตัวอักษร:

import Data.List
d (x,y) (x',y') = (x-x')^2 + (y-y')^2
square xs = (== [4,8,4]) . map length . group . sort $ [d x y | x<-xs, y<-xs]

คุณสามารถขูดมันลงได้เล็กน้อยถึง 100 โดยลบช่องว่างส่วนเกินและเปลี่ยนชื่อบางอย่าง

import Data.List
d(x,y)(a,b)=(x-a)^2+(y-b)^2
s l=(==[4,8,4]).map length.group.sort$[d x y|x<-l,y<-l]

ลองใช้ QuickCheck เพื่อให้แน่ใจว่ามันยอมรับสแควร์สตามอำเภอใจโดยมีหนึ่งจุดยอดที่ (x, y) และเวกเตอร์ขอบ (a, b):

prop_square (x,y) (a,b) = square [(x,y),(x+a,y+b),(x-b,y+a),(x+a-b,y+b+a)]

ลองใช้ใน ghci:

ghci> quickCheck prop_square
*** Failed! Falsifiable (after 1 test):  
(0,0)
(0,0)

โอ้ใช่จตุรัสที่ว่างเปล่าจะไม่ถือว่าเป็นจตุรัสที่นี่ดังนั้นเราจะทบทวนการทดสอบของเรา:

prop_square (x,y) (a,b) =
   (a,b) /= (0,0) ==> square [(x,y),(x+a,y+b),(x-b,y+a),(x+a-b,y+b+a)]

และลองอีกครั้ง:

ghci> quickCheck prop_square
+++ OK, passed 100 tests.

ปัจจัย

การดำเนินการในปัจจัยการเขียนโปรแกรมภาษา:

USING: kernel math math.combinatorics math.vectors sequences sets ;

: square? ( seq -- ? )
    members [ length 4 = ] [
        2 [ first2 distance ] map-combinations
        { 0 } diff length 2 =
    ] bi and ;

และการทดสอบหน่วยบางอย่าง:

[ t ] [
    {
        { { 0 0 } { 0 1 } { 1 1 } { 1 0 } }   ! standard square
        { { 0 0 } { 2 1 } { 3 -1 } { 1 -2 } } ! non-axis-aligned square
        { { 0 0 } { 1 1 } { 0 1 } { 1 0 } }   ! different order
        { { 0 0 } { 0 4 } { 2 2 } { -2 2 } }  ! rotated square
    } [ square? ] all?
] unit-test

[ f ] [
    {
        { { 0 0 } { 0 2 } { 3 2 } { 3 0 } }   ! rectangle
        { { 0 0 } { 3 4 } { 8 4 } { 5 0 } }   ! rhombus
        { { 0 0 } { 0 0 } { 1 1 } { 0 0 } }   ! only 2 distinct points
        { { 0 0 } { 0 0 } { 1 0 } { 0 1 } }   ! only 3 distinct points
    } [ square? ] any?
] unit-test

OCaml, 145 164

let(%)(a,b)(c,d)=(c-a)*(c-a)+(d-b)*(d-b)
let t a b c d=a%b+a%c=b%c&&d%c+d%b=b%c&&a%b=a%c&&d%c=d%b
let q(a,b,c,d)=t a b c d||t a c d b||t a b d c

ทำงานแบบนี้:

q ((0,0),(2,1),(3,-1),(1,-2))

ขอ deobfuscate และอธิบายนิดหน่อย

ครั้งแรกที่เรากำหนดบรรทัดฐาน:

let norm (ax,ay) (bx,by) = (bx-ax)*(bx-ax)+(by-ay)*(by-ay)

คุณจะสังเกตเห็นว่าไม่มีการเรียก sqrt มันไม่จำเป็นที่นี่

let is_square_with_fixed_layout a b c d =
  (norm a b) + (norm a c) = norm b c
  && (norm d c) + (norm d b) = norm b c
  && norm a b = norm a c
  && norm d c = norm d b

a, b, c และ d เป็นคะแนน เราคิดว่าประเด็นเหล่านี้ถูกจัดวางเช่นนี้:

a - b
| / |
c - d

หากเรามีสี่เหลี่ยมเงื่อนไขเหล่านี้ทั้งหมดต้องเก็บไว้:

• abc เป็นสามเหลี่ยมมุมฉาก
• bcd เป็นรูปสามเหลี่ยมมุมฉาก
• ด้านที่เล็กกว่าของสามเหลี่ยมมุมฉากแต่ละอันจะมีบรรทัดฐานเดียวกัน

สังเกตว่าสิ่งต่อไปนี้ถืออยู่เสมอ:

is_square_with_fixed_layout r s t u = is_square_with_fixed_layout r t s u

เราจะใช้เพื่อลดความซับซ้อนของฟังก์ชั่นการทดสอบของเราด้านล่าง

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

let is_square (a,b,c,d) =
  is_square_with_fixed_layout a b c d
  || is_square_with_fixed_layout a c b d
  || is_square_with_fixed_layout a c d b
  || is_square_with_fixed_layout a b d c
  || is_square_with_fixed_layout a d b c
  || is_square_with_fixed_layout a d c b

หลังจากการทำให้เข้าใจง่าย:

let is_square (a,b,c,d) =
  is_square_with_fixed_layout a b c d
  || is_square_with_fixed_layout a c d b
  || is_square_with_fixed_layout a b d c

แก้ไข: ปฏิบัติตามคำแนะนำของ M.Giovannini

Python (105)

คะแนนจะแสดงโดย(x,y)tuples คะแนนสามารถอยู่ในลำดับใดก็ได้และยอมรับเฉพาะสี่เหลี่ยมเท่านั้น สร้างรายการsระยะทางระหว่างจุด (ไม่ใช่ศูนย์) คู่ ควรมีระยะทางรวม 12 กลุ่มในกลุ่มที่ไม่ซ้ำกันสองกลุ่ม

def f (p): s = ตัวกรอง (ไม่มี, [(xz) ** 2+ (yw) ** 2 สำหรับ x, y ใน p สำหรับ z, w ใน p]); return len (s) == 12 และ len ( ชุด (s)) == 2

Python 42 ตัวอักษร

ดูเหมือนว่าการปรับปรุงจะใช้ตัวเลขที่ซับซ้อนสำหรับคะแนน

len(set(abs(x-y)for x in A for y in A))==3

โดยที่ A = [(11 + 13j), (14 + 12j), (13 + 9j), (10 + 10j)]

คำตอบเก่า:

from itertools import*
len(set((a-c)**2+(b-d)**2 for(a,b),(c,d)in combinations(A,2)))==2

คะแนนที่ระบุไว้ในลำดับใด ๆ เป็นรายการเช่น

A = [(11, 13), (14, 12), (13, 9), (10, 10)]

C # - ไม่สั้นอย่างแน่นอน การละเมิด LINQ เลือกการรวมกันของจุดสองจุดที่แตกต่างกันในการคำนวณคำนวณระยะทางแล้วตรวจสอบว่าพวกเขาสี่คนนั้นเท่ากันและมีค่าระยะทางที่แตกต่างกันเพียงค่าเดียว Point เป็นคลาสที่มีสมาชิกสองคนสองคนคือ X และ Y. อาจเป็น Tuple ได้อย่างง่ายดาย

var points = new List<Point>
             {
                 new Point( 0, 0 ), 
                 new Point( 3, 4 ), 
                 new Point( 8, 4 ), 
                 new Point( 5, 0 )
              };    
var distances = points.SelectMany(
    (value, index) => points.Skip(index + 1),
    (first, second) => new Tuple<Point, Point>(first, second)).Select(
        pointPair =>
        Math.Sqrt(Math.Pow(pointPair.Item2.X - pointPair.Item1.X, 2) +
                Math.Pow(pointPair.Item2.Y - pointPair.Item1.Y, 2)));
return
    distances.Any(
        d => distances.Where( p => p == d ).Count() == 4 &&
                distances.Where( p => p != d ).Distinct().Count() == 1 );

PHP, 82 ตัวอักษร

//$x=array of x coordinates
//$y=array of respective y coordinates
/* bounding box of a square is also a square - check if Xmax-Xmin equals Ymax-Ymin */
function S($x,$y){sort($x);sort($y);return ($x[3]-$x[0]==$y[3]-$y[0])?true:false};

//Or even better (81 chars):
//$a=array of points - ((x1,y1), (x2,y2), (x3,y3), (x4,y4))
function S($a){sort($a);return (bool)($a[3][0]-$a[0][0]-abs($a[2][1]-$a[3][1]))};

K - 33

คำแปลของโซลูชัน J โดย JB :

{4 8 4~#:'=_sqrt+/'_sqr,/x-/:\:x}

K ทนทุกข์ทรมานจากคำที่สงวนไว้ ( _sqrและ_sqrt )

การทดสอบ:

  f:{4 8 4~#:'=_sqrt+/'_sqr,/x-/:\:x}

  f (0 0;0 1;1 1;1 0)
1

  f 4 2#0 0 1 1 0 1 1 0
1

  f 4 2#0 0 3 4 8 4 5 0
0

OCaml + แบตเตอรี่, 132 ตัวอักษร

let q l=match List.group(-)[?List:(x-z)*(x-z)+(y-t)*(y-t)|x,y<-List:l;z,t<-List:l;(x,y)<(z,t)?]with[[s;_;_;_];[d;_]]->2*s=d|_->false

(ดูสิไม่มีช่องว่าง!) รายการเข้าใจใน qรูปแบบรายการบรรทัดฐานกำลังสองสำหรับแต่ละจุดที่ไม่มีลำดับ สี่เหลี่ยมจัตุรัสมีสี่ด้านเท่ากันและสองเส้นทแยงมุมเท่ากันความยาวกำลังสองของหลังเป็นสองเท่าความยาวยกกำลังสองของอดีต เนื่องจากไม่มีสามเหลี่ยมด้านเท่ากันหมดในโครงร่างจำนวนเต็มการทดสอบจึงไม่จำเป็นจริงๆ แต่ฉันรวมมันไว้ด้วยเพื่อความสมบูรณ์

แบบทดสอบ:

q [(0,0);(0,1);(1,1);(1,0)] ;;
- : bool = true
q [(0,0);(2,1);(3,-1);(1,-2)] ;;
- : bool = true
q [(0,0);(1,1);(0,1);(1,0)] ;;
- : bool = true
q [(0,0);(0,2);(3,2);(3,0)] ;;
- : bool = false
q [(0,0);(3,4);(8,4);(5,0)] ;;
- : bool = false
q [(0,0);(0,0);(1,1);(0,0)] ;;
- : bool = false
q [(0,0);(0,0);(1,0);(0,1)] ;;
- : bool = false

มาติกา 65 80 69 66

ตรวจสอบว่าจำนวนของระยะทางระหว่างจุดที่แตกต่างกัน (ไม่รวมระยะทางจากจุดหนึ่งไปยังอีกจุดหนึ่ง) คือ 2 และสั้นลงของทั้งสองไม่ใช่ 0

h = Length@# == 2 \[And] Min@# != 0 &[Union[EuclideanDistance @@@ Subsets[#, {2}]]] &;

การใช้

h@{{0, 0}, {0, 1}, {1, 1}, {1, 0}}       (*standard square *)
h@{{0, 0}, {2, 1}, {3, -1}, {1, -2}}     (*non-axis aligned square *)
h@{{0, 0}, {1, 1}, {0, 1}, {1, 0}}       (*a different order *)

h@{{0, 0}, {0, 2}, {3, 2}, {3, 0}}       (* rectangle *)
h@{{0, 0}, {3, 4}, {8, 4}, {5, 0}}       (* rhombus   *)
h@{{0, 0}, {0, 0}, {1, 1}, {0, 0}}       (* only 2 distinct points *)
h@{{0, 0}, {0, 1}, {1, 1}, {0, 1}}       (* only 3 distinct points *)

ทรู
ทรู
ทรู
เท็จ
เท็จ
เท็จ
เท็จ

NB: \[And]เป็นตัวละครเดียวใน Mathematica

เยลลี่ขนาด 8 ไบต์

_Æm×ıḟƊṆ

ลองออนไลน์!

รับรายการตัวเลขที่ซับซ้อนเป็นอาร์กิวเมนต์บรรทัดคำสั่ง พิมพ์หรือ10

_Æm        Subtract mean of points from each point (i.e. center on 0)
   ×ıḟƊ    Rotate 90°, then compute set difference with original.
       Ṇ   Logical negation: if empty (i.e. sets are equal) then 1 else 0.

ดูเหมือนว่าจะเป็นความท้าทายที่สนุกสนานในการชุบชีวิต!

แฮสเคล (212)

import Data.List;j=any f.permutations where f x=(all g(t x)&&s(map m(t x)));t x=zip3 x(drop 1$z x)(drop 2$z x);g(a,b,c)=l a c==sqrt 2*l a b;m(a,b,_)=l a b;s(x:y)=all(==x)y;l(m,n)(o,p)=sqrt$(o-m)^2+(n-p)^2;z=cycle

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

• มุมทั้งหมด 90 องศา
• ทุกด้านมีความยาวเท่ากัน

รหัส Deobfuscated และการทดสอบ

j' = any satisfyBothConditions . permutations
          --f
    where satisfyBothConditions xs = all angleIs90 (transform xs) && 
                                     same (map findLength' (transform xs))
          --t
          transform xs = zip3 xs (drop 1 $ cycle xs) (drop 2 $ cycle xs)
          --g
          angleIs90 (a,b,c) = findLength a c == sqrt 2 * findLength a b
          --m
          findLength' (a,b,_) = findLength a b
          --s
          same (x:xs) = all (== x) xs
          --l
          findLength (x1,y1) (x2,y2) = sqrt $ (x2 - x1)^2 + (y2 - y1)^2


main = do print $ "These should be true"
          print $ j [(0,0),(0,1),(1,1),(1,0)]
          print $ j [(0,0),(2,1),(3,-1),(1,-2)]
          print $ j [(0,0),(1,1),(0,1),(1,0)]
          print $ "These should not"
          print $ j [(0,0),(0,2),(3,2),(3,0)]
          print $ j [(0,0),(3,4),(8,4),(5,0)]
          print $ "also testing j' just in case"
          print $ j' [(0,0),(0,1),(1,1),(1,0)]
          print $ j' [(0,0),(2,1),(3,-1),(1,-2)]
          print $ j' [(0,0),(1,1),(0,1),(1,0)]
          print $ j' [(0,0),(0,2),(3,2),(3,0)]
          print $ j' [(0,0),(3,4),(8,4),(5,0)]

สกาลา (146 ตัวอักษร)

def s(l:List[List[Int]]){var r=Set(0.0);l map(a=>l map(b=>r+=(math.pow((b.head-a.head),2)+math.pow((b.last-a.last),2))));print(((r-0.0).size)==2)}

จาวาสคริปต์ 144 ตัว

ในทางคณิตศาสตร์เท่ากับคำตอบ J Bs มันสร้างความยาว 6 และยืนยันว่า 2 ที่ยิ่งใหญ่ที่สุดเท่ากันและ 4 ที่เล็กที่สุดเท่ากัน อินพุตต้องเป็นอาร์เรย์ของอาร์เรย์

function F(a){d=[];g=0;for(b=4;--b;)for(c=b;c--;d[g++]=(e*e+f*f)/1e6)e=a[c][0]-a[b][0],f=a[c][1]-a[b][1];d.sort();return d[0]==d[3]&&d[4]==d[5]} //Compact function
testcases=[
[[0,0],[1,1],[1,0],[0,1]],
[[0,0],[999,999],[999,0],[0,999]],
[[0,0],[2,1],[3,-1],[1,-2]],
[[0,0],[0,2],[3,2],[3,0]],
[[0,0],[3,4],[8,4],[5,0]],
[[0,0],[0,0],[1,1],[0,0]],
[[0,0],[0,0],[1,0],[0,1]]
]
for(v=0;v<7;v++){
    document.write(F(testcases[v])+"<br>")
}

function G(a){ //Readable version
    d=[]
    g=0
    for(b=4;--b;){
        for(c=b;c--;){
            e=a[c][0]-a[b][0]
            f=a[c][1]-a[b][1]
            d[g++]=(e*e+f*f)/1e6 //The division tricks the sort algorithm to sort correctly by default method.
        }
    }
    d.sort()
    return (d[0]==d[3]&&d[4]==d[5])
}

PHP, 161 158 ตัวอักษร

function S($a){for($b=4;--$b;)for($c=$b;$c--;){$e=$a[$c][0]-$a[$b][0];$f=$a[$c][1]-$a[$b][1];$d[$g++]=$e*$e+$f*$f;}sort($d);return$d[0]==$d[3]&&$d[4]==$d[5];}

หลักฐาน (1x1): http://codepad.viper-7.com/ZlBpOB

นี้จะขึ้นอยู่ออกจากคำตอบของ JavaScript eBuisness

JavaScript 1.8, 112 ตัวอักษร

อัปเดต: บันทึก 2 ตัวอักษรโดยการพับความเข้าใจอาร์เรย์ด้วยกัน

function i(s)(p=[],[(e=x-a,f=y-b,d=e*e+f*f,p[d]=~~p[d]+1)for each([a,b]in s)for each([x,y]in s)],/8,+4/.test(p))

การปรับใช้อีกครั้งของคำตอบของ JB ใช้ประโยชน์จากคุณสมบัติของ JavaScript 1.7 / 1.8 (การปิดนิพจน์ความเข้าใจของอาเรย์การมอบหมายการทำลายโครงสร้าง) การละเมิดยัง~~ (ตัวดำเนินการสองบิตไม่ได้) เพื่อบีบบังคับให้undefinedเป็นตัวเลขโดยมีการบีบบังคับแบบอาเรย์กับสตริงและ regexp เพื่อตรวจสอบว่าการนับความยาวเป็นเท่าใด[4, 8, 4]เท่าไร การใช้โอเปอเรเตอร์คอมม่าในทางที่ผิดนั้นเป็นเคล็ดลับ C ที่ทำให้งงงวย

แบบทดสอบ:

function assert(cond, x) { if (!cond) throw ["Assertion failure", x]; }

let text = "function i(s)(p=[],[(e=x-a,f=y-b,d=e*e+f*f,p[d]=~~p[d]+1)for each([a,b]in s)for each([x,y]in s)],/8,+4/.test(p))"
assert(text.length == 112);
assert(let (source = i.toSource()) (eval(text), source == i.toSource()));

// Example squares:
assert(i([[0,0],[0,1],[1,1],[1,0]]))    // standard square
assert(i([[0,0],[2,1],[3,-1],[1,-2]]))  // non-axis-aligned square
assert(i([[0,0],[1,1],[0,1],[1,0]]))    // different order

// Example non-squares:
assert(!i([[0,0],[0,2],[3,2],[3,0]]))  // rectangle
assert(!i([[0,0],[3,4],[8,4],[5,0]]))  // rhombus
assert(!i([[0,0],[0,0],[1,1],[0,0]]))  // only 2 distinct points
assert(!i([[0,0],[0,0],[1,0],[0,1]]))  // only 3 distinct points

// Degenerate square:
assert(!i([[0,0],[0,0],[0,0],[0,0]]))   // we reject this case

GoRuby - 66 ตัวอักษร

f=->a{z=12;a.pe(2).m{|k,l|(k-l).a}.so.go{|k|k}.a{|k,l|l.sz==z-=4}}

ขยาย:

f=->a{z=12;a.permutation(2).map{|k,l|(k-l).abs}.sort.group_by{|k|k}.all?{|k,l|l.size==(z-=4)}}

ขั้นตอนวิธีการเช่นเดียวกับคำตอบของ JB

ทดสอบเช่น:

p f[[Complex(0,0), Complex(0,1), Complex(1,1), Complex(1,0)]]

เอาต์พุตtrueสำหรับ true และ blank สำหรับ false

Python 97 (ไม่มีคะแนนซับซ้อน)

def t(p):return len(set(p))-1==len(set([pow(pow(a-c,2)+pow(b-d,2),.5)for a,b in p for c,d in p]))

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

คุณสามารถทดสอบได้ดังนี้:

S1 = [(0,0),(1,0),(1,1),(0,1)]   # standard square
S2 = [(0,0),(2,1),(3,-1),(1,-2)] # non-axis-aligned square
S3 = [(0,0),(1,1),(0,1),(1,0)]   # different order
S4 = [(0,0),(2,2),(0,2),(2,0)]   #
S5 = [(0,0),(2,2),(0,2),(2,0),(0,0)] #Redundant points

B1 = [(0,0),(0,2),(3,2),(3,0)]  # rectangle
B2 = [(0,0),(3,4),(8,4),(5,0)]  # rhombus
B3 = [(0,0),(0,0),(1,1),(0,0)]  # only 2 distinct points
B4 = [(0,0),(0,0),(1,0),(0,1)]  # only 3 distinct points
B5 = [(1,1),(2,2),(3,3),(4,4)]  # Points on the same line
B6 = [(0,0),(2,2),(0,2)]        # Not enough points

def tests(f):
    assert(f(S1) == True)
    assert(f(S2) == True)
    assert(f(S3) == True)
    assert(f(S4) == True)
    assert(f(S5) == True)

    assert(f(B1) == False)
    assert(f(B2) == False)
    assert(f(B3) == False)
    assert(f(B4) == False)
    assert(f(B5) == False)
    assert(f(B6) == False)

def t(p):return len(set(p))-1==len(set([pow(pow(a-c,2)+pow(b-d,2),.5)for a,b in p for c,d in p]))

tests(t)

สิ่งนี้จะอธิบายเล็กน้อย แต่ความคิดโดยรวมคือมีเพียงสามระยะทางระหว่างจุดในสี่เหลี่ยม (ด้านข้าง, แนวทแยง, ศูนย์ (จุดเมื่อเทียบกับตัวเอง)):

def t(p):return len(set(p))-1==len(set([pow(pow(a-c,2)+pow(b-d,2),.5)for a,b in p for c,d in p]))

• สำหรับรายการ p ของ tuples (x, y)
• ลบรายการที่ซ้ำกันโดยใช้ set (p) จากนั้นทดสอบความยาว
• รับคะแนนรวมกันทุกครั้ง (a, b ใน p สำหรับ c, d in p)
• รับรายการระยะทางจากทุกจุดถึงจุดอื่น
• ใช้การตั้งค่าเพื่อตรวจสอบว่ามีระยะทางเฉพาะสามระยะทาง - ศูนย์ (จุดเปรียบเทียบกับตัวเอง) - ความยาวด้าน - ความยาวแนวทแยง

หากต้องการบันทึกอักขระรหัสฉัน:

• ใช้ชื่อฟังก์ชั่นถ่าน 1 ตัว
• ใช้นิยามฟังก์ชั่น 1 บรรทัด
• แทนที่จะตรวจสอบจำนวนจุดที่ไม่ซ้ำกันคือ 4 ฉันตรวจสอบว่าเป็น -1 ความยาวจุดที่แตกต่างกัน (save == 3 ==)
• ใช้ list และ tuple unpacking เพื่อรับ a, b ใน p สำหรับ c, d in p, แทนที่จะใช้ [0], a [1]
• ใช้ pow (x, .5) แทนการรวมคณิตศาสตร์เพื่อรับ sqrt (x)
• ไม่ใส่ช่องว่างหลังจาก)
• ไม่วางศูนย์นำบนลอย

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

ครั้งแรกที่ฉันลองรหัสกอล์ฟ มีน้ำใจถ้าฉันทำผิดกฎของบ้าน

Clojure, 159 ตัวอักษร

user=> (def squares
         [[[0,0] [0,1] [1,1]  [1,0]]   ; standard square
         [[0,0] [2,1] [3,-1] [1,-2]]  ; non-axis-aligned square
         [[0,0] [1,1] [0,1]  [1,0]]]) ; different order
#'user/squares
user=> (def non-squares
         [[[0,0] [0,2] [3,2] [3,0]]    ; rectangle
          [[0,0] [3,4] [8,4] [5,0]]])  ; rhombus
#'user/non-squares
user=> (defn norm
         [x y]
         (reduce + (map (comp #(* % %) -) x y)))
#'user/norm
user=> (defn square?
         [[a b c d]]
         (let [[x y z] (sort (map #(norm a %) [b c d]))]
           (and (= x y) (= z (* 2 x)))))
#'user/square?
user=> (every? square? squares)
true
user=> (not-any? square? non-squares)
true

แก้ไข: เพื่ออธิบายเล็กน้อย

• ก่อนกำหนดบรรทัดฐานซึ่งโดยทั่วไปให้ระยะห่างระหว่างสองจุดที่กำหนด
• จากนั้นคำนวณระยะทางของจุดแรกไปยังอีกสามจุด
• จัดเรียงสามระยะทาง (สิ่งนี้อนุญาตให้ลำดับของคะแนนใด ๆ )
• ระยะทางที่สั้นที่สุดทั้งสองจะต้องเท่ากับสี่เหลี่ยม
• ระยะที่สาม (ยาวที่สุด) จะต้องเท่ากับรากที่สองของผลบวกของกำลังสองของระยะทางสั้น ๆ โดยทฤษฎีบทของพีธากอรัส

(หมายเหตุ: ไม่จำเป็นต้องใช้การรูทสแควร์และด้วยเหตุนี้ในรหัสที่บันทึกไว้ด้านบน)

C #, 107 ตัวอักษร

return p.Distinct().Count()==4&&
(from a in p from b in p select (a-b).LengthSquared).Distinct().Count()==3;

จุดที่เป็นรายการของ Vector3D ที่มีจุด

คำนวณระยะทางทั้งหมดที่ยกกำลังสองระหว่างจุดทั้งหมดและหากมีสามประเภทที่แตกต่างกันอย่างแน่นอน (ต้องเป็น 0 ค่าบางค่า a และ 2 * a) และ 4 คะแนนที่แตกต่างกันจากนั้นคะแนนจะเป็นรูปสี่เหลี่ยม

Python, 66

ปรับปรุงคำตอบของ paperhorseจาก 76 เป็น 66:

def U(A):c=sum(A)/4;d=A[0]-c;return{d+c,c-d,d*1j+c,c-d*1j}==set(A)

Python 2 , 49 ไบต์

lambda l:all(1j*z+(1-1j)*sum(l)/4in l for z in l)

ลองออนไลน์!

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

ความยาวเท่ากัน (แม้ว่าจะสั้นกว่าโดยใช้ Python 3 {*l})

lambda l:{1j*z+(1-1j)*sum(l)/4for z in l}==set(l)

ลองออนไลน์!

วุลแฟรมภาษา (มาติกา) , 32 31 ไบต์

Tr[#^2]==Tr[#^3]==0&[#-Mean@#]&

ลองออนไลน์!

ทำรายการจุดที่แสดงด้วยจำนวนเชิงซ้อนคำนวณช่วงเวลากลางที่สองและสามและตรวจสอบว่าทั้งสองเป็นศูนย์

ยกเลิกแข็งแรงเล่นกอล์ฟ:

S[p_] := Total[(p - Mean[p])^2] == Total[(p - Mean[p])^3] == 0

หรือ

S[p_] := CentralMoment[p, 2] == CentralMoment[p, 3] == 0

พิสูจน์

เกณฑ์นี้ทำงานบนเครื่องบินซับซ้อนทั้งหมดไม่เพียงแค่ในจำนวนเต็มเสียน

1. ครั้งแรกเราทราบว่าช่วงเวลาส่วนกลางจะไม่เปลี่ยนแปลงเมื่อมีการแปลคะแนนร่วมกัน สำหรับชุดคะแนน

   P = Table[c + x[i] + I*y[i], {i, 4}]
   

   ช่วงเวลาส่วนกลางทั้งหมดเป็นอิสระจากc(นั่นคือเหตุผลที่พวกเขาถูกเรียกว่ากลาง ):

   {FreeQ[FullSimplify[CentralMoment[P, 2]], c], FreeQ[FullSimplify[CentralMoment[P, 3]], c]}
   (*    {True, True}    *)
   

2. ประการที่สองช่วงเวลาส่วนกลางมีการพึ่งพาการปรับขนาดที่ซับซ้อนโดยรวม (การปรับและการหมุน) ของชุดของคะแนน:

   P = Table[f * (x[i] + I*y[i]), {i, 4}];
   FullSimplify[CentralMoment[P, 2]]
   (*    f^2 * (...)    *)
   FullSimplify[CentralMoment[P, 3]]
   (*    f^3 * (...)    *)
   

   ซึ่งหมายความว่าหากช่วงเวลาส่วนกลางเป็นศูนย์การปรับและ / หรือการหมุนชุดของคะแนนจะทำให้ช่วงเวลากลางเท่ากับศูนย์

3. ประการที่สามเรามาพิสูจน์เกณฑ์สำหรับรายการคะแนนที่ได้รับการแก้ไขสองคะแนนแรก:

   P = {0, 1, x[3] + I*y[3], x[4] + I*y[4]};
   

   ส่วนจริงและจินตภาพของช่วงเวลากลางที่สองและสามภายใต้เงื่อนไขใดเป็นศูนย์

   C2 = CentralMoment[P, 2] // ReIm // ComplexExpand // FullSimplify;
   C3 = CentralMoment[P, 3] // ReIm // ComplexExpand // FullSimplify;
   Solve[Thread[Join[C2, C3] == 0], {x[3], y[3], x[4], y[4]}, Reals] // FullSimplify
   (*    {{x[3] -> 0, y[3] -> -1, x[4] -> 1, y[4] -> -1},
          {x[3] -> 0, y[3] -> 1, x[4] -> 1, y[4] -> 1},
          {x[3] -> 1/2, y[3] -> -1/2, x[4] -> 1/2, y[4] -> 1/2},
          {x[3] -> 1/2, y[3] -> 1/2, x[4] -> 1/2, y[4] -> -1/2},
          {x[3] -> 1, y[3] -> -1, x[4] -> 0, y[4] -> -1},
          {x[3] -> 1, y[3] -> 1, x[4] -> 0, y[4] -> 1}}    *)
   

   วิธีแก้ปัญหาทั้งหกนี้แสดงถึงกำลังสอง: ดังนั้นวิธีเดียวที่รายการจุดของแบบฟอร์ม{0, 1, x[3] + I*y[3], x[4] + I*y[4]}สามารถมีช่วงเวลากลางที่สองและสามเป็นศูนย์ได้เมื่อจุดสี่จุดเป็นรูปสี่เหลี่ยม

เนื่องจากคุณสมบัติการแปลการหมุนและการสเกลแสดงให้เห็นในจุดที่ 1 และ 2 ซึ่งหมายความว่าเมื่อใดก็ตามที่ช่วงเวลากลางที่สองและสามเป็นศูนย์เรามีรูปสี่เหลี่ยมในสถานะการแปล / การหมุน / การปรับขนาด ∎

ลักษณะทั่วไป

ช่วงเวลากลาง k-th ของ n-gon ปกติจะเป็นศูนย์ถ้า k ไม่สามารถหารด้วย n เงื่อนไขเหล่านี้เพียงพอจะต้องรวมกันเพื่อทำเกณฑ์ที่เพียงพอสำหรับการตรวจจับ n-gons สำหรับกรณี n = 4 มันก็เพียงพอที่จะตรวจจับศูนย์ใน k = 2 และ k = 3; สำหรับการตรวจจับเช่นรูปหกเหลี่ยม (n = 6) อาจจำเป็นต้องตรวจสอบ k = 2,3,4,5 สำหรับค่าศูนย์ ฉันไม่ได้พิสูจน์สิ่งต่อไปนี้ แต่สงสัยว่ามันจะตรวจพบ n-gon ทั่วไป:

isregularngon[p_List] :=
  And @@ Table[PossibleZeroQ[CentralMoment[p, k]], {k, 2, Length[p] - 1}]

ความท้าทายของรหัสเป็นหลักรหัสนี้เฉพาะสำหรับความยาว 4 รายการ

J, ^{31 29 27} 26

3=[:#[:~.[:,([:+/*:@-)"1/~

ตรวจสอบว่า 8 ระยะทางที่เล็กที่สุดระหว่างจุดเดียวกันหรือไม่ ตรวจสอบว่ามีสามชนิดของระยะทางระหว่างจุด (ศูนย์ความยาวด้านและความยาวแนวทแยงมุม)

f 4 2 $ 0 0 2 1 3 _1 1 _2
1
f 4 2 $ 0 0 0 2 3 2 3 0
0

4 2 $ เป็นวิธีการเขียนอาร์เรย์ใน J

Smalltalk for 106 characters

s:=Set new.
p permutationsDo:[:e|s add:((e first - e second) dotProduct:(e first - e third))].
s size = 2

where p is a collection of points, e.g.

p := { 0@0. 2@1. 3@ -1. 1@ -2}. "twisted square"

I think the math is sound...

Mathematica, 123 characters (but you can do better):

Flatten[Table[x-y,{x,a},{y,a}],1]
Sort[DeleteDuplicates[Abs[Flatten[Table[c.d,{c,%},{d,%}]]]]]
%[[1]]==0&&%[[3]]/%[[2]]==2

Where 'a' is the input in Mathematica list form, eg: a={{0,0},{3,4},{8,4},{5,0}}

The key is to look at the dot products between all the vectors and note that they must have exactly three values: 0, x, and 2*x for some value of x. The dot product checks both perpendicularity AND length in one swell foop.

I know there are Mathematica shortcuts that can make this shorter, but I don't know what they are.

Haskell, "wc -c" reports 110 characters. Does not check that the input has 4 elements.

import Data.List
k [a,b]=2*a==b
k _=0<1
h ((a,b):t)=map (\(c,d)->(a-c)^2+(b-d)^2) t++h t
h _=[]
j=k.nub.sort.h

I tested on

test1 = [(0,0),(3,4),(-4,3),(-1,7)] -- j test1 is True
test2 = [(0,0),(3,4),(-3,4),(0,8)]  -- j test2 is False