Hilfe! Meine Matheprüfung steht kurz bevor und ich habe nicht gelernt! ¹ Teil der Prüfung ist es, ein Viereck anhand seiner Scheitelpunktkoordinaten zu klassifizieren, was ich leider nicht kann. ²

Ihre Herausforderung besteht also darin, ein Programm zu schreiben, das dies für mich erledigt, damit ich nicht versage!

Herausforderung

Bestimmen Sie bei vier Scheitelpunkten, von denen keiner kollinear ist, die spezifischste Klassifikation des durch diese vier Scheitelpunkte gebildeten Vierecks.

Was ich unter "spezifischster Klassifizierung" verstehe, ist, dass, obwohl alle Quadrate Rechtecke sind, wenn die Form ein Quadrat ist, Sie angeben sollten, dass es ein Quadrat ist, und nicht, dass es ein Rechteck ist.

Eingang

Die Eingabe erfolgt als vier (x, y) Koordinaten. Sie können diese als eine Liste der Länge 4 von Listen / Tupeln der Länge 2 nehmen. Alternativ können Sie Eingaben als eine Liste der x-Koordinaten und eine Liste der jeweiligen y-Koordinaten nehmen.

Zum Beispiel, wenn meine Form Ecken an den Punkten hat (0, 0), (5, 0), (6, 1), und (1, 1)kann wählen Sie Eingabe in einem der folgenden Formate oder etwas ähnliches zu nehmen:

[(0, 0), (5, 0), (6, 1), (1, 1)]
([0, 5, 6, 1], [0, 0, 1, 1])

Sie können davon ausgehen, dass sich das Viereck nicht selbst schneidet und die Punkte in der richtigen Reihenfolge angegeben werden (dh zwei aufeinanderfolgende Punkte in der Eingabe werden durch ein Liniensegment im Viereck verbunden).

Ausgabe

Sie benötigen eine eindeutige Ausgabe für jede der folgenden Klassen von Vierecken:

• Platz
• Rechteck
• Rhombus
• Parallelogramm
• Trapez / Trapez
• Drachen
• Viereck

Dies kann der genaue Name selbst, ein Zeichen, eine Ganzzahl usw. sein.

Regeln

• Es gelten Standardlücken
• Wenn Ihre Programmiersprache über eine integrierte Software verfügt, die genau diese Aufgabe ausführt, ist diese integrierte Software nicht zulässig.
• Eingebaute Funktionen zum Ermitteln der Entfernung zwischen zwei Punkten sind zulässig.
• Eingebaute Funktionen zum Ermitteln des Winkels zwischen zwei Linien sind zulässig.

Wenn Sie alle Begriffe kennen, können Sie jetzt mit dem Programmieren beginnen! (Testfälle sind am Ende)

Terminologie

Dieser Abschnitt richtet sich an alle, die Erläuterungen zu den Definitionen der verschiedenen Formen benötigen.

Platz

Ein Viereck ist genau dann ein Quadrat, wenn alle vier Seiten gleich lang sind und jedes Paar benachbarter Seiten senkrecht steht (dh, es ist sowohl ein Rechteck als auch eine Raute).

Rechteck

Ein Viereck ist nur dann ein Rechteck, wenn jedes Paar benachbarter Seiten senkrecht steht.

Rhombus

Ein Viereck ist nur dann eine Raute, wenn alle vier Seiten gleich sind.

Parallelogramm

Ein Viereck ist genau dann ein Parallelogramm, wenn jedes Paar gegenüberliegender Seiten parallel ist und jedes Paar gegenüberliegender Winkel gleich ist. Diese beiden Bedingungen implizieren sich gegenseitig, sodass Sie nur nach einer von ihnen suchen müssen.

Trapez / Trapez

Ein Viereck ist genau dann ein Trapez / Trapez, wenn es mindestens ein Paar paralleler Seiten hat.

Drachen

Ein Viereck ist ein Drachen, wenn zwei gegenüberliegende Paare benachbarter Seiten gleich lang sind. das heißt, zwei seiner benachbarten Seiten sind gleich und die anderen beiden sind ebenfalls gleich.

Testfälle

input as (x, y) * 4 -> full name
[(0, 0), (1, 0), (1, 1), (0, 1)] -> square
[(0, 0), (1, 1), (-1, 3), (-2, 2)] -> rectangle
[(0, 0), (5, 0), (8, 4), (3, 4)] -> rhombus
[(0, 0), (5, 0), (6, 1), (1, 1)] -> parallelogram
[(0, 0), (4, 0), (3, 1), (1, 1)] -> trapezoid/trapezium
[(0, 0), (1, 1), (0, 3), (-1, 1)] -> kite  
[(0, 0), (2, 0), (4, 4), (0, 1)] -> quadrilateral

Links (Desmos Grafikrechner)

Hier finden Sie Links zu Visualisierungen der einzelnen Testfälle.

Quadratisches
Rechteck
Rhombus
Parallelogramm
Trapez / Trapez
Drachen
Viereck

Gewinnkriterien

Ich kann offensichtlich keinen Computer in die Prüfung einbinden, daher muss der Code so kurz wie möglich sein, damit ich ihn mir merken kann. Ich muss es in die Ränder schreiben und mit TryItOffline ^TM ausführen, damit es in die Ränder passt. Ihr Programm muss so klein wie möglich sein!

¹ Natürlich habe ich tatsächlich getan: P
² Natürlich habe ich tatsächlich getan: P

APL (Dyalog) , 104 89 80 82 81 79 78 Bytes

⍙←{⍵⍺⍺1⌽⍵}
⎕←(|x){⍵≡2⌽⍵:≡⍙¨0⍺⍵⋄2 4=+/1=2|+⍙↑⍵(=⍙⍺)}2|1+-⍙(12○x←-⍙⎕+.×1 0J1)÷○1

Probieren Sie es online!

Input-Output

Nimmt eine 4 × 2-Koordinatenmatrix als Eingabe

Ausgänge

• 1 1 1 für Platz
• 1 1 0 für Rhombus
• 1 0 1 für Rechteck
• 1 0 0 für Parallelogramm
• 1 0 für Kite
• 0 1 für Trapez
• 0 0 für Viereck

Algorithmus

Ermitteln Sie zunächst alle 4 Seitenlängen und Winkel des Vierecks

Wenn beide Paare entgegengesetzter Winkel gleich sind ( OA), ist die Form eine Art Parallelogramm. Bestimmen Sie, ob alle Seitenlängen gleich sind ( AS, Benachbarte Seiten) und ob alle Winkel gleich sind ( AA).

+--------+----------------+----------------+
|        |       AA       |      ~AA       |
+--------+----------------+----------------+
|   AS   |     Square     |    Rhombus     |
|--------+----------------+----------------+
|  ~AS   |    Rectangle   |  Parallelogram |
+--------+----------------+----------------+

Wenn nicht OA, dann:

• Bestimmen Sie, ob es genau 2 Paare gleicher benachbarter Seiten gibt und ob sie getrennt sind ( aabbanstelle von aaab). Wenn ja, ist die Form ein Drachen.

• Stellen Sie fest, ob genau 1 Paar parallele gegenüberliegende Seiten vorhanden sind. Wenn ja, ist die Form ein Trapez.

• Ansonsten ist die Form ein Viereck.

Code

⍙←{⍵⍺⍺1⌽⍵}Definiert einen neuen Operator. In APL bedeutet ein Operator eine Funktion höherer Ordnung . Dieser Operator akzeptiert 1 Funktionsargument ( ⍺⍺) und gibt eine monadische Funktion zurück, die:

1. Dreht ( 1⌽) das Argument ( ⍵)
2. Bewerben Sie sich ⍺⍺dazwischen und⍵

Dies ist besonders nützlich für skalare Funktionen, da die meisten von ihnen implizit über Array-Argumente hinweg abgebildet werden, so ⍙dass diese zwischen jedem benachbarten Elementpaar mit Umlauf angewendet werden können. Zum Beispiel +⍙1 2 3 4ist das, 1 2 3 4 + 2 3 4 1was auswertet 3 5 7 5.

x←-⍙⎕+.×1 0J1 wandelt die Eingabekoordinatenmatrix in ein Array komplexer Zahlen um, die die Vektoren der vier Seiten der Form darstellen.

• ⎕Wenn verwiesen wird, werden Eingaben entgegengenommen und zurückgegeben

• 1 0J1stellt den Vektor [1, i] dar ("Vektor" im mathematischen Sinne und "i" als Quadratwurzel von -1). In APL wird eine komplexe Zahl a+bigeschriebenaJb

• +.×Matrix-Multiplikation. Mathematisch wäre das Ergebnis eine 4 × 1-Matrix. In +.×APL wird es jedoch "inneres Produkt" genannt, das die Matrixmultiplikation und das innere Vektorprodukt verallgemeinert und es Ihnen ermöglicht, sogar Dinge wie das "Multiplizieren" eines dreidimensionalen Arrays mit einem zweidimensionalen zu tun. In diesem Fall multiplizieren wir eine 4 × 2-Matrix und einen 2-Element-Vektor und erhalten einen 4-Element-Vektor (der komplexen Zahlendarstellungen der 4 gegebenen Eckpunkte).

• -⍙ist eine paarweise Subtraktion mit Umlauf, wie oben angegeben. Dies ergibt die Vektoren der 4 Seiten der Form (als komplexe Zahlen). Diese Vektoren zeigen in die "umgekehrte" Richtung, aber das spielt keine Rolle.

• x← speichert das in der Variablen x

2|1+-⍙(12○x)÷○1 findet (eine Darstellung von) den Außenwinkeln an den 4 Eckpunkten der Form.

• 12○xFindet das Hauptargument jedes der 4 Seitenvektoren im Bogenmaß.

• ÷○1dividiert durch π, damit die Winkel leichter zu bearbeiten sind. Somit werden alle Winkel als Vielfaches eines geraden Winkels ausgedrückt.

• -⍙Paarweise Subtraktion mit Umlauf wie oben angegeben. Dies ergibt die 4 Außenwinkel.

• 2|1+ Das Hauptargument ist begrenzt (-1,1] und die paarweise Subtraktion ergibt den Bereich (-2,2]. Dies ist schlecht, da derselbe Winkel zwei verschiedene Darstellungen hat. Wenn Sie "add 1 mod 2" ausführen, wird der Winkel neu berechnet. begrenzt auf (0,2]. Obwohl alle Winkel um 1 höher sind, als es sein sollte, ist es in Ordnung, wenn wir dies berücksichtigen.

|xFindet die Größe jedes der 4 Seitenvektoren

{⍵≡2⌽⍵:≡⍙¨0⍺⍵⋄2 4=+/1=2|+⍙↑⍵(=⍙⍺)}definiert und wendet eine Funktion mit dem Array von 4 Außenwinkeln als rechtem Argument ⍵und dem Array von 4 Seitenlängen als rechtem Argument an ⍺.

• Die Funktion hat einen geschützten Ausdruck. In diesem Fall ⍵≡2⌽⍵ist die Wache.
• Wenn der Guard den Wert "0" ergibt , 1wird der nächste Ausdruck ≡⍙¨0⍺⍵ausgeführt und sein Wert zurückgegeben.
• Wenn der Guard 0das Ergebnis ergibt, wird dieser Ausdruck übersprungen und der folgende 2 4=...=⍙⍺)wird stattdessen ausgeführt.

⍵≡2⌽⍵ prüft, ob beide Paare entgegengesetzter Winkel gleich sind.

• 2⌽⍵ Dreht das Winkelarray um 2 Stellen.
• ⍵≡prüft, ob das dasselbe ist wie es ⍵selbst

≡⍙¨0⍺⍵ Gibt einen eindeutigen Wert für jede Form vom Typ Parallelogramm zurück.

• 0⍺⍵ist das 3-Element-Array des Skalars 0, des Seitenlängen-Arrays ⍺und des Winkel-Arrays ⍵.
• ≡⍙¨wird ≡⍙für jedes dieser Elemente ausgeführt.
• ≡⍙überprüft, ob alle Werte eines Arrays gleich sind, indem überprüft wird, ob durch Drehen um 1 dasselbe Array erhalten wird. Skalare drehen sich nicht und ≡⍙0kehren zurück 1. Wie oben erwähnt, wird ≡⍙⍺nach einer Raute und ≡⍙⍵nach einem Rechteck gesucht.

2 4=+/1=2|+⍙↑⍵(=⍙⍺)Gibt einen eindeutigen Wert für jede nicht parallelogrammartige Form zurück. Dies wird erreicht, indem die Kontrollen für Drachen und Trapez miteinander verflochten werden.

2=+/1=2|+⍙⍵ sucht nach einem Trapez.

• +⍙⍵gibt die angrenzenden Winkelsummen an. Die Innenwinkel paralleler Linien summieren sich zu einem geraden Winkel, ebenso wie die Außenwinkel paralleler Seiten eines Vierecks. Jedes Paar paralleler Seiten sollte also zu zwei 1oder -1zu benachbarten Winkelsummen führen.

• 1=2|Die Winkel in ⍵1 sind jedoch größer als sie sein sollten, sodass die Winkel tatsächlich zu 1oder summieren 3. Dies kann mit "mod 2 gleich 1" überprüft werden.

• +/summiert das Array. Dies ergibt eine Zählung benachbarter Winkelsummen, die 1oder ist 3.

• 2= prüfe ob das gleich 2 ist. (Dh ob es genau ein Paar paralleler Seiten gibt)

4=+/1=2|+⍙(=⍙⍺) sucht nach einem Drachen.

• (=⍙⍺)gibt ein Array an, das angibt, welche benachbarten Seiten gleich sind. Im Gegensatz zu ≡, =Arbeitselementweise. Somit ist dies ein 4-Element-Array mit 1s, wobei die Länge dieser Seite gleich der der "nächsten" Seite ist.

• +⍙ Paarweise Summe mit umwickeln.

• 1=2|Da (=⍙⍺)es sich um ein boolesches Array handelt (eines mit nur 0s und 1s), sind die einzig möglichen Werte der paarweisen Summe 0, 1und 2. Ist 1=2|also genauso wie eben 1=.

• +/summiert das Array. Dies ergibt eine Anzahl von paarweisen Summen 1.

• 4=überprüfen , ob die 4. gleich der einzige Weg, wenn passiert ist , (=⍙⍺)ist 1 0 1 0oder 0 1 0 1. Wie oben erwähnt, bedeutet dies, dass die Form ein Drachen ist.

2 4=+/1=2|+⍙↑⍵(=⍙⍺) verflochten die oben genannten Prüfungen.

• ⍵(=⍙⍺)ist das aus 2 Elementen bestehende verschachtelte Array des Arrays ⍵und des Arrays(=⍙⍺)

• ↑Fördert das verschachtelte Array zu einer geeigneten Matrix. Da ⍵(=⍙⍺)es sich um ein 2-Element-Array aus 4-Element-Arrays handelt, ist das Ergebnis eine 2 × 4-Matrix.

• +⍙Da ⌽(und damit auch ⍙) die letzte (horizontale) Achse dreht, entspricht +⍙eine Matrix dem Anwenden +⍙auf jede Zeile einzeln.

• 1=2|Sowohl residual / mod ( |) als auch equals ( =) funktionieren auf Elementbasis, sogar für Matrizen.

• +/Standardmäßig arbeitet reduct ( /) entlang der letzten (horizontalen) Achse. So +/Summen entlang Reihen und wiederum eine 2 × 4 - Matrix in ein 2-Elemente einfaches Array.

• 2 4=Da =pro Element gearbeitet wird, werden die Drachen- und Trapezbedingungen gleichzeitig überprüft.

Mathematica, 195 Bytes

Which[s=Differences@{##,#};l=Norm/@s;r=#.#2==#2.#3==0&@@s;Equal@@l,If[r,1,2],#==#3&&#2==#4&@@l,If[r,3,4],MatchQ[l,{a_,b_,b_,a_}|{a_,a_,b_,b_}],5,#+#3=={0,0}||#2+#4=={0,0}&@@Normalize/@s,6,1>0,7]&

Mit Leerzeichen:

Which[
    s = Differences @ {##,#};
    l = Norm /@ s;
    r = #.#2 == #2.#3 == 0& @@ s;

    Equal @@ l, If[r, 1, 2],
    # == #3 && #2 == #4& @@ l, If[r, 3, 4],
    MatchQ[l, {a_,b_,b_,a_}|{a_,a_,b_,b_}], 5,
    #+#3 == {0,0} || #2+#4 == {0,0}& @@ Normalize /@ s, 6,
    1 > 0, 7
]&

Ausgänge 1für Quadrate, 2Rauten, 3Rechtecke, 4Parallelogramme, 5Drachen, 6Trapez und 7alles andere. Ich würde einen TIO-Link posten, aber dies funktioniert anscheinend nicht in Mathematik.

Wenn die vier Punkte P, Q, R, und S, dann {##,#}ist {P,Q,R,S,P}, so sist die Liste der Seitenvektoren {Q-P,R-Q,S-R,P-S}, lsind die Längen dieser Vektoren und rdie Bedingung , dass der Winkel zwischen Q-Pund R-Qsowie dem Winkel zwischen R-Qund S-Rsind beide 90Grad.

Wenn also alle Seitenlängen gleich sind, ist das Viereck eine Raute. Wenn es rhält, ist es tatsächlich ein Quadrat, ansonsten ist es nur eine einfache Raute.

Ausschluss von Rhomben, wenn beide Paare der gegenüberliegenden Seitenlängen gleich sind, dann ist das Viereck immer noch Parallelogramm. Wenn dies rzutrifft, handelt es sich tatsächlich um ein Rechteck, andernfalls handelt es sich nur um ein einfaches Parallelogramm.

Ohne Parallelogramme ist die Liste der Seitenlängen lvon der Form {a,b,b,a}oder {a,a,b,b}für einige, aund bdann ist das Viereck ein Drachen. Beachten Sie, dass es sich nicht zusätzlich um ein Trapez oder eine Raute handeln kann.

Parallelogramme und Drachen ausschließen. Wenn das Viereck zwei parallele Seiten hat, ist es ein Trapez. Wir überprüfen dies, indem wir Normalizedie Seitenvektoren untersuchen und prüfen, ob sich ein Paar entgegengesetzter Vektoren addiert {0,0}.

Ausschluss all der oben genannten, wenn 1 > 0(es ist besser), dann ist das Viereck nur ein einfaches altes Viereck.

Python 2 , 463 410 408 397 Bytes

53 Bytes mit einem Tupel in der sechsten Zeile gespeichert, anstatt in einer Liste zu indizieren.

Speichert 11 Bytes, indem statt des ersten Buchstabens jeder Form die ganzen Zahlen 1 bis 7 ausgegeben werden. Die ganzen Zahlen entsprechen wie folgt:

1. Platz
2. Rechteck
3. Rhombus
4. Parallelogramm
5. Trapez
6. Drachen
7. Viereck

from numpy import *;D=dot
from numpy.linalg import *;N=norm
def P(a,b):x=D(a,b);y=N(a)*N(b);return x==y or x==-y
def Q(a,b):return int(N(a)==N(b))
L=input()
a,b,c,d=tuple([(L[i][0]-L[(i+1)%4][0],L[i][1]-L[(i+1)%4][1]) for i in range(4)])
g=7
e=Q(a,c)+Q(b,d)
if e==2:
 g=(1if D(a,b)==0 else 3) if Q(a,b) else 2 if D(a,b)==0 else 4
elif P(a,c) or P(b,d):
 g = 5
elif Q(a,b) or Q(b,c):
 g = 6
print g

Probieren Sie es online!

Ungolfed, um die Logik zu zeigen

Wird als Funktion angezeigt, um die Ausgabe für die verschiedenen Testeingaben anzuzeigen. note Ich habe das Testbeispiel "Rechteck" von dem ursprünglich in der Frage angegebenen geändert, bei dem es sich nicht um ein Rechteck handelte.

Die Logik beruht auf Punktprodukten und der Norm (Länge) der Vektoren, die durch die Seiten des Vierecks gebildet werden, um zu beurteilen, ob die Seiten gleich lang, auf gegenüberliegenden Seiten parallel oder senkrecht zu benachbarten Seiten sind.

def S(va, vb):
    return (va[0]-vb[0], va[1]-vb[1])
def dot(sa,sb):      # Eventually replaced with numpy.dot
    return(sa[0]*sb[0]+sa[1]*sb[1])
def norm(s):         # Eventually replaced by numpy.linalg.norm
    return (s[0]**2+s[1]**2)**.5
def isperp(a,b):     # Test if lines/vectors are perpendicular
    return dot(a,b)==0
def ispar(a,b):      # Test if lines/vectors are parallel
    x = dot(a,b)
    y = norm(a)*norm(b)
    return x == y or x == -y
def iseq(a,b):       # Test if lines/vectors are equal in length
    return norm(a)==norm(b)
   
def f(L):
    #Define the four sides
    s = []
    for i in range(4):
        s.append(S(L[i],L[(i+1)%4]))  # I refer often so shorter names may eventually

    guess = 'Q'
    eqsides = 0           # These 6 lines eventually golfed using integer arithmetic by returning an int from iseq()
    if iseq(s[0], s[2]):
        eqsides += 1
    if iseq(s[1],s[3]):
        eqsides += 1
    if eqsides == 2:
    # Opposite sides are equal, so square, rhombus, rectangle or parallelogram
        if iseq(s[0],s[1]):       #Equal adjacent sides, so square or rhombus
            guess='S' if isperp(s[0], s[1]) else 'H'
        else:                     # rectangle or Parallelogram
            guess='R' if isperp(s[0], s[1]) else 'P'
    elif ispar(s[0],s[2]) or ispar(s[1],s[3]):
        guess = 'T'
    elif iseq(s[0],s[1]) or iseq(s[1],s[2]):
        guess = 'K'
    return guess
    

#test suite:
print f([(0, 0), (1, 0), (1, 1), (0, 1)]) # -> square
print f([(0, 0), (1, 1), (-1, 3), (-2, 2)]) # -> rectangle
print f([(0, 0), (5, 0), (8, 4), (3, 4)]) #  -> rhombus
print f([(0, 0), (5, 0), (6, 1), (1, 1)]) #  -> parallelogram
print f([(0, 0), (4, 0), (3, 1), (1, 1)]) # -> trapezoid/trapezium
print f([(0, 0), (1, 1), (0, 3), (-1, 1)]) #-> kite  
print f([(0, 0), (2, 0), (4, 4), (0, 1)]) #-> quadrilateral

Probieren Sie es online!

Batch, 287 Bytes

@set/aa=%3-%1,b=%4-%2,c=%5-%1,d=%6-%2,e=%7-%1,f=%8-%2,g=a*a+b*b,h=(h=c-a)*h+(h=d-b)*h,i=(i=c-e)*i+(i=d-f)*i,j=e*e+f*f,p=!(i-g)+!(j-h),q=!(h-g),r=!(a*e+b*f),k=q+!(j-i)^|!(j-g)+!(h-i),t=!(a*(f-d)-b*(e-c))+!((c-a)*f-(d-b)*e)
@if %p%==2 (echo 1%r%%q%)else if %k%==2 (echo 1)else (echo 1%t%)

Ausgänge in binärer Form: 1= Drachen, 10= Viereck, 11= Trapez, 100= Parallelogramm, 101= Raute, 110= Rechteck, 111= Quadrat. Erklärung: g, h, i, jsind die Quadrate der Längen der Seiten. pist die Anzahl der Paare von gegenüberliegenden Seiten mit der gleichen Länge, qunterscheidet zwischen Parallelogrammen / Rechtecken und Rhombmen / Quadraten, indem überprüft wird, ob die gegenüberliegenden Paare tatsächlich gleich sind, runterscheidet zwischen Parallelogrammen / Rhombmen und Rechtecken / Quadraten über eine Rechtwinkligkeitsprüfung, kprüft auf a Suchen Sie nach Paaren gleicher benachbarter Seiten und suchen Sie tüber ein paar parallele Seitenprüfungen nach einem Trapez.