Dada apenas uma régua e uma bússola, inscreva um losango dentro do retângulo, compartilhando dois pontos opostos.

Entrada

Entrada é as dimensões do retângulo. No exemplo mostrado, isso seria 125, 50. Você pode receber entradas da maneira que for mais conveniente (como dois números inteiros, lista, seqüências de caracteres, etc.).

A dimensão maior será no mínimo 100, enquanto a menor será no mínimo 25. Ambos terminam em 200.

Saída

A saída será uma imagem (exibida na tela ou salva como um arquivo) mostrando

• O retângulo de entrada
• Todas as linhas / círculos "funcionais"
• O losango inscrito

em cores distintas. Na imagem acima, o retângulo é preto, as linhas de trabalho são azuis e o losango é laranja. As linhas devem ser desenhadas na ordem mostrada na lista (por exemplo, losango substitui as linhas de trabalho e o retângulo).

A imagem de saída precisa ser grande o suficiente para conter tudo. Por exemplo, os círculos mostrados não podem sair dos limites.

Método

O método usado na imagem de exemplo acima é:

• Desenhe um círculo usando o canto inferior esquerdo como centro e o canto superior direito como um ponto no perímetro, fornecendo um raio igual à diagonal do retângulo.
• Faça o mesmo, mas trocando pontos de centro e perímetro.
• Desenhe uma linha entre as interseções dos dois círculos, dando uma bissetor perpendicular à diagonal do retângulo.
• Use as interseções da nova linha e retângulo para desenhar o losango.

Isso funciona porque as diagonais interiores de um losango sempre se cortam perpendicularmente. Não estou incluindo aqui uma prova completa disso.

Este não é o único método para obter seu losango, e você pode usar outro, desde que explique o que está fazendo. Eu acredito que é provavelmente o mais fácil, no entanto.

Regras

Você só pode desenhar círculos e linhas (ou melhor, segmentos de linha). Um círculo é definido com um ponto central e um ponto de perímetro. Uma linha é definida por quaisquer dois pontos. As linhas não precisam ter nenhum comprimento especificado, mas devem cobrir pelo menos os pontos de definição (observe a imagem de exemplo: a linha passa um pouco além das interseções do círculo, mas não até a aresta). Para círculos, o raio do centro até o ponto de perímetro escolhido é considerado uma linha de trabalho e deve ser mostrado.

Para rasterizar as linhas, você pode usar qualquer algoritmo reconhecido (por exemplo, o de Bresenham) ou confiar em quaisquer recursos internos que sua linguagem possa ter. Se sua saída for baseada em vetores, verifique se é exibida em uma resolução pelo menos tão grande quanto o retângulo de entrada em pixels. Além disso, você desenhará em uma tela simples, portanto, suprima quaisquer marcas de grade ou saída estranha.

Sem trapaça! Você só pode determinar o posicionamento de pontos / linhas / círculos usando o que você estabeleceu até agora. Se você não consegue explicar como usar suas linhas / círculos de trabalho para mostrar que é um losango, está fazendo errado.

Você pode usar o par de pontos opostos desejado e o retângulo não precisa ser desenhado alinhado ao eixo, desde que a saída esteja correta.

A entrada sempre será um retângulo não quadrado, portanto, não se preocupe com maiúsculas e minúsculas.

Por fim, este é o código padrão de golfe, e o tamanho mais baixo em bytes vence.

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

A entrada deve ser fornecida no 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>

Muita matemática e desenho ... O retângulo é desenhado de lado se a altura for maior que a largura, o que acredito ser permitido.

Mathematica, 157 148 158 bytes

Agradecemos a Martin Ender pelos comentários com a alta qualidade habitual! 9 bytes salvos neste caso.

Editado assim que foi esclarecido que os argumentos podem vir em qualquer ordem; 10 bytes adicionados 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@#&

Novamente, é aqui que o Mathematica brilha: saída gráfica de alto nível envolvendo computação matemática. O mesmo código com espaços e novas linhas para legibilidade 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@# &

Função sem nome de um único argumento que é um par ordenado de números positivos; o final @@ Sort@# &converte esse par em dois argumentos numéricos em que o primeiro número é menor. Lineproduz um caminho poligonal de ponto a ponto, que se transformará em um polígono fechado se o primeiro e o último pontos forem os mesmos; Circleproduz um círculo com determinado centro e raio. Pontos especiais oe c(os cantos retangulares inferior esquerdo e superior direito), p(um terceiro canto de losango, fornecido por uma fórmula matemática) e k(ajudando a desenhar a bissetriz perpendicular) recebem nomes no caminho para salvar bytes quando chamados novamente , como é o par especial de pontosl = {o,c}. O Mathematica tem o prazer de adicionar pontos diretamente, multiplicar as duas coordenadas pelo mesmo fator, obter seu produto escalar, etc., tudo isso simplificando o código.

Saída de amostra, com argumentos 125e 50:

MetaPost, 473 (com cores) 353 (sem cores)

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

Não colorido (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 NUNCA usei isso antes, e tenho certeza que o massacrei ...
Mas quando você executa isso neste site:

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

Ele usa a interseção dos círculos para desenhar o segundo eixo e, em seguida, usa a interseção do eixo e o retângulo para desenhar o losango final. Embora eu pudesse ter trapaceado e apenas traçado uma linha perpendicular ao primeiro eixo haha.

Para alterar as dimensões, basta alterar A e B.

Independentemente, você acaba com (para L = 170, H = 100):

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

we hsão as entradas. Experimente no Desmos!

Versão 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 versão requer que cada linha seja copiada e colada em cada linha separada no Desmos. O Meta ainda precisa decidir se este é um método de contagem válido, mas o método anterior é definitivamente bom.

ImageMagick versão 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 com "rhombus.sh 180 120"

Mais preciso (usando tela de 6400x6400 em vez de 800x800), 570 bytes

As interseções não são exatas; a diretiva "strokewidth" torna as linhas largas o suficiente para garantir que pelo menos um pixel inteiro seja misturado com apenas as cores das duas linhas que se cruzam, mas nos piores casos (25x200 e 200x25) os cruzamentos estão em um ângulo pequeno, de modo que a nuvem de pixels misturados tem vários pixels e, como selecionamos o primeiro e o último pixel misturado, há um pequeno erro. Usar uma tela 8x maior com a mesma largura de traço e reduzir o resultado reduz o erro para menos de um pixel, mas com uma penalidade 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 normais versus 6400x6400 precisos:

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

Função anônima, a saída é exibida na tela. Ligeiramente não-destruído, com comentários:

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
}

Exemplo de saída para (120,100):

LibreLogo , 270 bytes

A entrada do usuário é tomada como uma matriz: [width, height]ou [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:

Explicação:

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

Não colorido (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)

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

Uma função nomeada que recebe entrada como 2 números separados por vírgula. A saída é fornecida em uma janela separada que você pode ter que redimensionar para ver a saída completa. Aqui está uma amostra de saída colorida 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

(A captura de tela / explicação será publicada em breve) A cor do plano de fundo é preta, o retângulo é vermelho, os círculos e as linhas são brancos e o losango é amarelo.