Membantu! Ujian matematika saya akan segera hadir dan saya tidak belajar! ¹ Bagian dari ujian adalah untuk mengklasifikasikan segiempat dengan koordinat titik, yang sayangnya saya tidak tahu caranya. ²

Jadi, tantangan Anda adalah menulis program untuk melakukan ini untuk saya jadi saya tidak gagal!

Tantangan

Diberikan empat simpul sedemikian rupa sehingga tidak ada tiga dari mereka yang kolinear, tentukan klasifikasi paling spesifik dari segiempat yang dibentuk oleh keempat simpul tersebut.

Yang saya maksud dengan "klasifikasi paling spesifik" adalah bahwa meskipun semua kotak adalah persegi panjang, jika bentuknya persegi, Anda harus menunjukkan bahwa itu adalah persegi dan tidak menunjukkan bahwa itu adalah persegi panjang.

Memasukkan

Input akan diberikan sebagai empat (x, y) koordinat. Anda dapat mengambil ini sebagai daftar panjang 4 daftar / tupel panjang 2. Atau, Anda dapat mengambil input sebagai daftar koordinat x dan daftar masing-masing koordinat y.

Sebagai contoh, jika bentuk saya memiliki simpul pada titik-titik (0, 0), (5, 0), (6, 1), dan (1, 1), Anda dapat memilih untuk mengambil masukan dalam salah satu dari format berikut atau yang serupa:

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

Anda dapat mengasumsikan bahwa segiempat tidak berpotongan sendiri dan bahwa titik-titik tersebut diberikan dalam urutan yang benar (yaitu, dua titik berurutan dalam input akan dihubungkan oleh segmen garis dalam segi empat).

Keluaran

Anda akan membutuhkan keluaran unik untuk masing-masing kelas segiempat berikut:

• Kotak
• Empat persegi panjang
• Belah ketupat
• Genjang
• Trapesium / Trapesium
• Layang-layang
• Berbentuk segi empat

Ini bisa berupa nama persisnya, karakter, bilangan bulat, dll.

Aturan

• Celah Standar Berlaku
• Jika bahasa pemrograman Anda memiliki built-in yang akan melakukan tugas yang tepat ini, bahwa built-in tidak diperbolehkan.
• Built-in untuk menemukan jarak antara dua titik diperbolehkan.
• Built-in untuk menemukan sudut antara dua garis diperbolehkan.

Pada titik ini, jika Anda mengetahui semua persyaratan, Anda siap untuk memulai pemrograman! (Kasus Uji pada akhirnya)

Terminologi

Bagian ini untuk siapa saja yang membutuhkan klarifikasi tentang definisi bentuk yang berbeda.

Kotak

Segiempat adalah bujur sangkar jika dan hanya jika keempat sisinya memiliki panjang yang sama dan setiap pasangan sisi yang berdekatan tegak lurus (yaitu, segi empat dan belah ketupat).

Empat persegi panjang

Segiempat adalah persegi panjang jika dan hanya jika setiap pasangan sisi yang berdekatan tegak lurus.

Belah ketupat

Segiempat adalah belah ketupat jika dan hanya jika keempat sisinya sama.

Genjang

Quadrilateral adalah jajar genjang jika dan hanya jika setiap pasangan sisi yang berlawanan adalah paralel dan setiap pasangan dari sudut yang berlawanan adalah sama. Kedua kondisi ini menyiratkan satu sama lain sehingga Anda hanya perlu memeriksa salah satunya.

Trapesium / Trapesium

Segiempat adalah trapesium / trapesium jika dan hanya jika memiliki setidaknya satu sisi paralel.

Layang-layang

Segiempat adalah layang-layang jika dua pasang yang berlawanan dari sisi yang berdekatan memiliki panjang yang sama; yaitu, dua sisi yang berdekatan sama dan dua lainnya juga sama.

Uji Kasus

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

Tautan (Kalkulator Grafik Desmos)

Berikut ini tautan ke visualisasi masing-masing kasus uji.

Persegi
Persegi Panjang
Rhombus
Parallelogram
Trapesium / Trapezium
Kite
Segiempat

Kriteria Menang

Saya tidak bisa membawa komputer ke ujian, jadi saya ingin Anda menulis kode sesingkat mungkin agar saya dapat menghafalnya. Saya perlu menuliskannya di margin dan menjalankannya menggunakan TryItOffline ^TM sehingga agar sesuai dengan margin, program Anda harus sekecil mungkin!

¹ Tentu saja saya benar-benar melakukannya: P
² Tentu saja saya benar-benar melakukannya: P

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

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

Cobalah online!

Input output

Mengambil 4 × 2 matriks koordinat sebagai input

Keluaran

• 1 1 1 untuk Square
• 1 1 0 untuk Belah Ketupat
• 1 0 1 untuk Rectangle
• 1 0 0 untuk Parallelogram
• 1 0 untuk Kite
• 0 1 untuk Trapezium
• 0 0 untuk segiempat

Algoritma

Pertama, temukan semua 4 sisi panjang dan sudut segiempat

Jika kedua pasang sudut yang berlawanan sama ( OA), maka bentuknya adalah semacam jajaran genjang. Tentukan apakah semua panjang sisi sama ( AS, Sisi Bersebelahan) dan jika semua sudut sama ( AA).

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

Jika tidak OA, maka:

• Tentukan apakah ada tepat 2 pasang sisi yang berdekatan yang sama dan jika mereka dipisahkan ( aabbbukan aaab). Jika demikian, bentuknya adalah layang-layang.

• Tentukan apakah ada tepat 1 pasang sisi yang berlawanan paralel. Jika demikian, bentuknya adalah trapesium.

• Kalau tidak, bentuknya adalah segi empat.

Kode

⍙←{⍵⍺⍺1⌽⍵}mendefinisikan operator baru. Dalam APL, operator berarti fungsi tingkat tinggi . Operator ini mengambil 1 argumen fungsional ( ⍺⍺) dan mengembalikan fungsi monadik yang:

1. Memutar ( 1⌽) argumen ( ⍵)
2. Terapkan ⍺⍺antara itu dan⍵

Ini sangat berguna untuk fungsi skalar karena sebagian besar dari mereka secara implisit memetakan seluruh argumen array, memungkinkan ⍙untuk menerapkannya di antara setiap pasangan elemen yang berdekatan dengan membungkus. Misalnya +⍙1 2 3 4adalah 1 2 3 4 + 2 3 4 1yang mengevaluasi 3 5 7 5.

x←-⍙⎕+.×1 0J1 mengubah matriks koordinat input ke dalam array bilangan kompleks yang mewakili vektor dari 4 sisi bentuk.

• ⎕, ketika direferensikan, mengambil dan mengembalikan input

• 1 0J1mewakili vektor [1, i] ("vektor" dalam arti matematika, dan "i" sebagai akar kuadrat dari -1). Dalam APL, bilangan kompleks a+biditulisaJb

• +.×perkalian matriks. Secara matematis, hasilnya adalah matriks 4 × 1. Namun, +.×disebut "produk dalam" di APL yang menggeneralisasikan perkalian matriks dan produk dalam vektor dan memungkinkan Anda untuk melakukan hal-hal genap seperti "gandakan" array 3 dimensi dengan yang 2 dimensi. Dalam hal ini, kita mengalikan matriks 4 × 2 dan vektor 2-elemen, menghasilkan vektor 4-elemen (dari representasi bilangan kompleks dari 4 simpul yang diberikan).

• -⍙adalah pengurangan berpasangan dengan membungkus seperti yang disebutkan di atas. Ini memberikan vektor dari 4 sisi bentuk (sebagai bilangan kompleks). Vektor-vektor ini menunjuk ke arah "terbalik" tetapi itu tidak masalah.

• x← menyimpannya ke dalam variabel x

2|1+-⍙(12○x)÷○1 menemukan (representasi) sudut eksterior pada 4 simpul bentuk.

• 12○xmenemukan argumen utama , dalam radian, dari masing-masing vektor sisi 4.

• ÷○1membaginya dengan π sehingga sudutnya lebih mudah untuk dikerjakan. Dengan demikian, semua sudut dinyatakan sebagai kelipatan dari sudut lurus.

• -⍙Pengurangan berpasangan dengan membungkus seperti yang disebutkan di atas. Ini memberikan 4 sudut eksterior.

• 2|1+ Argumen utama dibatasi (-1,1] dan pengurangan berpasangan membuat kisaran (-2,2] .Ini buruk karena sudut yang sama memiliki 2 representasi yang berbeda. Dengan melakukan "tambah 1 mod 2", sudut akan kembali dibatasi pada (0,2). Meskipun semua sudut 1 lebih dari apa yang seharusnya, tidak apa-apa jika kita mengingatnya.

|xmenemukan besarnya masing-masing vektor sisi 4

{⍵≡2⌽⍵:≡⍙¨0⍺⍵⋄2 4=+/1=2|+⍙↑⍵(=⍙⍺)}mendefinisikan dan menerapkan fungsi dengan array 4 sudut eksterior sebagai argumen kanan ⍵dan array 4 panjang sisi sebagai argumen benar ⍺.

• Fungsi memiliki ekspresi yang dijaga. Dalam hal ini, ⍵≡2⌽⍵adalah penjaga.
• Jika penjaga mengevaluasi 1maka ekspresi selanjutnya ≡⍙¨0⍺⍵dieksekusi dan nilainya dikembalikan.
• Jika penjaga mengevaluasi 0, ekspresi itu dilewati dan 2 4=...=⍙⍺)sebaliknya setelah dieksekusi.

⍵≡2⌽⍵ memeriksa apakah kedua pasang sudut yang berlawanan sama.

• 2⌽⍵ memutar array sudut sebanyak 2 tempat.
• ⍵≡memeriksa apakah itu sama dengan ⍵dirinya sendiri

≡⍙¨0⍺⍵ mengembalikan nilai unik untuk setiap bentuk tipe jajaran genjang.

• 0⍺⍵adalah array 3-elemen skalar 0, array panjang sisi ⍺, dan array sudut ⍵.
• ≡⍙¨dieksekusi ≡⍙untuk masing-masing elemen tersebut.
• ≡⍙memeriksa apakah semua nilai array sama dengan memeriksa jika memutarnya 1 memberikan array yang sama. Skalar tidak berputar sehingga ≡⍙0kembali 1. Seperti disebutkan di atas, ≡⍙⍺memeriksa untuk belah ketupat dan ≡⍙⍵memeriksa untuk persegi panjang.

2 4=+/1=2|+⍙↑⍵(=⍙⍺)mengembalikan nilai unik untuk setiap bentuk non-jajaran genjang. Ini dicapai dengan menjalin pemeriksaan layang-layang dan trapesium.

2=+/1=2|+⍙⍵ memeriksa trapezium.

• +⍙⍵memberikan jumlah sudut yang berdekatan. Sudut interior garis-garis paralel berjumlah sudut lurus, demikian juga sudut eksterior sisi paralel segi empat. Jadi, setiap pasangan sisi paralel harus mengarah ke dua 1atau -1dalam jumlah sudut yang berdekatan.

• 1=2|Namun, sudut dalam ⍵adalah 1 lebih dari yang seharusnya, sehingga sudut sebenarnya berjumlah 1atau 3. Ini dapat diperiksa dengan "mod 2 sama dengan 1".

• +/menjumlahkan array. Ini memberikan jumlah jumlah sudut yang berdekatan yaitu 1atau 3.

• 2= periksa apakah itu sama dengan 2. (Yaitu jika ada persis sepasang sisi paralel)

4=+/1=2|+⍙(=⍙⍺) memeriksa layang-layang.

• (=⍙⍺)memberikan array yang menunjukkan sisi yang berdekatan sama. Tidak seperti ≡, =unsur-bijaksana kerja. Jadi, ini adalah array 4-elemen dengan 1s di mana panjang sisi itu sama dengan sisi "berikutnya".

• +⍙ Jumlah berpasangan dengan membungkus.

• 1=2|Karena (=⍙⍺)memberikan array boolean (satu dengan hanya 0s dan 1s), satu-satunya nilai yang mungkin dari jumlah berpasangan adalah 0, 1dan 2. Jadi 1=2|sama dengan adil 1=.

• +/menjumlahkan array. Ini memberikan jumlah jumlah berpasangan yang 1.

• 4=memeriksa apakah yang sama 4. Satu-satunya cara yang terjadi adalah jika (=⍙⍺)adalah 1 0 1 0atau 0 1 0 1. Seperti disebutkan di atas, ini berarti bentuknya adalah layang-layang.

2 4=+/1=2|+⍙↑⍵(=⍙⍺) terjalin cek di atas.

• ⍵(=⍙⍺)adalah 2-elemen array yang bersarang dari array ⍵dan array(=⍙⍺)

• ↑mempromosikan array bersarang ke matriks yang tepat. Karena ⍵(=⍙⍺)array 2 elemen dari array 4 elemen, hasilnya adalah matriks 2 × 4.

• +⍙Karena ⌽(dan, dengan ekstensi, ⍙) memutar sumbu (horizontal) terakhir, +⍙ke sebuah matriks sama dengan menerapkan +⍙ke setiap baris secara individual.

• 1=2|baik residu / mod ( |) dan equals ( =) bekerja atas dasar per-elemen, bahkan untuk matriks.

• +/Secara default, perkecil ( /) bekerja di sepanjang sumbu (horizontal) terakhir. Jadi +/jumlahkan sepanjang baris dan ubah matriks 2 × 4 menjadi array sederhana 2-elemen.

• 2 4=Karena =berfungsi per elemen, ini memeriksa kondisi layang-layang dan trapesium secara bersamaan.

Mathematica, 195 byte

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

Dengan spasi putih:

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

Output 1untuk kotak, 2untuk belah ketupat, 3untuk persegi panjang, 4untuk jajaran genjang, 5untuk layang-layang, 6untuk trapesium, dan 7untuk apa pun. Saya akan memposting tautan TIO, tetapi ini tampaknya tidak berfungsi dalam Matematika.

Jika empat poin P, Q, R, dan S, kemudian {##,#}adalah {P,Q,R,S,P}, sehingga sadalah daftar vektor sisi {Q-P,R-Q,S-R,P-S}, ladalah panjang dari vektor-vektor, dan rkondisi bahwa sudut antara Q-Pdan R-Qserta sudut antara R-Qdan S-Rkeduanya 90derajat.

Jadi, jika semua panjang sisi sama, maka segiempat adalah belah ketupat. Jika rtahan, itu sebenarnya sebuah bujur sangkar, kalau tidak itu hanya sebuah belah ketupat.

Mengesampingkan rhombi, jika kedua pasangan dengan panjang sisi yang berlawanan sama, maka segiempatnya masih jajar genjang. Jika rtahan, itu sebenarnya persegi panjang, jika tidak, itu hanya jajaran genjang.

Mengesampingkan genjang, daftar panjang sisi ladalah dari bentuk {a,b,b,a}atau {a,a,b,b}untuk beberapa adan b, maka segiempat adalah layang-layang. Perhatikan bahwa itu tidak dapat berupa trapesium atau bahkan akan menjadi belah ketupat.

Mengesampingkan genjang dan layang-layang, jika segiempat memiliki sepasang sisi paralel, maka itu adalah trapesium. Kami memeriksa ini dengan Normalizememasukkan vektor sisi dan memeriksa apakah sepasang vektor yang berlawanan menambah {0,0}.

Mengesampingkan semua hal di atas, jika 1 > 0(lebih baik), maka segi empat hanyalah segi empat tua biasa.

Python 2 , 463 410 408 397 byte

Disimpan 53 byte dengan menggunakan tuple di baris keenam alih-alih mengindeks ke dalam daftar.

Menyimpan 11 byte dengan menggeser ke integer output 1 hingga 7 alih-alih huruf pertama dari setiap bentuk. Bilangan bulat sesuai sebagai berikut:

1. Kotak
2. Empat persegi panjang
3. Belah ketupat
4. Genjang
5. Trapesium
6. Layang-layang
7. Berbentuk segi empat

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

Cobalah online!

Ungolfed untuk menunjukkan logika

Ditunjukkan sebagai fungsi, untuk menampilkan output untuk input tes yang berbeda. perhatikan saya mengubah contoh tes "Persegi Panjang" dari yang awalnya disediakan dalam pertanyaan, yang bukan persegi panjang.

Logika bertumpu pada produk titik dan norma (panjang) vektor yang dibentuk oleh sisi segi empat untuk menilai apakah sisi memiliki panjang yang sama, sejajar pada sisi yang berlawanan, atau tegak lurus dengan sisi yang berdekatan.

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

Cobalah online!

Batch, 287 byte

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

Output dalam biner: 1= Layang-layang, 10= Quadrilateral, 11= Trapezium, 100= Parallelogram, 101= Rhombus, 110= Rectangle, 111= Square. Penjelasan: g, h, i, jadalah kuadrat dari panjang sisi. padalah jumlah pasangan sisi yang berlawanan dengan panjang yang sama, qmembedakan antara jajaran genjang / persegi panjang dan rhobmi / kotak dengan memeriksa apakah pasangan yang berlawanan sebenarnya sama, rmembedakan antara jajaran genjang / rhombi dan persegi / kotak melalui cek tegak lurus, kmemeriksa layang-layang dengan mencari pasangan sisi yang berdekatan yang sama dan tmemeriksa trapezium melalui beberapa pemeriksaan sisi paralel.