Donner seulement une règle et une boussole, inscrire un losange à l’intérieur du rectangle donné, en partageant deux points opposés.

Contribution

L'entrée correspond aux dimensions du rectangle. Dans l'exemple présenté, ce serait 125, 50. Vous pouvez entrer les données de la manière qui vous convient le mieux (deux entiers, liste, chaînes, etc.).

La plus grande dimension sera de 100 minimum, tandis que la plus petite sera de 25 minimum. Les deux plafonnent à 200.

Sortie

La sortie sera une image (affichée à l’écran ou enregistrée dans un fichier) montrant

• Le rectangle d'entrée
• Toutes les lignes / cercles "de travail"
• Le losange inscrit

dans des couleurs distinctes. Dans l'image ci-dessus, le rectangle est noir, les lignes de travail bleues et l'orange losange. Les lignes doivent être dessinées dans l'ordre indiqué dans la liste (par exemple, losange écrase les lignes de travail et le rectangle).

L'image de sortie doit être suffisamment grande pour tout contenir. Par exemple, les cercles montrés ne peuvent pas sortir des limites.

Méthode

La méthode utilisée dans l'exemple d'image ci-dessus est la suivante:

• Tracez un cercle en utilisant le coin inférieur gauche comme centre et le coin supérieur droit comme point du périmètre, en donnant un rayon égal à la diagonale du rectangle.
• Faites de même, mais permutez les points centraux et périphériques.
• Tracez une ligne entre les intersections des deux cercles, en donnant une médiatrice perpendiculaire à la diagonale du rectangle.
• Utilisez les intersections de la nouvelle ligne et du rectangle pour dessiner le losange.

Cela fonctionne parce que les diagonales intérieures d'un losange se divisent toujours perpendiculairement. Je n'inclus pas une preuve complète de cela ici, cependant.

Ce n'est pas la seule méthode pour obtenir votre losange et vous pouvez en utiliser une autre, étant donné que vous expliquez ce que vous faites. Je crois que c'est probablement le plus facile, cependant.

Règles

Vous pouvez uniquement dessiner des cercles et des lignes (ou plutôt des segments de ligne). Un cercle est défini avec un point central et un point de périmètre. Une ligne est définie par deux points quelconques. Les lignes ne doivent pas nécessairement avoir une longueur spécifiée, mais elles doivent au moins couvrir les points qui les définissent (remarquez l'exemple d'image: la ligne dépasse un peu les intersections des cercles, mais pas jusqu'au bord). Pour les cercles, le rayon du centre au point de périmètre choisi est considéré comme une ligne de travail et doit être indiqué.

Pour pixelliser les lignes, vous pouvez utiliser n'importe quel algorithme reconnu (par exemple, celui de Bresenham) ou vous appuyer sur les éléments intégrés de votre langue. Si votre sortie est à base de vecteurs, assurez-vous qu’elle affiche une résolution au moins égale à celle du rectangle en entrée en pixels. De plus, vous allez dessiner sur un canevas ordinaire. Veuillez donc supprimer les marques de grille et les sorties superflues.

Pas de tricherie! Vous pouvez uniquement déterminer l'emplacement des points / lignes / cercles en utilisant ce que vous avez établi jusqu'à présent. Si vous ne pouvez pas expliquer comment utiliser vos lignes / cercles de travail pour montrer que c'est un losange, vous le faites mal.

Vous pouvez utiliser la paire de points opposés de votre choix et le rectangle n'a pas besoin d'être tracé aligné sur l'axe, tant que la sortie est correcte.

L'entrée sera toujours un rectangle non carré, alors ne vous inquiétez pas de la casse spéciale.

Enfin, il s’agit du golf standard, ce qui fait que la taille la plus basse en octets est gagnante.

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

L'entrée devrait être donnée dans le format [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>

Juste beaucoup de maths et de dessins ... Le rectangle est tracé latéralement si la hauteur est supérieure à la largeur, ce qui est permis, à mon avis.

Mathematica, 157 148 158 octets

Merci à Martin Ender pour ses commentaires avec sa qualité habituelle! 9 octets enregistrés dans ce cas.

Édité une fois clarifié le fait que les arguments peuvent venir dans l’un ou l’autre des ordres; 10 octets ajoutés pour compenser.

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

Encore une fois, c’est là que brille Mathematica: une sortie graphique de haut niveau faisant appel à un calcul mathématique. Le même code avec des espaces et des nouvelles lignes pour la lisibilité humaine:

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

Fonction non nommée d'un seul argument qui est une paire ordonnée de nombres positifs; la dernière @@ Sort@# &convertit cette paire en deux arguments numériques où le premier nombre est le plus petit. Lineproduit un chemin polygonal de point en point, qui se transformera en un polygone fermé si les premier et dernier points sont identiques; Circleproduit un cercle de centre et de rayon donnés. Les points spéciaux oet c(les coins rectangulaires en bas à gauche et en haut à droite), p(un troisième coin en losange, donné par une formule mathématique), et k(aidant à dessiner la médiatrice) reçoivent des noms le long du chemin pour sauvegarder des octets lors de leur rappel. , comme la paire spéciale de pointsl = {o,c}. Mathematica se contente d'ajouter des points directement, de multiplier les deux coordonnées par le même facteur, de prendre leur produit scalaire, etc., ce qui simplifie le code.

Exemple de sortie, avec arguments 125et 50:

MetaPost, 473 (avec couleur) 353 (sans couleur)

Couleur (473 octets):

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 coloré (353 octets):

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;

Jamais JAMAIS utilisé cela auparavant, et je suis sûr que je l'ai massacré ...
Mais quand vous utilisez ça sur ce site:

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

Il utilise l'intersection des cercles pour dessiner le deuxième axe, puis utilise l'intersection de l'axe et du rectangle pour dessiner le losange final. Bien que j'aurais pu tricher et simplement tracer une ligne perpendiculaire au premier axe haha.

Pour changer les dimensions, il suffit de modifier A et B.

Quoi qu'il en soit, vous vous retrouvez avec (pour L = 170, H = 100):

Desmos, 375 (ou 163) octets

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)

wet hsont les entrées. Essayez sur Desmos!

Version alternative de 163 octets:

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

Cette version nécessite que chaque ligne soit copiée et collée dans chaque ligne distincte dans Desmos. Meta doit encore décider s’il s’agit d’une méthode de comptage valide, mais l’ancienne est tout à fait acceptable.

ImageMagick version 7.0.3 + bash + sed, 496 octets

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:

Résultat avec "rhombus.sh 180 120"

Plus précis (utilisation de la toile 6400x6400 au lieu de 800x800), 570 octets

Les intersections ne sont pas exactes. la directive "strokewidth" élargit les lignes de manière à ce qu’au moins un pixel entier soit mélangé aux couleurs des deux lignes qui se coupent, mais dans le pire des cas (25x200 et 200x25), les croisements sont à petit angle de sorte que le nuage nombre de pixels mélangés est long de plusieurs pixels, et puisque nous sélectionnons le premier et le dernier pixel mélangé, il y a une légère erreur. Utiliser un canevas 8 fois plus grand avec la même largeur de trait et ensuite réduire le résultat réduit l'erreur à moins d'un pixel, mais à une pénalité de temps d'environ 64 fois.

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:

Résultats de 800x800 normaux par rapport à 6400x6400 précis:

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 octets

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

Fonction anonyme, la sortie est affichée à l'écran. Légèrement non-golfé, avec commentaires:

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
}

Exemple de sortie pour (120,100):

LibreLogo , 270 octets

L'entrée utilisateur est considérée comme un tableau: [width, height]ou [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

Résultat:

Explication:

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 octets

Non coloré (433 octets):

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)

Couleur (515 octets):

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)

Une fonction nommée qui prend en entrée 2 nombres séparés par des virgules. La sortie est donnée dans une fenêtre séparée que vous devrez peut-être redimensionner pour voir la sortie complète. Voici un exemple de sortie colorée pour V(180,130):

SmileBASIC, 280 octets

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 capture d'écran / l'explication sera bientôt disponible) La couleur de fond est noire, le rectangle est rouge, les cercles et les lignes sont blancs et le losange est jaune.