Biorąc pod uwagę tylko linię prostą i kompas, wpisz romb wewnątrz danego prostokąta, dzieląc dwa przeciwne punkty.

Wkład

Dane wejściowe to wymiary prostokąta. W pokazanym przykładzie byłoby to 125, 50. Możesz pobierać dane w najbardziej dogodny sposób (jako dwie liczby całkowite, lista, ciągi znaków itp.).

Większy wymiar będzie wynosił minimum 100, a mniejszy będzie wynosił minimum 25. Oba limity wynoszą 200.

Wydajność

Wyjściem będzie obraz (wyświetlany na ekranie lub zapisany jako plik)

• Prostokąt wejściowy
• Wszystkie „działające” linie / okręgi
• Wpisany romb

w wyraźnych kolorach. Na powyższym obrazie prostokąt jest czarny, linie robocze są niebieskie, a romb pomarańczowy. Linie powinny być rysowane w kolejności pokazanej na liście (np. Romb zastępuje linie robocze i prostokąt).

Obraz wyjściowy musi być wystarczająco duży, aby pomieścić wszystko. Na przykład pokazane kręgi nie mogą wyjść poza granice.

metoda

Metodą zastosowaną w powyższym przykładzie jest:

• Narysuj okrąg, używając lewego dolnego rogu jako środka, a górnego prawego jako punktu na obwodzie, nadając promień równy przekątnej prostokąta.
• Zrób to samo, ale zamień punkty środkowe i obwodowe.
• Narysuj linię między przecięciami dwóch kół, nadając prostopadłą dwusieczną do przekątnej prostokąta.
• Użyj skrzyżowań nowej linii i prostokąta, aby narysować romb.

Działa to, ponieważ wewnętrzne przekątne rombu zawsze są prostopadłe do siebie. Nie dołączam tutaj jednak pełnego tego dowodu.

Nie jest to jedyna metoda na zdobycie rombu i możesz użyć innej, biorąc pod uwagę, że wyjaśnisz, co robisz. Myślę , że to chyba najłatwiejsze.

Zasady

Możesz rysować tylko koła i linie (a raczej segmenty linii). Okrąg jest definiowany za pomocą punktu środkowego i punktu obwodowego. Linia jest zdefiniowana przez dowolne dwa punkty. Linie nie muszą mieć żadnej określonej długości, ale muszą co najmniej obejmować punkty definiujące (zwróć uwagę na przykładowy obraz: linia przechodzi nieco poza przecięcia okręgu, ale nie do krawędzi). W przypadku okręgów promień od środka do wybranego punktu obwodowego jest uważany za linię roboczą i musi zostać pokazany.

Aby zrasteryzować linie, możesz użyć dowolnego rozpoznanego algorytmu (np. Bresenhama) lub polegać na wszelkich wbudowaniach, jakie może mieć Twój język. Jeśli Twoje dane wyjściowe są oparte na wektorze, upewnij się, że są wyświetlane w rozdzielczości co najmniej tak dużej, jak prostokąt wejściowy w pikselach. Będziesz także rysować na zwykłym płótnie, więc proszę, pomiń wszelkie znaki siatki lub obce wyniki.

Bez oszukiwania! Możesz określić położenie punktów / linii / okręgów tylko na podstawie tego, co ustaliłeś do tej pory. Jeśli nie potrafisz wyjaśnić, jak używać linii roboczych / okręgów do pokazania, że ​​to romb, robisz to źle.

Możesz użyć dowolnej pary przeciwnych punktów, a prostokąt nie musi być narysowany w linii, o ile dane wyjściowe są prawidłowe.

Wejście zawsze będzie prostokątem innym niż kwadrat, więc nie martw się o specjalną obudowę.

Wreszcie jest to standardowy kod golfowy, więc wygrywa najmniejszy rozmiar w bajtach.

HTML + JavaScript (ES6), 34 + 353 = 387 bajtów

Dane wejściowe należy podać w formacie [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>

Po prostu dużo matematyki i rysowania ... Prostokąt jest rysowany na boki, jeśli wysokość jest większa niż szerokość, która moim zdaniem jest dozwolona.

Mathematica, 157 148 158 bajtów

Podziękowania dla Martina Endera za komentarze w ich wysokiej jakości! W tym przypadku zapisano 9 bajtów.

Edytowane, gdy wyjaśniono, że argumenty mogą występować w dowolnej kolejności; Dodano 10 bajtów w celu kompensacji.

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@#&

Ponownie tutaj świeci Mathematica: grafika na wysokim poziomie z wykorzystaniem obliczeń matematycznych. Ten sam kod ze spacjami i znakami nowej linii dla czytelności dla ludzi:

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@# &

Nienazwana funkcja pojedynczego argumentu, który jest uporządkowaną parą liczb dodatnich; końcowy @@ Sort@# &konwertuje tę parę na dwa argumenty liczbowe, przy czym pierwsza liczba jest mniejsza. Linetworzy ścieżkę wielokątną od punktu do punktu, która zamieni się w zamknięty wielokąt, jeśli pierwszy i ostatni punkt są takie same; Circletworzy okrąg o danym środku i promieniu. Specjalne punkty oi c(lewy dolny i prawy górny róg prostokąta), p(trzeci romb rombu, określony wzorem matematycznym) i k(pomagając narysować prostopadły dwusieczny) otrzymują nazwy po drodze, aby zapisać bajty po ponownym wywołaniu , podobnie jak specjalna para punktówl = {o,c}. Mathematica chętnie dodaje punkty bezpośrednio, mnoży obie współrzędne przez ten sam współczynnik, bierze ich iloczyn iloczynu itp., Które upraszczają kod.

Przykładowe dane wyjściowe z argumentami 125i 50:

MetaPost, 473 (z kolorem) 353 (bez koloru)

Kolorowy (473 bajtów):

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;

Niekolorowane (353 bajty):

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;

Nigdy wcześniej tego nie używałam i jestem pewna, że ​​to zrobiłem ...
Ale kiedy uruchomisz to na tej stronie:

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

Wykorzystuje przecięcie kół, aby narysować drugą oś, a następnie używa przecięcia osi i prostokąta, aby narysować końcowy romb. Chociaż mogłem oszukać i po prostu narysować linię prostopadłą do pierwszej osi haha.

Aby zmienić wymiary, wystarczy zmienić A i B.

Niezależnie od tego kończysz na (dla L = 170, H = 100):

Desmos, 375 (lub 163) bajtów

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)

wi hsą danymi wejściowymi. Wypróbuj na Desmos!

Alternatywna wersja 163-bajtowa:

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

Ta wersja wymaga kopiowania i wklejania każdej linii do każdej osobnej linii w Desmos. Meta nadal musi zdecydować, czy jest to poprawna metoda liczenia, ale poprzednia metoda jest zdecydowanie w porządku.

ImageMagick wersja 7.0.3 + bash + sed, 496 bajtów

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:

Wynik z „rhombus.sh 180 120”

Dokładniej (przy użyciu płótna 6400 x 6400 zamiast 800 x 800), 570 bajtów

Przecięcia nie są dokładne; dyrektywa „strokewidth” sprawia, że ​​linie są wystarczająco szerokie, aby mieć pewność, że co najmniej jeden cały piksel zostanie zmieszany tylko z kolorami dwóch przecinających się linii, ale w najgorszych przypadkach (25 x 200 i 200 x 25) skrzyżowania są pod małym kątem, więc chmura pikseli mieszanych ma kilka pikseli długości, a ponieważ wybieramy pierwszy i ostatni piksel mieszany, istnieje niewielki błąd. Użycie 8-krotnie większego obszaru roboczego o tej samej szerokości linii, a następnie skalowanie wyniku w dół zmniejsza błąd do mniej niż jednego piksela, ale przy około 64-krotnym opóźnieniu czasowym.

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:

Wyniki zwykłego 800 x 800 w porównaniu z dokładnym 6400 x 6400:

Nie golfowany:

# 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 bajtów

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

Funkcja anonimowa, dane wyjściowe są wyświetlane na ekranie. Nieco golfa z komentarzami:

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
}

Przykładowe dane wyjściowe dla (120,100):

LibreLogo , 270 bajtów

Dane wejściowe użytkownika są traktowane jako tablica: [width, height]lub [height, width].

Kod:

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

Wynik:

Wyjaśnienie:

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 lub 515 bajtów

Bezbarwny (433 bajty):

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)

Kolorowy (515 bajtów):

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)

Nazwana funkcja, która przyjmuje dane wejściowe jako 2 liczby oddzielone przecinkami. Dane wyjściowe są podawane w osobnym oknie, którego zmiana może być konieczna, aby zobaczyć pełne dane wyjściowe. Oto przykładowy kolorowy wynik dla V(180,130):

SmileBASIC, 280 bajtów

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

(Zrzut ekranu / wyjaśnienie zostanie wkrótce opublikowany) Kolor tła jest czarny, prostokąt jest czerwony, koła i linie są białe, a romb jest żółty.