Wenn Sie nur ein Lineal und einen Kompass haben, schreiben Sie eine Raute in das gegebene Rechteck und teilen Sie zwei gegenüberliegende Punkte.

Eingang

Eingabe sind die Abmessungen des Rechtecks. Im gezeigten Beispiel wäre das 125, 50. Sie können Eingaben auf die bequemste Weise vornehmen (als zwei Ganzzahlen, Liste, Zeichenfolgen usw.).

Die größere Abmessung beträgt mindestens 100, während die kleinere mindestens 25 beträgt. Beide Cap bei 200.

Ausgabe

Die Ausgabe erfolgt in Form eines Bildes (auf dem Bildschirm angezeigt oder als Datei gespeichert)

• Das Eingaberechteck
• Alle "arbeitenden" Linien / Kreise
• Die eingeschriebene Raute

in verschiedenen Farben. Im obigen Bild ist das Rechteck schwarz, die Arbeitslinien blau und die Raute orange. Die Linien sollten in der in der Liste angegebenen Reihenfolge gezeichnet werden (z. B. Rhombus überschreibt Arbeitslinien und Rechtecke).

Das Ausgabebild muss groß genug sein, um alles zu enthalten. Beispielsweise können die angezeigten Kreise nicht außerhalb der Grenzen liegen.

Methode

Die im obigen Beispielbild verwendete Methode lautet:

• Zeichnen Sie einen Kreis mit der linken unteren Ecke als Mittelpunkt und der rechten oberen Ecke als Punkt auf dem Umfang. Geben Sie dabei einen Radius an, der der Diagonale des Rechtecks ​​entspricht.
• Gehen Sie genauso vor, tauschen Sie jedoch die Mittelpunkt- und Umfangspunkte aus.
• Zeichnen Sie eine Linie zwischen den Schnittpunkten der beiden Kreise und geben Sie der Diagonale des Rechtecks ​​eine senkrechte Halbierung.
• Verwenden Sie die Schnittpunkte der neuen Linie und des neuen Rechtecks, um die Raute zu zeichnen.

Dies funktioniert, weil die Innendiagonalen einer Raute sich immer senkrecht halbieren. Ich lege hier jedoch keinen vollständigen Beweis dafür bei.

Dies ist nicht die einzige Methode, um Ihre Raute zu erhalten, und Sie können eine andere verwenden, vorausgesetzt, Sie erklären, was Sie tun. Ich glaube, es ist wahrscheinlich das einfachste.

Regeln

Sie können nur Kreise und Linien (bzw. Liniensegmente) zeichnen. Ein Kreis wird mit einem Mittelpunkt und einem Umfangspunkt definiert. Eine Linie wird durch zwei beliebige Punkte definiert. Linien müssen keine festgelegte Länge haben, aber sie müssen mindestens die definierenden Punkte abdecken (beachten Sie das Beispielbild: Die Linie verläuft ein Stück über die Kreiskreuzungen hinaus, jedoch nicht bis zur Kante). Bei Kreisen gilt der Radius vom Mittelpunkt zum gewählten Umfangspunkt als Arbeitslinie und muss angezeigt werden.

Um die Zeilen zu rastern, können Sie einen beliebigen anerkannten Algorithmus (z. B. Bresenham) verwenden oder sich auf die in Ihrer Sprache enthaltenen Funktionen verlassen. Wenn Ihre Ausgabe vektorbasiert ist, stellen Sie bitte sicher, dass sie mit einer Auflösung angezeigt wird, die mindestens so groß ist wie das Eingaberechteck in Pixel. Außerdem werden Sie auf einer einfachen Leinwand zeichnen, also unterdrücken Sie bitte alle Gittermarkierungen oder überflüssigen Ausgaben.

Kein Schummeln! Sie können die Platzierung von Punkten / Linien / Kreisen nur anhand der bisher festgelegten Werte bestimmen. Wenn Sie nicht erklären können, wie Sie Ihre Arbeitslinien / -kreise verwenden, um zu zeigen, dass es sich um eine Raute handelt, machen Sie es falsch.

Sie können jedes beliebige Paar von gegenüberliegenden Punkten verwenden, und das Rechteck muss nicht achsenausgerichtet gezeichnet werden, solange die Ausgabe korrekt ist.

Die Eingabe wird immer ein nicht quadratisches Rechteck sein. Machen Sie sich also keine Gedanken über die Sondergehäuse.

Schließlich ist dies Standard-Code-Golf, so dass die niedrigste Größe in Bytes gewinnt.

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

Die Eingabe sollte im Format erfolgen [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>

Nur eine Menge Mathe und Zeichnen ... Das Rechteck wird seitlich gezeichnet, wenn die Höhe größer als die Breite ist, was ich für zulässig halte.

Mathematica, 157 148 158 Bytes

Vielen Dank an Martin Ender für Kommentare in gewohnt hoher Qualität! In diesem Fall werden 9 Bytes gespeichert.

Wurde bearbeitet, nachdem klargestellt wurde, dass die Argumente in beliebiger Reihenfolge kommen können. 10 Bytes hinzugefügt, um dies zu kompensieren.

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

Auch hier brilliert Mathematica: Hochwertige Grafikausgabe mit mathematischen Berechnungen. Der gleiche Code mit Leerzeichen und Zeilenumbrüchen für die menschliche Lesbarkeit:

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

Unbenannte Funktion eines einzelnen Arguments, das ein geordnetes Paar positiver Zahlen ist; Das letzte @@ Sort@# &konvertiert dieses Paar in zwei numerische Argumente, wobei die erste Zahl die kleinere ist. LineErzeugt einen polygonalen Pfad von Punkt zu Punkt, der sich in ein geschlossenes Polygon verwandelt, wenn der erste und der letzte Punkt identisch sind. CircleErzeugt einen Kreis mit gegebenem Mittelpunkt und Radius. Spezielle Punkte ound c(die untere linke und die obere rechte Rechteckecke), p(eine dritte Raute, die durch eine mathematische Formel angegeben wird) und k(die beim Zeichnen der senkrechten Winkelhalbierenden hilfreich ist) werden auf dem Weg benannt, um beim erneuten Aufrufen Bytes zu speichern , genau wie das besondere Punktepaarl = {o,c}. Mathematica fügt gerne Punkte direkt hinzu, multipliziert beide Koordinaten mit demselben Faktor, berechnet das Skalarprodukt usw., was den Code vereinfacht.

Beispielausgabe mit Argumenten 125und 50:

MetaPost, 473 (mit Farbe) 353 (ohne Farbe)

Farbig (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;

Nicht gefärbt (353 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;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;

Nie zuvor verwendet, und ich bin sicher, ich habe es geschlachtet ...
Aber wenn Sie das auf dieser Website ausführen:

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

Es verwendet den Schnittpunkt der Kreise, um die zweite Achse zu zeichnen, und verwendet dann den Schnittpunkt der Achse und des Rechtecks, um die endgültige Raute zu zeichnen. Obwohl ich hätte schummeln und nur eine Linie senkrecht zur ersten Achse zeichnen können, haha.

Um die Abmessungen zu ändern, ändern Sie einfach A und B.

Unabhängig davon erhalten Sie (für L = 170, H = 100):

Desmos, 375 (oder 163) Bytes

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)

wund hsind die Eingänge. Probieren Sie es auf Desmos!

Alternative 163-Byte-Version:

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

Diese Version erfordert, dass jede Zeile kopiert und in jede separate Zeile in Desmos eingefügt wird. Meta muss noch entscheiden, ob dies eine gültige Zählmethode ist, aber die erstere Methode ist definitiv in Ordnung.

ImageMagick Version 7.0.3 + Bash + Sed, 496 Bytes

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:

Ergebnis mit "rhombus.sh 180 120"

Genauer gesagt (6400 x 6400 Zeichenfläche anstelle von 800 x 800), 570 Byte

Die Schnittpunkte sind nicht genau; Die "strokewidth" -Direktive macht die Linien breit genug, um sicherzustellen, dass mindestens ein ganzes Pixel nur mit den Farben der beiden sich kreuzenden Linien gemischt wird. Im schlimmsten Fall (25x200 und 200x25) befinden sich die Kreuzungen jedoch in einem kleinen Winkel, sodass die Wolke Die Anzahl der gemischten Pixel beträgt mehrere Pixel, und da wir das erste und das letzte gemischte Pixel auswählen, liegt ein kleiner Fehler vor. Wenn Sie eine 8x größere Zeichenfläche mit derselben Strichstärke verwenden und das Ergebnis dann verkleinern, wird der Fehler auf weniger als ein Pixel reduziert, jedoch mit einer 64x Zeitstrafe.

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:

Ergebnisse von normalen 800x800 im Vergleich zu präzisen 6400x6400:

Ungolfed:

# 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 Bytes

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

Anonyme Funktion, Ausgabe wird auf dem Bildschirm angezeigt. Etwas ungolfed, mit Kommentaren:

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
}

Beispielausgabe für (120,100):

LibreLogo , 270 Bytes

Benutzereingaben werden als Array genommen: [width, height]oder [height, width].

Code:

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

Ergebnis:

Erläuterung:

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 oder 515 Bytes

Nicht gefärbt (433 Bytes):

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)

Farbig (515 Bytes):

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)

Eine benannte Funktion, die Eingaben als 2 durch Kommas getrennte Zahlen akzeptiert. Die Ausgabe wird in einem separaten Fenster angezeigt, dessen Größe Sie möglicherweise ändern müssen, um die vollständige Ausgabe anzuzeigen. Hier ist ein Beispiel für eine farbige Ausgabe für V(180,130):

SmileBASIC, 280 Bytes

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

(Screenshot / Erklärung wird in Kürze veröffentlicht) Hintergrundfarbe ist schwarz, Rechteck ist rot, Kreise und Linien sind weiß und die Raute ist gelb.