Dado solo una regla y una brújula, inscriba un rombo dentro del rectángulo dado, compartiendo dos puntos opuestos.

Entrada

La entrada es las dimensiones del rectángulo. En el ejemplo que se muestra, eso sería 125, 50. Puede tomar la entrada de la forma más conveniente (como dos enteros, lista, cadenas, etc.).

La dimensión más grande será de un mínimo de 100, mientras que la más pequeña será de un mínimo de 25. Ambos tope a 200.

Salida

La salida será una imagen (mostrada en la pantalla o guardada como un archivo) que muestra

• El rectángulo de entrada
• Todas las líneas / círculos "de trabajo"
• El rombo inscrito

En distintos colores. En la imagen de arriba, El rectángulo es negro, las líneas de trabajo son azules y el rombo naranja. Las líneas deben dibujarse en el orden que se muestra en la lista (por ejemplo, el rombo sobrescribe las líneas de trabajo y el rectángulo).

La imagen de salida debe ser lo suficientemente grande como para contener todo. Por ejemplo, los círculos que se muestran no pueden salir de los límites.

Método

El método utilizado en la imagen de ejemplo anterior es:

• Dibuja un círculo usando la esquina inferior izquierda como centro y la superior derecha como un punto en el perímetro, dando un radio igual a la diagonal del rectángulo.
• Haga lo mismo, pero intercambiando puntos centrales y perimetrales.
• Dibuja una línea entre las intersecciones de los dos círculos, dando una bisectriz perpendicular a la diagonal del rectángulo.
• Usa las intersecciones de la nueva línea y rectángulo para dibujar el rombo.

Esto funciona porque las diagonales interiores de un rombo siempre se bisecan perpendicularmente entre sí. Sin embargo, no incluyo una prueba completa de esto aquí.

Este no es el único método para obtener tu rombo, y puedes usar otro, dado que explicas lo que estás haciendo. Sin embargo, creo que es probablemente la más fácil.

Reglas

Solo puede dibujar círculos y líneas (o más bien, segmentos de línea). Un círculo se define con un punto central y un punto perimetral. Una línea se define por dos puntos cualesquiera. Las líneas no tienen que tener una longitud específica, pero al menos deben cubrir los puntos de definición (tenga en cuenta la imagen de ejemplo: la línea pasa un poco más allá de las intersecciones del círculo, pero no hasta el borde). Para los círculos, el radio desde el centro hasta el punto del perímetro elegido se considera una línea de trabajo y debe mostrarse.

Para rasterizar las líneas, puede usar cualquier algoritmo reconocido (por ejemplo, el de Bresenham), o confiar en cualquier componente que pueda tener su idioma. Si su salida está basada en vectores, asegúrese de que se muestre con una resolución al menos tan grande como el rectángulo de entrada en píxeles. Además, dibujará en un lienzo plano, por lo tanto, elimine las marcas de cuadrícula o los resultados extraños.

No hacer trampa! Solo puede determinar la ubicación de puntos / líneas / círculos utilizando lo que ha establecido hasta ahora. Si no puede explicar cómo usar sus líneas / círculos de trabajo para mostrar que es un rombo, lo está haciendo mal.

Puede usar cualquier par de puntos opuestos que desee, y el rectángulo no necesita dibujarse alineado con el eje, siempre que la salida sea correcta.

La entrada siempre será un rectángulo no cuadrado, así que no te preocupes por una carcasa especial.

Por último, este es el código estándar de golf, por lo que gana el tamaño más bajo en bytes.

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

La entrada debe darse en el formato [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>

Solo muchas matemáticas y dibujos ... El rectángulo se dibuja de lado si la altura es mayor que el ancho, lo cual creo que está permitido.

Mathematica, 157 148 158 bytes

¡Gracias a Martin Ender por los comentarios con su alta calidad habitual! 9 bytes guardados en este caso.

Editado una vez que se aclaró que los argumentos pueden venir en cualquier orden; 10 bytes agregados para compensar.

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

Nuevamente, aquí es donde brilla Mathematica: salida de gráficos de alto nivel que involucra cómputo matemático. El mismo código con espacios y líneas nuevas para la legibilidad humana:

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

Función sin nombre de un argumento único que es un par ordenado de números positivos; el final @@ Sort@# &convierte ese par en dos argumentos numéricos donde el primer número es el más pequeño. Lineproduce una ruta poligonal de punto a punto, que se convertirá en un polígono cerrado si el primer y el último punto son iguales; Circleproduce un círculo con centro y radio dados. Los puntos especiales oy c(las esquinas rectangulares inferior izquierda y superior derecha), p(una tercera esquina rombo, dada por una fórmula matemática), y k(ayudando a dibujar la bisectriz perpendicular) reciben nombres en el camino para guardar bytes cuando se les llama nuevamente , como es el par especial de puntosl = {o,c}. Mathematica se complace en agregar puntos directamente, multiplicar ambas coordenadas por el mismo factor, tomar su producto de puntos, etc., todo lo cual simplifica el código.

Salida de muestra, con argumentos 125y 50:

MetaPost, 473 (con color) 353 (sin color)

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

Sin color (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;

Nunca he usado esto antes, y estoy seguro de que lo maté ...
Pero cuando lo ejecutas en este sitio web:

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

Utiliza la intersección de los círculos para dibujar el segundo eje, y luego usa la intersección del eje y el rectángulo para dibujar el rombo final. Aunque podría haber hecho trampa y dibujar una línea perpendicular al primer eje jaja.

Para cambiar las dimensiones, simplemente modifique A y B.

En cualquier caso, terminas con (para L = 170, H = 100):

Desmos, 375 (o 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)

wy hson las entradas. Pruébalo en Desmos!

Versión alternativa de 163 bytes:

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

Esta versión requiere que cada línea se copie y pegue en cada línea separada en Desmos. Meta aún necesita decidir si este es un método de conteo válido, pero el método anterior definitivamente está bien.

ImageMagick Versión 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:

Resultado con "rombo.sh 180 120"

Más preciso (utilizando un lienzo de 6400x6400 en lugar de 800x800), 570 bytes

Las intersecciones no son exactas; La directiva "ancho de trazo" hace que las líneas sean lo suficientemente anchas para asegurarse de que al menos un píxel completo se mezcle solo con los colores de las dos líneas que se cruzan, pero en el peor de los casos (25x200 y 200x25) los cruces están en un ángulo pequeño para que la nube de píxeles mezclados tiene una longitud de varios píxeles, y dado que seleccionamos el primer y el último píxel mixto, hay un pequeño error. El uso de un lienzo 8x más grande con el mismo ancho de trazo y luego reducir el resultado reduce el error a menos de un píxel, pero con una penalización de tiempo de aproximadamente 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:

Resultados de 800x800 normales versus 6400x6400 precisos:

Sin golf:

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

Función anónima, la salida se muestra en la pantalla. Ligeramente descamados, con comentarios:

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
}

Ejemplo de salida para (120,100):

LibreLogo , 270 bytes

La entrada del usuario se toma como una matriz: [width, height]o [height, width].

Código:

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

Resultado:

Explicación:

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 o 515 bytes

Sin color (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)

Color (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)

Una función con nombre que toma la entrada como 2 números separados por comas. La salida se proporciona en una ventana separada que puede tener que cambiar de tamaño para ver la salida completa. Aquí hay una muestra de salida en color para 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

(La captura de pantalla / explicación se publicará pronto) El color de fondo es negro, el rectángulo es rojo, los círculos y las líneas son blancos y el rombo es amarillo.