Dato solo una riga e una bussola, iscrivi un rombo all'interno del rettangolo dato, condividendo due punti opposti.

Ingresso

L'input è le dimensioni del rettangolo. Nell'esempio mostrato, sarebbe 125, 50. Puoi prendere l'input nel modo più conveniente (come due numeri interi, elenco, stringhe, ecc.).

La dimensione più grande sarà di almeno 100, mentre la più piccola sarà di 25 minimo. Entrambi i cappellini a 200.

Produzione

L'output sarà un'immagine (visualizzata sullo schermo o salvata come file) che mostra

• Il rettangolo di input
• Tutte le linee / cerchi "funzionanti"
• Il rombo inscritto

in colori distinti. Nell'immagine sopra, Il rettangolo è nero, le linee di lavoro blu e il rombo arancione. Le linee devono essere tracciate nell'ordine mostrato nell'elenco (ad es. Rombo sovrascrive le linee di lavoro e il rettangolo).

L'immagine di output deve essere abbastanza grande da contenere tutto. Ad esempio, i cerchi mostrati non possono andare oltre i limiti.

Metodo

Il metodo utilizzato nell'immagine di esempio sopra è:

• Disegna un cerchio usando l'angolo inferiore sinistro come centro e quello superiore destro come punto sul perimetro, dando un raggio uguale alla diagonale del rettangolo.
• Fai lo stesso, ma scambiando i punti centrale e perimetrale.
• Traccia una linea tra le intersezioni dei due cerchi, dando una bisettrice perpendicolare alla diagonale del rettangolo.
• Usa le intersezioni della nuova linea e rettangolo per disegnare il rombo.

Questo funziona perché le diagonali interne di un rombo si dividono sempre perpendicolarmente. Non sto includendo una prova completa di questo qui, però.

Questo non è l' unico metodo per ottenere il tuo rombo, e puoi usarne un altro, dato che spieghi cosa stai facendo. Io credo che sia probabilmente il più facile, però.

Regole

Puoi disegnare solo cerchi e linee (o meglio, segmenti di linea). Un cerchio è definito con un punto centrale e un punto perimetrale. Una linea è definita da due punti qualsiasi. Le linee non devono avere una lunghezza specifica, ma devono almeno coprire i punti di definizione (notare l'immagine di esempio: la linea passa un po 'oltre le intersezioni del cerchio, ma non al bordo). Per i cerchi, il raggio dal centro al punto perimetrale scelto è considerato una linea di lavoro e deve essere mostrato.

Per rasterizzare le linee, puoi usare qualsiasi algoritmo riconosciuto (ad es. Quello di Bresenham), oppure fare affidamento su qualunque builtin potrebbe avere la tua lingua. Se il tuo output è basato su vettori, assicurati che sia mostrato con una risoluzione almeno grande quanto il rettangolo di input in pixel. Inoltre, disegnerai su una tela semplice, quindi sopprimere eventuali segni di griglia o output estraneo.

Non imbrogliare! Puoi solo determinare il posizionamento di punti / linee / cerchi usando ciò che hai stabilito finora. Se non riesci a spiegare come usare le linee / i cerchi di lavoro per mostrare che è un rombo, stai sbagliando.

Puoi utilizzare qualsiasi coppia di punti opposti che desideri e il rettangolo non deve essere disegnato allineato sull'asse, purché l'output sia corretto.

L'input sarà sempre un rettangolo non quadrato, quindi non preoccuparti di un involucro speciale.

Infine, questo è il codice golf standard, quindi vince la dimensione più bassa in byte.

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

L'input deve essere fornito nel 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 molta matematica e disegno ... Il rettangolo viene disegnato lateralmente se l'altezza è maggiore della larghezza, che credo sia consentita.

Mathematica, 157 148 158 byte

Grazie a Martin Ender per i commenti con la loro solita alta qualità! 9 byte salvati in questo caso.

Modificato una volta è stato chiarito che gli argomenti possono venire in entrambi gli ordini; 10 byte aggiunti per compensare.

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

Ancora una volta, è qui che brilla Mathematica: output grafico di alto livello che coinvolge il calcolo matematico. Lo stesso codice con spazi e nuove righe per la leggibilità umana:

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

Funzione senza nome di un singolo argomento che è una coppia ordinata di numeri positivi; il finale @@ Sort@# &converte quella coppia in due argomenti numerici in cui il primo numero è il più piccolo. Lineproduce un percorso poligonale da un punto all'altro, che si trasformerà in un poligono chiuso se il primo e l'ultimo punto sono uguali; Circleproduce un cerchio con centro e raggio dati. Ai punti speciali oe c(gli angoli rettangolari in basso a sinistra e in alto a destra), p(un terzo angolo del rombo, dato da una formula matematica), e k(aiutando a disegnare la bisettrice perpendicolare) vengono dati nomi lungo la strada per salvare byte quando richiamati , così come la speciale coppia di puntil = {o,c}. Mathematica è felice di aggiungere punti direttamente, moltiplicare entrambe le coordinate per lo stesso fattore, prendere il loro punto prodotto, ecc., Tutto ciò semplifica il codice.

Output di esempio, con argomenti 125e 50:

MetaPost, 473 (con colori) 353 (senza colori)

Colorato (473 byte):

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;

Non colorato (353 byte):

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;

Non l'ho mai usato prima, e sono sicuro di averlo macellato ...
Ma quando lo esegui su questo sito Web:

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

Usa l'intersezione dei cerchi per disegnare il secondo asse, quindi usa l'intersezione dell'asse e del rettangolo per disegnare il rombo finale. Anche se avrei potuto imbrogliare e solo tracciare una linea perpendicolare al primo asse haha.

Per modificare le dimensioni, basta modificare A e B.

Indipendentemente da ciò, si finisce con (per L = 170, H = 100):

Desmos, 375 (o 163) byte

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 hsono gli input. Provalo su Desmos!

Versione alternativa a 163 byte:

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

Questa versione richiede che ogni riga sia copiata e incollata in ogni riga separata in Desmos. Meta deve ancora decidere se si tratta di un metodo di conteggio valido, ma il metodo precedente va decisamente bene.

ImageMagick Versione 7.0.3 + bash + sed, 496 byte

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:

Risultato con "rhombus.sh 180 120"

Più preciso (utilizzando canvas 6400x6400 anziché 800x800), 570 byte

Le intersezioni non sono esatte; la direttiva "strokewidth" rende le linee abbastanza larghe da garantire che almeno un intero pixel si mescoli con solo i colori delle due linee che si intersecano, ma nei casi peggiori (25x200 e 200x25) gli incroci sono ad angolo ridotto, quindi la nuvola di pixel misti è lungo diversi pixel e poiché selezioniamo il primo e l'ultimo pixel misto, si verifica un leggero errore. L'uso di una tela 8 volte più grande con la stessa larghezza di tratto e quindi il ridimensionamento del risultato riduce l'errore a meno di un pixel, ma a una penalità di circa 64 volte.

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:

Risultati di 800x800 normali rispetto a 6400x6400 precisi:

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 byte

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

Funzione anonima, l'output viene visualizzato sullo schermo. Leggermente ungolfed, con commenti:

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
}

Esempio di output per (120.100):

LibreLogo , 270 byte

L'input dell'utente è preso come un array: [width, height]o [height, width].

Codice:

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

Risultato:

Spiegazione:

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 byte

Non colorato (433 byte):

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)

Colorato (515 byte):

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 funzione con nome che accetta input come 2 numeri separati da virgola. L'output viene fornito in una finestra separata che potrebbe essere necessario ridimensionare per visualizzare l'output completo. Ecco un esempio di output colorato per V(180,130):

SmileBASIC, 280 byte

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

(Schermata / spiegazione saranno pubblicate presto) Il colore di sfondo è nero, il rettangolo è rosso, i cerchi e le linee sono bianchi e il rombo è giallo.