Realmente quería un rombo, pero todo lo que obtuve fue este estúpido rectángulo

33

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

rombo en rectángulo

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.

Geobits
fuente
¿Podemos usar una fórmula matemática para decidir, por ejemplo, los puntos finales de la línea dibujada entre las intersecciones de los círculos una vez que se han dibujado (sin analizar realmente la imagen para ver dónde están las intersecciones)?
ETHproductions
@ETHproductions Yo diría que sí, ya que es bastante fácil mostrar que el ángulo entre ellos y el radio es de 60 grados a cada lado, y que forman triángulos equiláteros. Si alguien tiene alguna objeción, estoy dispuesto a escuchar eso también.
Geobits
3
¿Podemos suponer que la primera entrada será mayor que la segunda (o viceversa), o las respuestas tienen que ser capaces de manejar rectángulos orientados tanto vertical como horizontalmente?
Martin Ender el
¿Cuál es el propósito del segmento de línea corta dentro del rectángulo?
12Me21

Respuestas:

11

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.

ETHproducciones
fuente
Oooh, 10 bytes menos que 444: P
Kritixi Lithos
@KritixiLithos Ahora tengo 10 bytes menos que 400;-)
ETHproductions
El rectángulo se inscribe en el rombo cuando la altura es mayor que el ancho.
Larkeith
1
@ Larkeith Oops, no sabía que teníamos que cubrir esos casos. Corregido a un costo de 42 bytes.
ETHproductions
Puede usar "getContext` 2d `" (sin espacios) para guardar unos pocos bytes (¿por qué tuvieron que usar `y romper el descuento ...)
12Me21
10

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:

ingrese la descripción de la imagen aquí

Greg Martin
fuente
1
Re espacios en blanco innecesarios. Puedes usar este truco para guardar un byte {0,0}. Como no hay ningún requisito para usar azul y naranja, puede guardar bytes usando en Redlugar de Orange. Está usando Linecuatro veces, lo que es más que suficiente para guardar bytes i=Line;(como regla general, si la expresión tiene ncaracteres y la usa las mveces que necesita (m-1)*(n-1) > 4, menos si puede asignar la variable durante el primer uso sin paréntesis).
Martin Ender
Ese 0{,}truco es fantástico: D
Greg Martin
Me temo que esto no funciona si el segundo lado es más largo que el primero. Sin embargo, la orientación no necesita ser coherente, por lo que esto se puede solucionar agregando @@Sort@#&e intercambiando #y a lo #2largo del código o, alternativamente, adaptándolo para que funcione con rectángulos de orientación vertical.
Martin Ender
Sí, eso fue intencional ... parece que estamos esperando aclaraciones sobre si podemos asumir que las dimensiones vienen en el orden que queremos.
Greg Martin
9

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

Imagen

Urna de pulpo mágico
fuente
3

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.

GamrCorps
fuente
Esto parece suponer que el rectángulo de entrada está en orientación horizontal, lo que no se especifica en la tarea.
Henning Makholm
1
Para mí, "el rectángulo no necesita dibujarse alineado con el eje" implica que no hay una orientación predeterminada en el rectángulo, incluido el paisaje versus el retrato, que debe conservarse.
Greg Martin
Dado que solo se proporciona el tamaño (no las coordenadas), la salida se puede alinear como desee, suponiendo que el tamaño sea correcto.
Geobits
La primera vez que veo a Desmos siendo utilizado como un lenguaje de golf :)
Kritixi Lithos
3

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"

ingrese la descripción de la imagen aquí

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:

resultados normales vs 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
Glenn Randers-Pehrson
fuente
Me gusta cómo detectas las intersecciones, muy agradable. ¿Es correcto el último color mezclado? Pregunto porque parece que las líneas del rombo y el rectángulo están ligeramente apagadas. Pensé que tal vez el color se estaba detectando en un punto ligeramente fuera de lugar debido al suavizado (posiblemente también el ancho del trazo).
Geobits
2

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

ingrese la descripción de la imagen aquí

plannapus
fuente
2

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:

ingrese la descripción de la imagen aquí

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
Grant Miller
fuente
1

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

Salida de muestra

R. Kap
fuente
0

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.

12Me21
fuente