Écrivez une fonction qui prend 4 points sur le plan en entrée et renvoie vrai si les 4 points forment un carré. Les points auront des coordonnées intégrales avec des valeurs absolues <1000.

Vous pouvez utiliser toute représentation raisonnable des 4 points en entrée. Les points ne sont pas fournis dans un ordre particulier.

Le code le plus court gagne.

Exemples de carrés:

(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

Exemple de non-carrés:

(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

Vous pouvez retourner vrai ou faux pour le carré dégénéré (0,0),(0,0),(0,0),(0,0)

Python 176 90 79 octets

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

La fonction S prend une liste de nombres complexes comme entrée (A). Si nous connaissons à la fois le centre et un coin d'un carré, nous pouvons reconstruire le carré en tournant le coin de 90 180 et 270 degrés autour du point central (c). Sur le plan complexe, la rotation de 90 degrés autour de l'origine se fait en multipliant le point par i . Si notre forme d'origine et le carré reconstruit ont les mêmes points, cela doit être un carré.

J, 28 17 25 27

J n'a pas vraiment de fonctions, mais voici un verbe monadique qui prend un vecteur de points du plan complexe:

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

La méthode est un mélange de Michael Spencer (travail uniquement sur les longueurs inter-vertex; mais il échoue actuellement à mon losange2) et Eelvex (vérifiez les tailles des ensembles). Lecture de droite à gauche:

• -/~ calculer toutes les différences de points
• , aplatir
• | extraire la magnitude
• /:~ Trier
• #/.~ nub and count
• 4 8 4 -:doit avoir exactement 4 équidistances (à 0), 8 un peu plus grandes (longueur 1, côtés), 4 plus grandes encore (longueur sqrt 2, diagonales)

Manifestation:

   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

Pour mémoire, ma méthode précédente (requis sommets ordonnés, mais pouvait détecter des polygones réguliers de n'importe quel ordre):

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

Voir l'historique pour l'explication et la démo. La méthode actuelle pourrait probablement être étendue à d'autres polygones, ce 4 8 4qui ressemble beaucoup à une distribution binomiale.

Python, 71 42

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

Mise à jour 1) pour exiger 4 points différents (donnerait auparavant des faux positifs pour les points répétés - y en a-t-il d'autres?) 2) pour définir une fonction par spécification

Pour un carré, le vecteur entre deux points quelconques doit être 0 (le même point), un côté ou une diagonale. Ainsi, l'ensemble de la magnitude de ces vecteurs doit avoir une longueur de 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 caractères

Voici comment j'écrirais la solution J de JB dans Haskell. Sans aucune tentative de nuire à la lisibilité en supprimant les caractères non essentiels, il s'agit d'environ 132 caractères:

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]

Vous pouvez le réduire à 100 en supprimant les espaces en excès et en renommant certaines choses

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]

Utilisons QuickCheck pour nous assurer qu'il accepte des carrés arbitraires, avec un sommet en (x, y) et un vecteur de bord (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)]

L'essayer dans ghci:

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

Oh oui, le carré vide n'est pas considéré comme un carré ici, nous allons donc réviser notre test:

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

Et réessayez:

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

Facteur

Une implémentation dans le langage de programmation Factor :

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 ;

Et quelques tests unitaires:

[ 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

Courez comme ceci:

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

Désobfusquons et expliquons un peu.

Nous définissons d'abord une norme:

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

Vous remarquerez qu'il n'y a pas d'appel à sqrt, ce n'est pas nécessaire ici.

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

Ici a, b, c et d sont des points. Nous supposons que ces points sont présentés comme suit:

a - b
| / |
c - d

Si nous avons un carré, toutes ces conditions doivent être remplies:

• abc est un triangle rectangle
• bcd est un triangle rectangle
• les petits côtés de chaque triangle rectangle ont les mêmes normes

Notez que ce qui suit est toujours valable:

is_square_with_fixed_layout r s t u = is_square_with_fixed_layout r t s u

Nous utiliserons cela pour simplifier notre fonction de test ci-dessous.

Puisque notre entrée n'est pas ordonnée, nous devons également vérifier toutes les permutations. Sans perte de généralité on peut éviter de permuter le premier point:

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

Après simplification:

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

Edit: suivi les conseils de M.Giovannini.

Python (105)

Les points sont représentés par des (x,y)tuples. Les points peuvent être dans n'importe quel ordre et n'acceptent que les carrés. Crée une liste s,, de paires (non nulles) de distances entre les points. Il devrait y avoir 12 distances au total, en deux groupes uniques.

def f (p): s = filtre (Aucun, [(xz) ** 2+ (yw) ** 2 pour x, y en p pour z, w en p]); renvoyer len (s) == 12et len ​​( ensemble (s)) == 2

Python - 42 caractères

On dirait que c'est une amélioration d'utiliser des nombres complexes pour les points

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

où A = [(11 + 13j), (14 + 12j), (13 + 9j), (10 + 10j)]

ancienne réponse:

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

Les points sont spécifiés dans n'importe quel ordre sous forme de liste, par exemple

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

C # - pas exactement court. Abuser de LINQ. Sélectionne deux combinaisons distinctes de points dans l'entrée, calcule leurs distances, puis vérifie qu'exactement quatre d'entre eux sont égaux et qu'il n'y a qu'une seule autre valeur de distance distincte. Point est une classe avec deux membres doubles, X et Y. Pourrait facilement être un tuple, mais 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 );

PHP, 82 caractères

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

Traduction de la solution J par JB :

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

K souffre ici de ses mots réservés ( _sqret _sqrt).

Essai:

  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 + Batteries, 132 caractères

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

(regardez, Ma, pas d'espaces!) La compréhension de qla liste forme la liste des normes au carré pour chaque paire distincte de points non ordonnés. Un carré a quatre côtés égaux et deux diagonales égales, les longueurs carrées de ce dernier étant le double des longueurs carrées du premier. Puisqu'il n'y a pas de triangles équilatéraux dans le réseau entier, le test n'est pas vraiment nécessaire, mais je l'inclus pour être complet.

Tests:

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

Mathematica 65 80 69 66

Vérifie que le nombre de distances inter-points distinctes (sans compter la distance d'un point à lui-même) est 2 et que la plus courte des deux n'est pas 0.

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

Usage

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

Vrai
Vrai
Vrai
Faux
Faux
Faux
Faux

NB: \[And]est un caractère unique dans Mathematica.

Gelée , 8 octets

_Æm×ıḟƊṆ

Essayez-le en ligne!

Prend une liste de nombres complexes comme argument de ligne de commande. Imprime 1ou 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.

Cela semble être un défi agréable à revivre!

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

Première tentative naïve. Vérifie les deux conditions suivantes pour toutes les permutations de la liste de points d'entrée (où une permutation donnée représente, disons, un ordre des points dans le sens horaire):

• tous les angles sont de 90 degrés
• tous les côtés sont de la même longueur

Code et tests désobfusqués

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

Scala (146 caractères)

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

JavaScript 144 caractères

Mathématiquement égal à la réponse J Bs. Il génère les 6 longueurs et affirme que les 2 plus grandes sont égales et que les 4 plus petites sont égales. L'entrée doit être un tableau de tableaux.

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 caractères

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

Preuve (1x1): http://codepad.viper-7.com/ZlBpOB

Ceci est basé sur la réponse JavaScript d' eBuisness .

JavaScript 1.8, 112 caractères

Mise à jour: enregistré 2 caractères en repliant les compréhensions de tableau ensemble.

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

Une autre réimplémentation de la réponse de JB. Exploite les fonctionnalités JavaScript 1.7 / 1.8 (fermetures d'expressions, compréhensions de tableaux, affectation de déstructuration). Abuse également ~~(double opérateur pas au niveau du bit) pour contraindre undefinedau numérique, avec une contrainte tableau-chaîne et une expression rationnelle pour vérifier que le nombre de longueurs est [4, 8, 4](il suppose que exactement 4 points sont passés). L'abus de l'opérateur virgule est un vieux truc C obscurci.

Tests:

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 caractères

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

étendu:

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

Même algorithme que la réponse de JB .

Testez comme:

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

Sorties truepour vrai et vide pour faux

Python 97 (sans points complexes)

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

Cela prendra des listes de tuples de points dans [(x, y), (x, y), (x, y), (x, y)] dans n'importe quel ordre, et peut gérer les doublons ou le mauvais nombre de points. Il ne nécessite PAS de points complexes comme les autres réponses python.

Vous pouvez le tester comme ceci:

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)

Cela prendra un peu d'explication, mais l'idée générale est qu'il n'y a que trois distances entre les points d'un carré (Side, Diagonal, Zero (point par rapport à lui-même)):

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

• pour une liste p de tuples (x, y)
• Supprimez les doublons à l'aide de set (p), puis testez la longueur
• Obtenez chaque combinaison de points (a, b en p pour c, d en p)
• Obtenez la liste de la distance de chaque point à chaque autre point
• Utilisez l'ensemble pour vérifier qu'il n'y a que trois distances uniques - Zéro (point par rapport à lui-même) - Longueur latérale - Longueur diagonale

Pour enregistrer les caractères du code, je suis:

• en utilisant un nom de fonction de 1 caractère
• en utilisant une définition de fonction 1 ligne
• Au lieu de vérifier que le nombre de points uniques est de 4, je vérifie qu'il vaut -1 les différentes longueurs de points (sauvegarde == 3 ==)
• utilisez la décompression de liste et de tuple pour obtenir a, b en p pour c, d en p, au lieu d'utiliser a [0], a [1]
• utilise pow (x, .5) au lieu d'inclure des mathématiques pour obtenir sqrt (x)
• ne pas mettre d'espaces après le)
• ne pas mettre un zéro de tête sur le flotteur

Je crains que quelqu'un ne trouve un test qui casse cela. Alors s'il vous plaît, faites-le et je vais corriger. Par exemple, le fait que je vérifie simplement trois distances, au lieu de faire un abs () et de vérifier la longueur du côté et l'hypoténuse, semble être une erreur.

La première fois que j'ai essayé le golf à code. Soyez gentil si j'ai enfreint les règles de la maison.

Clojure, 159 caractères.

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

Edit: Pour expliquer aussi un peu.

• Définissez d'abord une norme qui donne essentiellement la distance entre deux points donnés.
• Calculez ensuite la distance du premier point aux trois autres points.
• Triez les trois distances. (Cela permet n'importe quel ordre des points.)
• Les deux distances les plus courtes doivent être égales à un carré.
• La troisième distance (la plus longue) doit être égale à la racine carrée de la somme des carrés des courtes distances par le théorème de Pythagore.

(Remarque: l'enracinement carré n'est pas nécessaire et donc dans le code enregistré ci-dessus.)

C #, 107 caractères

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

Où points est la liste de Vector3D contenant les points.

Calcule toutes les distances au carré entre tous les points, et s'il existe exactement trois types distincts (doit être 0, une valeur a et 2 * a) et 4 points distincts, alors les points forment un carré.

Python, 66

Amélioration de la réponse de Paperhorse de 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 octets

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

Essayez-le en ligne!

Prend une liste de quatre nombres complexes en entrée. Fait pivoter chaque point de 90 degrés autour de la moyenne et vérifie que chaque point résultant figure dans la liste d'origine.

Même longueur (mais plus courte en Python 3 avec {*l}).

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 32 31 octets

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

Essayez-le en ligne!

Prend une liste de points représentés par des nombres complexes, calcule les deuxième et troisième moments centraux et vérifie que les deux sont nuls.

Non-golfé:

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

ou

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

preuve

Ce critère fonctionne sur tout le plan complexe, pas seulement sur les entiers gaussiens .

1. Tout d'abord, nous notons que les moments centraux ne changent pas lorsque les points sont traduits ensemble. Pour un ensemble de points

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

   les moments centraux sont tous indépendants de c(c'est pourquoi ils sont appelés centraux ):

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

2. Deuxièmement, les moments centraux dépendent simplement de la mise à l'échelle complexe globale (mise à l'échelle et rotation) de l'ensemble de points:

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

   Cela signifie que si un moment central est nul, la mise à l'échelle et / ou la rotation de l'ensemble de points maintiendra le moment central égal à zéro.

3. Troisièmement, prouvons le critère pour une liste de points où les deux premiers points sont fixes:

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

   Dans quelles conditions les parties réelle et imaginaire des deuxième et troisième moments centraux sont-elles nulles?

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

   Toutes ces six solutions représentent des carrés: Par conséquent, la seule façon dont une liste de points de la forme {0, 1, x[3] + I*y[3], x[4] + I*y[4]}peut avoir zéro seconde et troisième moments centraux est lorsque les quatre points forment un carré.

En raison des propriétés de translation, de rotation et de mise à l'échelle démontrées aux points 1 et 2, cela signifie que chaque fois que les deuxième et troisième moments centraux sont nuls, nous avons un carré dans un état de translation / rotation / mise à l'échelle. ∎

généralisation

Le k-ième moment central d'un n-gon régulier est nul si k n'est pas divisible par n. Il faut combiner suffisamment de ces conditions pour constituer un critère suffisant pour détecter les n-gons. Pour le cas n = 4, il suffisait de détecter des zéros dans k = 2 et k = 3; pour détecter, par exemple, des hexagones (n = 6), il peut être nécessaire de vérifier k = 2,3,4,5 pour les zéros. Je n'ai pas prouvé ce qui suit, mais je soupçonne qu'il détectera tout n-gon régulier:

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

Le défi du code est essentiellement ce code spécialisé pour les listes de longueur 4.

J, ^{31 29 27} 26

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

vérifie si les 8 plus petites distances entre les points sont identiques. vérifie s'il existe exactement trois types de distances entre les points (zéro, longueur latérale et longueur diagonale).

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 $ est une façon d'écrire un tableau en J.

Smalltalk pour 106 caractères

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

où p est un ensemble de points, par exemple

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

Je pense que les maths sont solides ...

Mathematica, 123 caractères (mais vous pouvez faire mieux):

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

Où 'a' est l'entrée sous forme de liste Mathematica, par exemple: a={{0,0},{3,4},{8,4},{5,0}}

La clé est de regarder les produits scalaires entre tous les vecteurs et de noter qu'ils doivent avoir exactement trois valeurs: 0, x et 2 * x pour une valeur de x. Le produit scalaire vérifie à la fois la perpendicularité ET la longueur en un seul gonflement.

Je sais qu'il existe des raccourcis Mathematica qui peuvent rendre cela plus court, mais je ne sais pas ce qu'ils sont.

Haskell, "wc -c" rapporte 110 caractères. Ne vérifie pas que l'entrée a 4 éléments.

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

J'ai testé sur

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