Hanya diberi penggaris dan kompas, tulislah sebuah belah ketupat di dalam persegi panjang yang diberikan, bagikan dua titik yang berlawanan.

Memasukkan

Input adalah dimensi persegi panjang. Dalam contoh yang ditunjukkan, itu akan menjadi 125, 50. Anda dapat mengambil input dengan cara apa pun yang paling nyaman (seperti dua bilangan bulat, daftar, string, dll).

Dimensi yang lebih besar akan menjadi 100 minimum, sedangkan yang lebih kecil akan menjadi minimum 25. Keduanya tutup pada 200.

Keluaran

Output akan berupa gambar (ditampilkan di layar atau disimpan sebagai file) yang ditampilkan

• Kotak input
• Semua garis / lingkaran "yang berfungsi"
• Belah ketupat yang tertulis

dalam warna berbeda. Pada gambar di atas, persegi panjang berwarna hitam, garis kerja biru, dan oranye belah ketupat. Garis-garis harus digambar dalam urutan yang ditunjukkan dalam daftar (misalnya, belah ketupat menimpa garis yang bekerja dan persegi panjang).

Gambar output harus cukup besar untuk memuat semuanya. Misalnya, lingkaran yang ditampilkan tidak dapat melampaui batas.

metode

Metode yang digunakan dalam contoh gambar di atas adalah:

• Gambarlah sebuah lingkaran menggunakan sudut kiri bawah sebagai pusat, dan kanan atas sebagai titik pada perimeter, memberikan jari-jari sama dengan diagonal persegi panjang itu.
• Lakukan hal yang sama, tetapi bertukar titik pusat dan perimeter.
• Gambarlah garis di antara persimpangan dua lingkaran, berikan garis-berat tegak lurus ke diagonal persegi panjang itu.
• Gunakan persimpangan garis dan persegi panjang baru untuk menggambar belah ketupat.

Ini berhasil karena diagonal interior belah ketupat selalu saling membagi dua. Saya tidak menyertakan bukti lengkap tentang hal ini di sini.

Ini bukan satu - satunya metode untuk mendapatkan belah ketupat Anda, dan Anda dapat menggunakan yang lain, mengingat Anda menjelaskan apa yang Anda lakukan. Saya percaya itu mungkin yang paling mudah.

Aturan

Anda hanya dapat menggambar lingkaran dan garis (atau lebih tepatnya, segmen garis). Lingkaran didefinisikan dengan titik pusat dan titik perimeter. Garis ditentukan oleh dua titik. Garis tidak harus panjang tertentu, tetapi paling tidak harus mencakup titik-titik yang menentukan (perhatikan contoh gambar: garis melewati sedikit persimpangan lingkaran, tetapi tidak ke tepi). Untuk lingkaran, jari-jari dari pusat ke titik perimeter yang dipilih dianggap sebagai garis kerja, dan harus ditunjukkan.

Untuk meraster garis, Anda dapat menggunakan algoritme yang dikenali (misalnya milik Bresenham), atau bergantung pada apa pun yang mungkin dimiliki bahasa Anda. Jika output Anda berbasis vektor, pastikan ditampilkan pada resolusi setidaknya sebesar persegi input dalam piksel. Selain itu, Anda akan menggambar di atas kanvas polos, jadi harap tekan tanda kisi atau keluaran yang asing.

Jangan curang! Anda hanya dapat menentukan penempatan titik / garis / lingkaran menggunakan apa yang telah Anda buat sejauh ini. Jika Anda tidak dapat menjelaskan cara menggunakan garis / lingkaran kerja Anda untuk menunjukkan bahwa itu adalah belah ketupat, Anda salah melakukannya.

Anda dapat menggunakan pasangan titik berlawanan mana saja yang Anda inginkan, dan persegi panjang tidak perlu ditarik garis-sejajar, asalkan outputnya benar.

Input akan selalu menjadi persegi panjang non-persegi, jadi jangan khawatir tentang casing khusus itu.

Terakhir, ini adalah kode standar golf, jadi ukuran terendah dalam byte menang.

HTML + JavaScript (ES6), 34 + 353 = 387 byte

Masukan harus diberikan dalam format [125,50].

[w,h]=eval(prompt(c=C.getContext("2d"))).sort();d=q=>(c.strokeStyle=q,b);l=(x,y=Z)=>x?c.lineTo(x,y)||l:c.stroke();b=(x,y=H,r)=>(c.beginPath(),r?c.arc(x,y,Math.sqrt(r),0,2*Math.PI):c.moveTo(x,y),l);b(Z=300,Z)(W=Z+w)(W,H=Z+h)(Z,H)(Z)();d`red`(Z,H,s=w*w+h*h)();b(W,Z,s)();b(Z)(W)();b(Z+w/2-h,Z+h/2-w)(H+w/2,W+h/2)();d`lime`(Z)(W-s/2/w)(W)(Z+s/2/w,H)(Z,H)()

<canvas id=C width=800 height=800>

Hanya banyak matematika dan gambar ... Kotak persegi panjang digeser jika tingginya lebih besar dari lebar, yang saya yakini diperbolehkan.

Mathematica, 157 148 158 byte

Terima kasih kepada Martin Ender untuk komentar dengan kualitas tinggi yang biasa mereka! 9 byte disimpan dalam kasus ini.

Diedit setelah itu diklarifikasi bahwa argumen dapat datang dalam urutan apa pun; 10 byte ditambahkan sebagai kompensasi.

Graphics@{(m=Line)@{o=0{,},{#,0},c={##},{0,#2},o},Blue,m[l={o,c}],Circle[#,(c.c)^.5]&/@l,m[{k={#2,-#},-k}+{c,c}/2],Red,m@{o,p={0,c.c/2/#2},c,c-p,o}}&@@Sort@#&

Sekali lagi, ini adalah tempat Mathematica bersinar: output grafis tingkat tinggi yang melibatkan perhitungan matematis. Kode yang sama dengan spasi dan baris baru untuk keterbacaan manusia:

Graphics@{
  (m=Line)@{o = 0{,}, {#, 0}, c = {##}, {0, #2}, o},
  Blue, m[l = {o, c}], Circle[#, (c.c)^.5] & /@ l, 
  m[{k = {#2, -#}, -k} + {c, c}/2],
  Red, m@{o, p = {c.c/2/#2, 0}, c, c - p, o}
} & @@ Sort@# &

Fungsi tanpa nama dari satu argumen yang merupakan pasangan angka positif yang diurutkan; final @@ Sort@# &mengkonversi pasangan itu menjadi dua argumen numerik di mana angka pertama adalah yang lebih kecil. Linemenghasilkan jalur poligon dari titik ke titik, yang akan berubah menjadi poligon tertutup jika titik pertama dan terakhir adalah sama; Circlemenghasilkan lingkaran dengan pusat dan jari-jari yang diberikan. Poin khusus odan c(sudut persegi panjang kiri dan kanan atas), p(sudut belah ketupat ketiga, yang diberikan oleh rumus matematika), dan k(membantu menggambar garis-garis tegak lurus) diberi nama sepanjang jalan untuk menghemat byte ketika dipanggil lagi , seperti pasangan poin khususl = {o,c}. Mathematica dengan senang hati menambahkan poin secara langsung, mengalikan kedua koordinat dengan faktor yang sama, mengambil titik produk mereka, dll., Yang semuanya menyederhanakan kode.

Output sampel, dengan argumen 125dan 50:

MetaPost, 473 (dengan warna) 353 (tanpa warna)

Berwarna (473 bytes):

A:=170;B:=100;pair X,Y;path C,D,E,F,G,R,T;X=(0,0);Y=(A,B);R=X--(A,0)--Y--(0,B)--cycle;T=(0,B)--(A,B);draw R;E=X--Y;C=X..Y*2..cycle;D=Y..-Y..cycle;F=(D intersectionpoint C)--(C intersectionpoint D);draw C withcolor green;draw D withcolor green;draw E withcolor red;draw F withcolor red;draw (F intersectionpoint R)--Y withcolor blue;draw X--(F intersectionpoint T) withcolor blue;draw (F intersectionpoint T)--Y withcolor blue;draw (F intersectionpoint R)--X withcolor blue;

Tidak berwarna (353 byte):

A:=170;B:=100;pair X,Y;path C,D,E,F,G,R,T;X=(0,0);Y=(A,B);R=X--(A,0)--Y--(0,B)--cycle;T=(0,B)--(A,B);draw R;E=X--Y;C=X..Y*2..cycle;D=Y..-Y..cycle;F=(D intersectionpoint C)--(C intersectionpoint D);draw C;draw D;draw E;draw F;draw (F intersectionpoint R)--Y;draw X--(F intersectionpoint T);draw (F intersectionpoint T)--Y;draw (F intersectionpoint R)--X;

Belum pernah menggunakan ini sebelumnya, dan saya yakin saya telah membunuhnya ...
Tetapi ketika Anda menjalankannya di situs web ini:

http://www.tlhiv.org/mppreview/

Menggunakan persimpangan lingkaran untuk menggambar sumbu kedua, dan kemudian menggunakan persimpangan sumbu dan persegi panjang untuk menggambar belah ketupat terakhir. Padahal aku bisa saja curang dan hanya menggambar garis tegak lurus dengan sumbu pertama haha.

Untuk mengubah dimensi, cukup ubah A dan B.

Apapun, Anda berakhir dengan (untuk L = 170, H = 100):

Desmos, 375 (atau 163) byte

w=125
h=50
\left(wt,\left[0,h\right]\right)
\left(\left[0,w\right],ht\right)
\left(x-\left[0,w\right]\right)^2+\left(y-\left[0,h\right]\right)^2=w^2+h^2
\frac{h}{w}x\left\{0\le x\le w\right\}
-\frac{w}{h}\left(x-\frac{w}{2}\right)+\frac{h}{2}
a=\frac{h^2}{2w}+\frac{w}{2}
\left(t\left(w-a\right)+\left[0,1\right]a,ht\right)
\left(at-\left[0,a-w\right],\left[0,h\right]\right)

wdan hmerupakan input. Cobalah di Desmos!

Alternatif versi 163-byte:

w=125
h=50
(wt,[0,h])
([0,w],ht)
(x-[0,w])^2+(y-[0,h])^2=w^2+h^2
hx/w\left\{0\le x\le w\right\}
-w(x-w/2)/h+h/2
a=h^2/2/w+w/2
(t(w-a)+[0,1]a,ht)
(at-[0,a-w],[0,h])

Versi ini mengharuskan setiap baris untuk disalin dan ditempelkan ke setiap baris terpisah ke Desmos. Meta masih perlu memutuskan apakah ini adalah metode penghitungan yang valid, tetapi metode yang pertama jelas baik-baik saja.

ImageMagick Versi 7.0.3 + bash + sed, 496 byte

M=magick
L=$((400-$(($1))/2)),$((400+$(($2))/2))
R=$((400+$(($1))/2)),$((400-$(($2))/2))
Z=" $L $R" Y=" -1 x";D=' -draw' K=' -stroke'
A=' -strokewidth 3 +antialias -fill'
$M xc:[800x]$A none$K \#000$D "rectangle$Z"$D "line$Z"$K \#00F8$D "circle$Z"$K \#0F08$D "circle $R $L" -depth 8 png:a
$M a txt:-|sed "/38C/!d;s/:.*//">x;P=`head$Y`;Q=`tail$Y`
$M a$A \#F008$K \#F008$D "line $P $Q" b
$M b txt:-|sed "/C70/!d;s/:.*//">x;S=`head$Y`;T=`tail$Y`
$M b$A \#F804$K \#F80$D "polyline $L $S $R $T $L" x:

Hasil dengan "rhombus.sh 180 120"

Lebih tepat (menggunakan kanvas 6400x6400 bukannya 800x800), 570 byte

Persimpangan tidak tepat; arahan "strokewidth" membuat garis-garis cukup lebar untuk memastikan setidaknya satu piksel penuh dicampur hanya dengan warna dari dua garis yang berpotongan, tetapi dalam kasus terburuk (25x200 dan 200x25) penyeberangan berada pada sudut kecil sehingga awan piksel campuran panjangnya beberapa piksel, dan karena kami memilih piksel campuran pertama dan terakhir, ada sedikit kesalahan. Menggunakan kanvas 8x lebih besar dengan goresan yang sama dan kemudian menurunkan hasilnya mengurangi kesalahan menjadi kurang dari satu piksel, tetapi pada sekitar waktu hukuman 64x.

M=magick
L=$((3200-$(($1))*4)),$((3200+$(($2))*4))
R=$((3200+$(($1))*4)),$((3200-$(($2))*4))
K=-stroke;A='-strokewidth 3 +antialias'
$M xc:[6400x] $A -fill none $K \#000 -draw "rectangle $L $R" \
-draw "line $L $R" $K \#00F8 -draw "circle $L $R" \
$K \#0F08 -draw "circle $R $L" -depth 8 png:a 
$M a txt:-|grep 38C077|sed -e "s/:.*//p">x
P=`head -1 x`;Q=`tail -1 x`
$M a $A -fill \#F008 $K \#F008 -draw "line $P $Q" png:b
$M b txt:-|grep C70000|sed -e "s/:.*//p">x
S=`head -1 x`;T=`tail -1 x`
$M b $A -fill \#F804 $K \#F80 -draw "polyline $L $S $R $T $L" -resize 800 x:

Hasil normal 800x800 dibandingkan 6400x6400 tepat:

Tidak Disatukan:

# rhombus.sh
# Inscribe a rhombus in the rectangle with dimensions 2*$1, 2*$2

# Run with "rhombus.sh W H"

M=magick

W=${1:-100};H=${2:-40}

# L locates the lower left corner of the rectangle
L=$((400-$((W))/2)),$((400+$((H))/2))

# R locates the upper right corner of the rectangle
R=$((400+$((W))/2)),$((400-$((H))/2))

# We'll need this several times
A='-strokewidth 3 +antialias'

# Establish 800x800 canvas (white) (circles + rectangle will
# always fit in 764x764)
#
# Draw the W x H rectangle (black) in center of canvas
#
# Draw two circles (blue, 50% alpha [#00F8] and green, 50% alpha [#0F08])
#  one centered at point L with peripheral point R
#  the other centered at point R with peripheral point L

$M xc:[800x] $A -fill none \
       -stroke \#000  -draw "rectangle $L $R" \
                      -draw "line      $L $R" \
       -stroke \#00F8 -draw "circle    $L $R" \
       -stroke \#0F08 -draw "circle    $R $L" \
       -depth 8 a.png 

# Find P and Q, the 2 intersections of the circles,
# that have mixed color #38C077 
$M a.png txt:-|grep 38C077|sed -e "s/:.*//p">x
P=`head -1 x`;Q=`tail -1 x`

# Draw line connecting the intersections P and Q
$M a.png $A -fill \#F008 -stroke \#F008 -draw "line $P $Q" b.png

# Find S and T, the 2 intersections of the line with the original rectangle,
# that have mixed color #C70000
$M b.png txt:-|grep C70000|sed -e "s/:.*//p">x
S=`head -1 x`;T=`tail -1 x`

# Draw the rhombus
$M b.png $A -fill \#F804 -stroke \#F80 -draw "polyline $L $S $R $T $L" d.png

R, 290 byte

function(A,B,p=polygon){R=A^2+B^2
D=2*A
a=sqrt(R)*cbind(cos(t<-seq(0,2*pi,.01)),sin(t))
b=t(t(a)+c(A,B))
x=range(a,b)
plot(NA,xli=x,yli=x,as=1,ax=F,an=F)
rect(0,0,A,B)
segments(0,0,A,B,c=4)
p(a,b=4)
p(b,b=4)
curve(B/2-A*x/B+A^2/2/B,co=4,a=T)
p(cbind(c((R-2*B^2)/D,A,R/D,0),c(B,B,0,0)),b=3)}

Fungsi anonim, output ditampilkan di layar. Sedikit ungolfed, dengan komentar:

function(A,B){
    R=A^2+B^2
    D=2*A
    t=seq(0,2*pi,.01)
    a=sqrt(R)*cbind(cos(t),sin(t)) #Circle with (0,0) as center
    b=t(t(a)+c(A,B)) #Second circle transposed to (A,B) center
    x=range(a,b)
    #Empty plot, large enough to fit the 2 circles:
    plot(NA,xlim=x,ylim=x,asp=1,axes=F,ann=F)
    rect(0,0,A,B) #Initial rectangle
    segments(0,0,A,B,col=4) #Rectangle diagonal
    polygon(a,border=4) #Circle 1 (border is b thanks to partial matching)
    polygon(b,border=4) #Circle 2
    curve(B/2-A*x/B+A^2/2/B,col=4,add=T) #Line joining circles intersection
    polygon(cbind(c((R-2*B^2)/D,A,R/D,0),c(B,B,0,0)),border=3) #Rhombus
}

Contoh output untuk (120.100):

LibreLogo , 270 byte

Input pengguna diambil sebagai array: [width, height]atau [height, width].

Kode:

fc [24]
D=180
R=sorted(eval(input "))
W=R[1]
H=R[0]
L=sqrt W**2+H**2
A=D/π*asin(H/L)
Z=A*2
S=L/2/cos A*π/D rectangle[W,H]pc 255 lt A fd 400 bk 800 fd 400 rt A pu bk H/2 lt 90 fd W/2 pd circle L*2 rt D-A fd L circle L*2 pc [5]lt D-A fd S lt Z fd S rt D+Z fd S lt Z fd S

Hasil:

Penjelasan:

fc [24]                        ; Fill Color = Invisible
D = 180                        ; D = 180° (Saved Bytes)
R = sorted( eval( input " ) )  ; R = Sorted Array of Rectangle Width and Height (User Input)
W = R[1]                       ; W = Rectangle Width
H = R[0]                       ; H = Rectangle Height
L = sqrt W**2 + H**2           ; L = Rectangle Diagonal Length
A = D / π * asin( H / L )      ; A = Rectangle Diagonal Angle°
Z = A * 2                      ; Z = Rectangle Diagonal Angle° * 2 (Saved Bytes)
S = L / 2 / cos A * π / D      ; S = Rhombus Side Length
rectangle [W, H]               ; Draw Rectangle
pc 255                         ; Pen Color = Blue
lt A                           ; Left = Rectangle Diagonal Angle°
fd 400                         ; Forward = 400 pt
bk 800                         ; Back = 800 pt
fd 400                         ; Forward = 400 pt
rt A                           ; Right = Rectangle Diagonal Angle°
pu                             ; Pen Up
bk H / 2                       ; Back = Rectangle Height / 2
lt 90                          ; Left = 90°
fd W / 2                       ; Forward = Rectangle Width / 2
pd                             ; Pen Down
circle L * 2                   ; Draw Left Circle (Radius = Rectangle Diagonal Length)
rt D - A                       ; Right = 180° - Rectangle Diagonal Angle°
fd L                           ; Forward = Rectangle Diagonal Length
circle L * 2                   ; Draw Right Circle (Radius = Rectangle Diagonal Length)
pc [5]                         ; Pen Color = Red
lt D - A                       ; Left = 180° - Rectangle Diagonal Angle°
fd S                           ; Forward = Rhombus Side Length
lt Z                           ; Left = Rectangle Diagonal Angle° * 2
fd S                           ; Forward = Rhombus Side Length
rt D + Z                       ; Right = 180° + Rectangle Diagonal Angle° * 2
fd S                           ; Forward = Rhombus Side Length
lt Z                           ; Left = Rectangle Diagonal Angle° * 2
fd S                           ; Forward = Rhombus Side Length

Python 3.5 + Tkinter, 433 atau 515 byte

Tidak Berwarna (433 byte):

from tkinter import*
def V(a,b):S=500;Y,Z=S+a,S-b;M=(a**2+b**2)**0.5;D=Tk();C=Canvas(D);B=C.create_oval;X=C.create_line;B(S+M,S-M,S-M,S+M);B(Y-M,Z+M,Y+M,Z-M);X(Y,Z,S,S);C.create_rectangle(Y,S,S,Z);Q=-((Z-S)/(Y-S))**-1;U,V=(Y+S)/2,(Z+S)/2;X(U+M,V+M*Q,U-M,V-M*Q);P=[(Y,Q*(Y-U)+V),(((Z-V)/Q)+U,Z)][a>b];L=[(S,Q*(S-U)+V),(((S-V)/Q)+U,S)][a>b];X(S,S,P[0],P[1]);X(Y,Z,P[0],P[1]);X(Y,Z,L[0],L[1]);X(S,S,L[0],L[1]);C.pack(fill=BOTH,expand=1)

Berwarna (515 byte):

from tkinter import*
def V(a,b):S=500;t='blue';Y,Z=S+a,S-b;M=(a**2+b**2)**0.5;D=Tk();C=Canvas(D);B=C.create_oval;X=C.create_line;B(S+M,S-M,S-M,S+M,outline=t);B(Y-M,Z+M,Y+M,Z-M,outline=t);X(Y,Z,S,S,fill=t);C.create_rectangle(Y,S,S,Z);Q=-((Z-S)/(Y-S))**-1;U,V=(Y+S)/2,(Z+S)/2;X(U+M,V+M*Q,U-M,V-M*Q,fill=t);P=[(Y,Q*(Y-U)+V),(((Z-V)/Q)+U,Z)][a>b];L=[(S,Q*(S-U)+V),(((S-V)/Q)+U,S)][a>b];o='orange';X(S,S,P[0],P[1],fill=o);X(Y,Z,P[0],P[1],fill=o);X(Y,Z,L[0],L[1],fill=o);X(S,S,L[0],L[1],fill=o);C.pack(fill=BOTH,expand=1)

Fungsi bernama yang mengambil input sebagai 2 angka yang dipisahkan koma. Output diberikan dalam jendela terpisah yang mungkin harus Anda ubah ukurannya untuk melihat output penuh. Berikut adalah contoh keluaran berwarna untuk V(180,130):

SmileBASIC, 280 byte

INPUT W,H
W=MAX(W,H)/4H=MIN(W,H)/4D=SQR(W*W+H*H)N=D+W
M+D+H
GBOX D,D,N,M,#RED
GCIRCLE D,M,D
GCIRCLE N,D,D
GLINE D,M,N,D
X=D+W/2Y=D+H/2A=ATAN(W,H)E=D*H/W/2S=E*COS(A)T=E*SIN(A)GLINE X-S*9,Y-T*9,X+S*9,Y+T*9GCOLOR-#L
GLINE D,M,X-S,Y-T
GLINE D,M,X+S,M
GLINE N,D,X+S,Y+T
GLINE N,D,X-S,D

(Cuplikan layar / penjelasan akan segera diposting) Warna latar belakang hitam, persegi panjang merah, lingkaran dan garis putih, dan belah ketupat berwarna kuning.