29

एक फ़ंक्शन लिखें जो विमान पर 4 बिंदुओं को इनपुट के रूप में लेता है और यदि 4 अंक एक वर्ग बनाते हैं तो यह सही है। अंक का पूर्ण मूल्यों के साथ अभिन्न समन्वय होगा <1000।

आप इनपुट के रूप में 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)

code-golf math

— कीथ रान्डेल
स्रोत

हम यहां 3 डी पॉइंट्स पर बात कर रहे हैं, है ना?

— gnibbler

3

@gnibbler "पर विमान" सवाल कर 3 डी का हिस्सा संभावना नहीं बताते हैं।

— जेबी

क्या अंक दिए गए हैं?

— जेबी

@ जेबी, मैं सोच रहा था कि इसका मतलब एक विमान पर था, लेकिन मैंने किसी कारण से 3 डी अंतरिक्ष में एक विमान की कल्पना की :)

— gnibbler

1

@eBusiness: -1 कि आपने 11 वोट डाले हैं: उनमें से 7 नीचे हैं।

— आठवीं

12

पायथन 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))

फंक्शन एस अपने इनपुट (ए) के रूप में जटिल संख्याओं की एक सूची लेता है। यदि हम केंद्र और एक वर्ग के एक कोने को जानते हैं, तो हम केंद्र बिंदु (c) के चारों ओर कोने 90,180 और 270 डिग्री को घुमाकर वर्ग का पुनर्निर्माण कर सकते हैं। मूल के बारे में 90 डिग्री से जटिल विमान रोटेशन पर बिंदु को i से गुणा करके किया जाता है । यदि हमारे मूल आकार और पुनर्निर्मित वर्ग में समान बिंदु हैं तो यह एक वर्ग होना चाहिए था।

— paperhorse
स्रोत

कुछ अनुकूलन: 1) "is_square" 2 के बजाय "S" का उपयोग करें) का उपयोग करके इसे एक पंक्ति में रखें; 3) 4 दिशाओं पर सीधे "i में (1,1j, -1, -1j)" 4) के लिए सेट तर्क में [] की जरूरत नहीं है।

— कीथ रान्डेल

धन्यवाद कीथ (मैं बाहर छोड़ दिया (3) के रूप में यह मेरे कोड के रूप में एक ही लंबाई प्रतीत होता है)

— पेपरहॉर्स

2

@ कीथ रान्डेल - जब जेबी के पास बहुत कम समाधान है तो इसे क्यों स्वीकार किया गया?

— aaaaaaaaaaaa

1

दो कारण। एक, जे हमेशा जीत जाएगा। इसलिए मुझे भाषा से थोड़ा सामान्य करना पसंद है। इसके अलावा, मैं इस जवाब को बेहतर पसंद करता हूं क्योंकि यह उसी समस्या से ग्रस्त नहीं है, जो केवल-दूरी के जवाब के रूप में है जहां अन्य आंकड़े (वास्तव में, केवल तर्कहीन) झूठी गलतियां देते हैं।

— कीथ रान्डेल

5

@ कीथ रान्डेल - प्रश्न से उद्धरण: "अंक में अभिन्न निर्देशांक होंगे" "सबसे छोटा कोड जीतता है।" यह पूरी तरह से ठीक है यदि आप एक उत्तर का चयन करने के लिए अलग-अलग मानदंड चुनते हैं, यहां तक कि व्यक्तिपरक मानदंड भी, लेकिन फिर आपको प्रश्न में यह बताना चाहिए।

— आआआआआआआआआआ आआआआआ

13

जे, २ 27 १ 17 २५ २ 27

J में वास्तव में फ़ंक्शंस नहीं हैं, लेकिन यहां एक जटिल क्रिया है जो जटिल समतल से बिंदुओं का एक वेक्टर लेती है:

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

विधि माइकल स्पेंसर का एक मिश्रण है (पूरी तरह से इंटर-वर्टेक्स लंबाई पर काम करता है; लेकिन वह वर्तमान में मेरे rhombus2 को विफल कर रहा है) और एलेक्स (सेट्स के आकारों की जांच) काम करता है। बाएं से दाएं पढ़ना:

-/~ सभी बिंदु अंतरों की गणना करें
, समतल करना
| परिमाण निकालें
/:~ छांटना
#/.~ नब और गिनती
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एक द्विपद वितरण की तरह दिखता है।

— जेबी
स्रोत

क्या आप इस भाषा से जुड़ सकते हैं?

— सरगुन ढिल्लन

1

@gnibbler: क्यों नहीं? मुझे पूरा यकीन है कि यह करता है।

— 12

1

दरअसल, एक गैर-वर्गीय आंकड़ा जो आपके द्वारा जांच की जाने वाली शर्तों को संतुष्ट करता है, एक नियमित त्रिकोण प्लस एक विस्तारित लंबाई के मध्य वाले त्रिकोण के सिरे से एक तरफ की लंबाई इंगित करता है। लेकिन प्रश्न पूर्णांक इनपुट के लिए कहा जाता है, इसलिए मुझे लगता है कि समाधान ठीक है।

— आआआआआआआआआआआ आआआआआआ

1

आह अच्छा। मैं 4 वें बिंदु के केंद्र के साथ समबाहु त्रिकोणों के बारे में सोच रहा था, लेकिन यह पूर्णांक सह-निर्देश द्वारा खारिज किया गया है

— gnibbler

1

आप इसे स्पष्ट परिभाषा में बदलकर 3 वर्णों को काट सकते हैं: 3 :'4 8 4-:#/.~/:~|,-/~y'

— isawdrones

5

पायथन, 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)

— mbomb007
स्रोत

मुझे लगता है कि प्रश्न को स्पष्ट रूप से अंकों की एक सूची कहा गया है, न कि एक वेक्टर।

— सरगुन ढिल्लन

झूठी सकारात्मक।

— आआआआआआआआआआआ आआआआआ

1

तो (0 + 0j, 0 + 0j, 1 + 0j, 0 + 1j) एक वर्ग है?

— मगहर

मेरा rhombus 2 1 +/- 60j नहीं है, यह -1, 0, 1 के मानों के लिए exp (i j pi / 3) की तरह अधिक है । ध्यान दें कि जैसा कि eBusiness ने बताया कि वे सभी अभिन्न नहीं हो सकते हैं, इसलिए वास्तव में नहीं सवाल का दायरा।

— जेबी

3

हास्केल, 100 वर्ण

यहाँ है कि मैं Haskell में JB का J समाधान कैसे लिखूँगा। गैर-पात्र पात्रों को हटाकर पठनीयता को नुकसान पहुंचाने के प्रयास के साथ, यह लगभग 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]

चलो यह सुनिश्चित करने के लिए क्विकचेक का उपयोग करें कि यह मनमाना वर्गों को स्वीकार करता है, एक शीर्ष पर (x, y) और किनारे वेक्टर (ए, बी) के साथ:

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.

1

फ़ंक्शन को अनियंत्रित करके 11 वर्ण सहेजें d। s l=[4,8,4]==(map length.group.sort)[(x-a)^2+(y-b)^2|(x,y)<-l,(a,b)<-l]

— रे

3

फ़ैक्टर

फैक्टर प्रोग्रामिंग भाषा में एक कार्यान्वयन :

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

— mrjbq7
स्रोत

3

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

चलिए थोड़ा और समझाते हैं।

पहले हम एक मानदंड को परिभाषित करते हैं:

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

यदि हमारे पास एक वर्ग है तो इन सभी स्थितियों को रखना होगा:

एबीसी एक सही त्रिकोण है
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

संपादित करें: एम .गोविन्नी की सलाह का पालन किया।

— bltxd
स्रोत

अच्छा लगा। हमने यहां बहुत ज्यादा OCaml नहीं देखा है :)

— Eclipx

n20 अक्षरों में कमी के लिए एक ऑपरेटर का उपयोग करें 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:।

— मटियास जियोवन्नी

2

पायथन (105)

अंक का प्रतिनिधित्व (x,y)टुपल्स द्वारा किया जाता है। अंक किसी भी क्रम में हो सकते हैं और केवल वर्गों को स्वीकार करते हैं। sअंकों के बीच जोड़ीदार (गैर-शून्य) दूरियों की एक सूची बनाता है । दो अद्वितीय समूहों में कुल मिलाकर 12 दूरी होनी चाहिए।

def f (p): s = filter (कोई नहीं, (xz) ** 2+ (yw) ** 2for x, y in z for z, w in p]); वापसी len (s) == 12and len ( सेट (रों)) == 2

— होआ लॉन्ग टैम
स्रोत

आप फ़िल्टर छोड़ सकते हैं और जांच सकते हैं कि क्या सेट की लेन 3 है। यह मेरे जवाब के रूप में एक ही झूठी सकारात्मक समस्या से ग्रस्त है।

— gnibbler

>>> f ([(0,0), (0,4), (2,2), ((2,2)]] = सही

— सरगुन ढिल्लों

2

f([(0,0),(0,4),(2,2),(-2,2)]) एक वर्ग है

— gnibbler

2

पायथन - 42 वर्ण

अंक के लिए जटिल संख्याओं का उपयोग करने के लिए इसके सुधार की तरह दिखता है

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

जहां ए = [(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)]

— gnibbler
स्रोत

>>> A=[(0,0),(0,0),(1,1),(0,0)] >>> len(set((a-c)**2+(b-d)**2 for(a,b),(c,d)in combinations(A,2)))==2 True

— सरगुन ढिल्लन

@ सरगुन, यह विशेष श्रेणी के इनपुट का एक विशेष मामला है जो काम नहीं करता है। मैं एक फिक्स के बारे में सोचने की कोशिश कर रहा हूं जो उत्तर के आकार को नहीं उड़ाता है। इस बीच, विफल मामलों के सामान्य वर्ग को बाहर कर सकते हैं?

— जिब्बलर

A=[(0,0),(0,4),(2,2),(-2,2)]; len(set((a-c)**2+(b-d)**2 for(a,b),(c,d)in combinations(A,2)))==2

— सरगुन ढिल्लन

@ सरगुन: वह उदाहरण एक वर्ग है।

— कीथ रान्डेल

डुप्लिकेट बिंदुओं से छुटकारा पाने के लिए आप (-01) जोड़ सकते हैं

— कीथ रान्डेल

2

सी # - बिल्कुल कम नहीं। LINQ का दुरुपयोग करना। इनपुट में बिंदुओं के अलग-अलग दो-संयोजनों का चयन करता है, उनकी दूरियों की गणना करता है, फिर पुष्टि करता है कि उनमें से चार समान हैं और केवल एक अन्य विशिष्ट दूरी मान है। पॉइंट एक ऐसा वर्ग है जिसमें दो डबल सदस्य होते हैं, X और Y आसानी से टपल हो सकते हैं, लेकिन meh।

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

— डैनियल कॉफ़मैन
स्रोत

2

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]))};

— Arek
स्रोत

लेकिन सिर्फ इसलिए कि बाउंडिंग बॉक्स चौकोर है, इसका मतलब यह नहीं है कि पॉइंट एक वर्ग में झूठ हैं। आवश्यक है लेकिन पर्याप्त स्थिति नहीं है। विचार करें (0,0), (5,5), (10,0), (0, -5)। बाउंडिंग बॉक्स चौकोर (0:10, -5: 5) है; आंकड़ा नहीं है।

— फ्लोरिस

2

के - 33

जेबी द्वारा जे समाधान का अनुवाद :

{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

— isawdrones
स्रोत

2

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

— मतिअस जियोवन्निनी
स्रोत

2

गणितज्ञ 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 *)

यह सच है
यह सच है
यह सच है
झूठी
झूठी
झूठी
झूठी

एनबी: \[And]गणितज्ञ में एकल चरित्र है।

— DavidC
स्रोत

1

क्या आप मुझे बता रहे हैं कि Mathematica में एक अंतर्निहित IsSquare फ़ंक्शन नहीं है?

— गुडगुई

2

जेली , 8 बाइट्स

_Æm×ıḟƊṆ

इसे ऑनलाइन आज़माएं!

कमांड लाइन तर्क के रूप में जटिल संख्याओं की एक सूची लेता है। प्रिंटों 1या 0।

_Æ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.

यह पुनर्जीवित करने के लिए एक सुखद चुनौती की तरह लगता है!

— लिन
स्रोत

1

हास्केल (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 डिग्री के हैं
सभी पक्षों की लंबाई समान है

कोड और परीक्षणों की अवहेलना की

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

— दान बर्टन
स्रोत

1

स्काला (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)}

— गैरेथ
स्रोत

1

जावास्क्रिप्ट 144 वर्ण

गणितीय रूप से जे बी उत्तर के बराबर। यह 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])
}

— aaaaaaaaaaaa
स्रोत

1

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

यह eBuisness के जावास्क्रिप्ट उत्तर पर आधारित है ।

— केविन ब्राउन
स्रोत

यह समस्या बयान से थोड़ा अस्पष्ट है कि अंक क्रम में आएंगे। मैं पूछता हूँ।

— जेबी

1

मुझे नहीं लगता कि यह ठीक से बहुत सारे मामलों को संभाल लेगा। उदाहरण के लिए, यह गलत तरीके से वर्गों के रूप में लेबल करेगा।

— कीथ रान्डेल

जावास्क्रिप्ट के जवाबों में से एक से मेल करने के लिए यह अपडेट किया गया, सभी मामलों को संभालना चाहिए।

— केविन ब्राउन

1

जावास्क्रिप्ट 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))

जेबी के जवाब का एक और कार्यान्वयन। जावास्क्रिप्ट 1.7 / 1.8 सुविधाएँ (अभिव्यक्ति बंद, सरणी समझ, विनाशकारी असाइनमेंट)। इसके अलावा एब्स -टू-स्ट्रिंग ज़बरदस्ती और एक regexp के साथ संख्यात्मक के साथ ~~ज़बरदस्ती undefinedकरने के लिए गालियां (डबल बिटवाइज़ नहीं ऑपरेटर) , यह जांचने के लिए कि लंबाई मायने रखती है [4, 8, 4](यह मानता है कि वास्तव में 4 अंक पास हैं)। अल्पविराम ऑपरेटर का दुरुपयोग एक पुरानी ओफ़्स्कुलेटेड सी चाल है।

टेस्ट:

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

— ecatmur
स्रोत

1

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

जेबी के जवाब के रूप में एक ही एल्गोरिदम ।

टेस्ट जैसे:

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

trueसत्य के लिए आउटपुट और असत्य के लिए रिक्त

— Nemo157
स्रोत

GoRuby के बारे में कभी नहीं सुना। क्या इसके बारे में कुछ भी आधिकारिक लिखा गया है? stackoverflow.com/questions/63998/hidden-features-of-ruby/…

— जोनास एल्फस्ट्रॉम

@ जोनास: मैंने इसके बारे में वास्तव में कुछ भी आधिकारिक नहीं देखा है, मैंने जो सबसे अच्छा ब्लॉग पोस्ट देखा है वह यह है । मैं वास्तव में इसे बनाने और काम करने में सक्षम नहीं था, लेकिन एक विकल्प सिर्फ एक ही फ़ोल्डर में गोल्फ-ruby -r ./golf-prelude.rb FILE_TO_RUN.rb प्रोल्यूड की प्रतिलिपि बनाना और चलाना है और यह उसी तरह से काम करेगा।

— निमो 157

यह sortपहले आवश्यक नहीं है group_by। .sort.group_by {...}के रूप में लिखा जाना चाहिए.group_by {...}

— user102008

1

पायथन 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)] में बिंदु tuples की सूची ले जाएगा, और डुप्लिकेट, या अंकों की गलत संख्या को संभाल सकता है। यह अन्य अजगर जवाब की तरह जटिल बिंदुओं की आवश्यकता नहीं है।

आप इसे इस तरह से परख सकते हैं:

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

tuples की सूची p के लिए (x, y)
सेट (पी) का उपयोग करके डुप्लिकेट निकालें और फिर लंबाई का परीक्षण करें
अंकों के हर संयोजन को प्राप्त करें (a, b in p for c, d in p)
हर बिंदु से हर दूसरे बिंदु की दूरी की सूची प्राप्त करें
यह जांचने के लिए सेट का उपयोग करें कि केवल तीन अद्वितीय दूरी हैं - शून्य (खुद की तुलना में बिंदु) - साइड लंबाई - विकर्ण लंबाई

कोड वर्ण सहेजने के लिए मैं हूं:

1 चार फ़ंक्शन नाम का उपयोग करना
1 लाइन फ़ंक्शन परिभाषा का उपयोग करना
अद्वितीय बिंदुओं की संख्या की जांच करने के बजाय 4 है, मैं जांचता हूं कि यह -1 अलग-अलग बिंदु लंबाई है (== 3 == बचाता है)
एक [0], एक [1] का उपयोग करने के बजाय, c, p के लिए p, d, के लिए p और b को प्राप्त करने के लिए सूची और tuple का उपयोग न करें।
sqrt पाने के लिए गणित को शामिल करने के बजाय pow (x, .5) का उपयोग करता है (x)
के बाद रिक्त स्थान नहीं डालना)
फ्लोट पर एक अग्रणी शून्य नहीं डाल रहा है

मुझे डर है कि कोई ऐसा टेस्ट केस खोज सकता है जो इसे तोड़ दे। तो कृपया और ठीक करें। उदाहरण के लिए, मैं सिर्फ एक एब्स करने के बजाय तीन दूरी के लिए जांच करता हूं () और साइड की लंबाई और कर्ण के लिए जांच, एक त्रुटि की तरह लगता है।

पहली बार मैंने कोड गोल्फ की कोशिश की है। अगर मैंने घर के किसी नियम को तोड़ा है तो दयालु बनो।

— Jagu
स्रोत

1

क्लोजर, 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

संपादित करें: थोड़ा समझाने के लिए भी।

पहले एक मानदंड को परिभाषित करें जो मूल रूप से दो दिए गए बिंदुओं के बीच की दूरी देता है।
फिर दूसरे तीन बिंदुओं पर पहले बिंदु की दूरी की गणना करें।
तीन दूरियों को छाँटें। (यह अंक के किसी भी क्रम की अनुमति देता है।)
दो सबसे छोटी दूरी एक वर्ग के बराबर होनी चाहिए।
तीसरी (सबसे लंबी) दूरी पाइथागोरस के प्रमेय द्वारा छोटी दूरी के वर्गों के योग के वर्गमूल के बराबर होनी चाहिए।

(नोट: वर्गमूल की आवश्यकता नहीं है और इसलिए ऊपर सहेजे गए कोड में है।)

— Meikel
स्रोत

1

सी #, 107 वर्ण

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

जहाँ पॉइंट्स में वेक्टर 3 डी की सूची होती है।

सभी बिंदुओं के बीच में विभाजित सभी दूरी की गणना करता है, और अगर बिल्कुल तीन अलग-अलग प्रकार हैं (0 होना चाहिए, कुछ मूल्य ए और 2 * ए) और 4 अलग-अलग बिंदुओं के बाद अंक एक वर्ग बनाते हैं।

— आप
स्रोत

1

पायथन, 66

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)

— मोनिका को बहाल करो
स्रोत

1

पायथन 2 , 49 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट के रूप में चार जटिल संख्याओं की सूची लेता है। औसत के आसपास प्रत्येक बिंदु 90 डिग्री घूमता है, और जांचता है कि प्रत्येक परिणामी बिंदु मूल सूची में है।

समान लंबाई (हालांकि पायथन 3 का उपयोग करके कम {*l})।

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

इसे ऑनलाइन आज़माएं!

— XNOR
स्रोत

यदि छोटा है तो पायथन 3 का उपयोग क्यों न करें? इसके अलावा, अगर इसे पाइथन में मनमानी सच्चाई / झूठे मूल्यों को वापस करने की अनुमति दी जाती है, तो इसका ^उपयोग किया जा सकता है ==।

— जोएल

@ जॉय पायथन 2 ज्यादातर वरीयता है, और यह 2011 से एक बहुत पुरानी चुनौती है जब पायथन 2 को पायथन गोल्फिंग बहुत सुंदर माना गया था। और चुनौती सच या झूठ को वापस करने के लिए कहती है, इसलिए मैं इसके साथ फंस गया। यदि यह आज पोस्ट किया गया था, तो यह शायद सचाई / झूठी या दो अलग-अलग मूल्यों में से एक को आउटपुट करने के लिए निर्दिष्ट करेगा, और यह डिफ़ॉल्ट रूप से मानने के लिए ओके द्वारा भी हो सकता है।

— xnor

1

वोल्फ्राम भाषा (गणितज्ञ) , 32 31 बाइट्स

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

इसे ऑनलाइन आज़माएं!

जटिल संख्याओं द्वारा दर्शाए गए बिंदुओं की एक सूची लेता है, दूसरे और तीसरे केंद्रीय क्षण की गणना करता है, और जांचता है कि दोनों शून्य हैं।

संयुक्त राष्ट्र के golfed:

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

या

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

प्रमाण

यह मानदंड पूरे जटिल विमान पर काम करता है, न कि केवल गाऊसी पूर्णांक पर ।

सबसे पहले, हम ध्यान दें कि जब बिंदुओं का एक साथ अनुवाद किया जाता है तो केंद्रीय क्षण नहीं बदलते हैं। अंकों के एक सेट के लिए
```
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}    *)
```
दूसरा, केंद्रीय क्षणों के बिंदुओं के समग्र जटिल स्केलिंग (स्केलिंग और रोटेशन) पर एक सरल निर्भरता है:
```
P = Table[f * (x[i] + I*y[i]), {i, 4}];
FullSimplify[CentralMoment[P, 2]]
(*    f^2 * (...)    *)
FullSimplify[CentralMoment[P, 3]]
(*    f^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 में प्रदर्शन किया गया, इसका मतलब है कि किसी भी समय दूसरे और तीसरे केंद्रीय क्षण शून्य हैं, हमारे पास कुछ अनुवाद / रोटेशन / स्केलिंग राज्य में एक वर्ग है। ∎

सामान्यकरण

नियमित n-gon का k-th केंद्रीय क्षण शून्य है यदि k n द्वारा विभाज्य नहीं है। एन-गोंन्स का पता लगाने के लिए पर्याप्त मानदंड बनाने के लिए इन शर्तों में से किसी को जोड़ा जाना चाहिए। केस n = 4 के लिए k = 2 और k = 3 में शून्य का पता लगाना पर्याप्त था; पता लगाने के लिए, उदाहरण के लिए, हेक्सागोन्स (एन = 6) शून्य के लिए k = 2,3,4,5 की जांच करना आवश्यक हो सकता है। मैंने निम्नलिखित सिद्ध नहीं किया है, लेकिन संदेह है कि यह किसी भी नियमित n-gon का पता लगाएगा:

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

कोड चुनौती अनिवार्य रूप से यह कोड लंबाई -4 सूचियों के लिए विशेष है।

— रोमन
स्रोत

समाधान काफी दिलचस्प लग रहा है। क्या आप बता सकते हैं कि यह सही उत्तर क्यों देता है?

— जोएल

@Joel मैंने एक प्रमाण जोड़ा है।

— रोमन

बहुत बहुत धन्यवाद। यह आदर्श होगा कि इस अच्छे समाधान का अधिक सहज गणितीय स्पष्टीकरण हो सकता है।

— जोएल

@ जोल मैं आपको वह धागा दे सकता हूं जिसने मुझे इस समाधान तक पहुंचाया। मैंने यह देखना शुरू कर दिया कि वर्गों (निर्देशांक की सूची, जटिल संख्या के रूप में) में एक सहसंयोजक मैट्रिक्स है जो इकाई मैट्रिक्स के आनुपातिक है; हालाँकि, यह स्थिति पर्याप्त (झूठी सकारात्मक) नहीं है। बिंदु समरूपता के किसी भी ढांचे के लिए तीसरा केंद्रीय क्षण शून्य होना चाहिए। इसलिए मैंने दूसरे और तीसरे केंद्रीय क्षणों में एक शर्त रखने के लिए जटिल प्रतिनिधित्व पर स्विच किया, और मेरे आश्चर्य में यह निकला कि दूसरा केंद्रीय क्षण वर्गों के लिए शून्य है।

— रोमन

महान। इस समाधान का रास्ता दिखाने के लिए धन्यवाद।

— जोएल

0

जे, ^{३१ २ ९ २} , २६

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 $ जे में एक सरणी लिखने का एक तरीका है।

— Eelvex
स्रोत

यह रोम्बस परीक्षण में विफल रहता है।

— JB

@ जेबी: मेरे पास एक टाइपो था। मैंने वैसे भी अब तरीका बदल दिया है।

— बारहवीं

बेनाम: Eeew ... तुम वही तरीका मैं चोरी कर रहा था ले जा रहे हैं। मेरे संस्करण के छोटे को छोड़कर: p

— JB

@ जेबी: सच में? मैंने उस पर ध्यान नहीं दिया। और कौन चेक करता है (3 == #distances)?

— बारहवीं

@ जेबी: ओइक ... 2. के संयोजन के लिए कुछ जांच: - /

— एवेक्स मार्क्स

0

106 अक्षरों के लिए स्मॉलटाक

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

जहाँ p अंक का एक संग्रह है, उदा

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

मुझे लगता है कि गणित ध्वनि है ...

2 अलग-अलग डॉट उत्पादों के लिए जाँच करने से इसमें कटौती नहीं होती है। एक ही स्थिति में रखे गए बिंदु गलत सकारात्मकता उत्पन्न कर सकते हैं।

— आआआआआआआआआआआआ आआआआआ

0

गणितज्ञ, 123 वर्ण (लेकिन आप बेहतर कर सकते हैं):

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

जहां 'क' गणितज्ञ सूची रूप में इनपुट है, उदाहरण के लिए: a={{0,0},{3,4},{8,4},{5,0}}

कुंजी सभी वैक्टर के बीच डॉट उत्पादों को देखना है और ध्यान दें कि उनके पास x के कुछ मूल्य के लिए 0, x और 2 * x के बिल्कुल तीन मान होने चाहिए। डॉट उत्पाद लंबवत और लम्बाई दोनों की जाँच करता है।

मुझे पता है कि गणितज्ञ शॉर्टकट हैं जो इसे छोटा बना सकते हैं, लेकिन मुझे नहीं पता कि वे क्या हैं।

— barrycarter
स्रोत

मुझे लगता है कि यह गलत है, लेकिन मैं यह नहीं समझ सकता कि कोड क्या करता है।

— आआआआआआआआआआआ आआआआआआ

यह 4 बिंदुओं के बीच सभी वैक्टरों की गणना करता है, सभी डॉट उत्पादों (निरपेक्ष मूल्य) लेता है, और परिणाम को एक्स के कुछ मूल्य के लिए 0, x, 2 * x से युक्त करने की अपेक्षा करता है।

— बैरीकेटर 16

तो 16 वैक्टर -> 256 डॉट उत्पाद, और आप जांचते हैं कि उच्च मूल्य 2 गुना कम है, लेकिन आप नहीं जानते कि प्रत्येक मूल्य के कितने हैं। क्या यह सही समझा गया है?

— आआआआआआआआआआ आआआआआ आआआआआ

हां, यह मेरे एल्गोरिथम का सही वर्णन करता है। और मुझे अब लगता है कि आप सही हैं: आप एक ऐसा परिदृश्य बना सकते हैं जिसमें सभी 3 मान हों, लेकिन सही मात्रा में नहीं। चूहे। हालांकि फिक्सेबल होना चाहिए?

— बैरीकेटर

@barrycarter आप का उपयोग करके पात्रों को बचा सकता है Unionबजाय Sort@DeleteDuplicates। मैंने आपकी 3 पंक्तियों को भी एक साथ रखा है:

#[[1]] == 0 && #[[3]]/#[[2]] == 2 &[  Union@Abs@Flatten[Table[c.d, {c, #}, {d, #}]] &[   Flatten[Table[x - y, {x, a}, {y, a}], 1]]]

— डेविड

0

हास्केल, "wc -c" 110 वर्णों की रिपोर्ट करता है। यह जांच नहीं करता है कि इनपुट में 4 तत्व हैं।

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

मैंने परीक्षण किया

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

— क्रिस कुकलेविक
स्रोत

ध्यान दें उपरोक्त को कभी भी एक बिंदु से दूरी नहीं मिलती है, इसलिए 0 की दूरी की उपस्थिति इनपुट सूची में एक दोहराया बिंदु को दर्शाती है, और यह क्रमबद्ध सूची में k [0, b] के रूप में दिखाई देगा इसलिए 2 * 0 == b हमेशा विफल रहेगा क्योंकि b 0. के समान नहीं हो सकता है

— क्रिस कुक्लिविज़

निर्धारित करें कि 4 अंक एक वर्ग बनाते हैं

पायथन 176 90 79 बाइट्स

जे, २ 27 १ 17 २५ २ 27

पायथन, 71 42

हास्केल, 100 वर्ण

फ़ैक्टर

पायथन (105)

पायथन - 42 वर्ण

के - 33

OCaml + बैटरियों, 132 वर्ण

गणितज्ञ 65 80 69 66

जेली , 8 बाइट्स

हास्केल (212)

स्काला (146 अक्षर)

जावास्क्रिप्ट 144 वर्ण

PHP, 161 158 अक्षर

जावास्क्रिप्ट 1.8, 112 अक्षर

GoRuby - 66 वर्ण

सी #, 107 वर्ण

पायथन, 66

पायथन 2 , 49 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 32 31 बाइट्स

प्रमाण

सामान्यकरण

जे, ३१ २ ९ २ , २६

106 अक्षरों के लिए स्मॉलटाक

गणितज्ञ, 123 वर्ण (लेकिन आप बेहतर कर सकते हैं):

जे, ^{३१ २ ९ २} , २६