Il triangolo di Reuleaux è la forma formata dall'intersezione di tre cerchi, con ciascun cerchio che passa attraverso i centri degli altri. Indipendentemente dalla rotazione, la larghezza di un triangolo di Reuleaux sarà sempre uguale al raggio dei cerchi:

_{Immagine: Wolfram MathWorld}

Scrivi un programma che accetta una larghezza rcome input e visualizza un triangolo Reuleaux di quella larghezza (in pixel).

È necessario visualizzare la forma in modo isolato, ovvero pieno, non tratteggiato e su uno sfondo pieno.

code-golf - Vince il programma più breve in byte.

JavaScript + HTML, 164 158 + 13 = 171 byte

w=+prompt(f=(x,y)=>x*x+y*y<w*w);C.width=C.height=w*2;for(y=-w;++y<w;)for(x=-w;++x<w;)f(x,y)&f(w-x,y)&f(w/2-x,y-w*.866)&&C.getContext`2d`.fillRect(x+w,y+w,1,1)

<canvas id=C>

Non so perché mi diverta a rispondere a queste sfide disegnando sfide con <canvas>così tanto ...

Love2D, 320 byte.

j=math.rad(60)i="increment"m=math s=m.sin C=m.cos g=love.graphics f="fill"S=g.stencil function love.draw()r=arg[2]c=function(x,y)return function()g.circle(f,x,y,r,r*4)end end X=r/2 Y=0 S(c(X,Y),i,1)S(c(X+C(j)*r,Y+s(j)*r),i,1,true)S(c(X-C(j)*r,Y+s(j)*r),i,1,true)g.setStencilTest("greater",2)g.rectangle(f,0,0,2*r,2*r)end

Probabilmente non è la soluzione ottimale, utilizza gli stencil di Love2D, imposta i 3 cerchi e compila il punto in cui si intersecano.

Chiama dalla riga di comando, ad esempio love tri.love 256

Esempio di output

Python 2 , 111 byte

from turtle import*
r=input()
ht()
begin_fill()
c=circle
c(r,60)
seth(120)
c(r,60)
seth(240)
c(r,60)
end_fill()

Mathematica 101 100 98 byte

Adottare un approccio diverso rispetto a @MichaelSeifert e probabilmente interpretarlo un po 'più letteralmente per quanto riguarda la clausola pixel:

Image@Boole@Table[And@@(({x,y}∈#~Disk~2)&/@{{0,c=√3},d={1,0},-d}),{x,-1,1,2/#},{y,c-2,c,2/#}]&

Esempio di utilizzo:

%@10

10 pixel

50 pixel

100 pixel

Salvataggio di un byte grazie a @MartinEnder (notazione infissa) e altri 2 byte definendo d.

PHP + SVG, 165 byte

<?$h=3/8*$w=2*$d=2*$r=$_GET[0];$q=$r+sqrt($r**2-($r/2)**2);echo"<svg width=$w height=$w><path d='M$r,$r A$r,$r 0 0 1 $d,$r A$r,$r 0 0 1 $h,$q A$r,$r 0 0 1 $r,$r'/>";

Esempio di output per l'ingresso 128

<svg width=512 height=512><path d='M128,128 A128,128 0 0 1 256,128 A128,128 0 0 1 192,238.85125168441 A128,128 0 0 1 128,128'/>

PostScript, 96 86 85 75 73 72 byte

dup(^@^^Z<^@Z<){sin mul exch dup}forall
0 1 2{newpath 369 arc clip}for fill

Prende l'input come valore nello stack. ^^e ^@rappresentano caratteri di controllo letterali.(^@^^Z<^@Z<)è la stringa di caratteri con punti di codice 0, 30, 90, 60, 0, 90 e 60, rispettivamente. Questi vengono quindi interpretati come angoli in gradi, perché ovviamente è a questo che servono i punti di codice.

Salvato 10 byte perché closepathnon è necessario (entrambi clipefill chiudono implicitamente il percorso).

Salvato 1 byte utilizzando repeat invece di definire una funzione.

10 byte salvati passando a un approccio completamente diverso.

Salvato 2 byte facendo trucchi con lo stack.

Salvato 1 byte utilizzando 0 1 2{}forinvece di 3{}repeat.

Mathematica, 134 131 byte

NB Questa soluzione non è più valida, poiché la domanda è stata successivamente modificata per richiedere la misurazione di r in pixel. Grazie a Martin Ender per avermi aiutato a radere qualche byte nei commenti.

r=Input[];RegionPlot[And@@((Abs[y+I x-#]^2<3r^2)&/@Table[Exp[2n I/3Pi]r,{n,3}]),{x,-1,1},{y,-1,1},Frame->False,BoundaryStyle->None]

Il valore di input deve essere ridimensionato tra 0 e 1 affinché questo codice funzioni. Si noti che è richiesto quasi un quarto di questo codice per visualizzare la forma "in isolamento", poiché non è l'impostazione predefinita di Mathematica.

BBC BASIC, 58 byte

I.r:L.r,r,r,r:F.i=0TO9S.PI/1.5PLOT177,r*COS(i),r*SIN(i)N.

Scarica l'interprete su http://www.bbcbasic.co.uk/bbcwin/download.html

Ungolfed

INPUTr                       :REM input a radius
LINEr,r,r,r                  :REM draw a line of length 0 from r,r to r,r to establish a cursor history away from the corner of the screen
FORi=0 TO 9 STEP PI/1.5      :REM in steps of 120 degrees (going round and round the three sides of an equilateral triangle)
  PLOT177,r*COS(i),r*SIN(i)  :REM move relative by r*COS(i),r*SIN(i) and draw a sector with arc between new and last graphics cursor positions,
NEXT                         :REM with the centre of the arc at the penultimate graphics cursor position.

TeX / TikZ, 128 121 112 byte

\input tikz\footline{}\tikz\draw[draw=none,fill=red](0,1)\foreach~ in{1,2,3}{[rotate=~*120]arc(0:60:\r pt)};\bye

Il codice si basa su questa risposta a TeX.se .

TeX è basato su vettori, quindi non su pixel. Il raggio è un float con un massimo di circa 15 prima che colpisca il bordo della pagina. Inoltre, non è stato creato per l'input da riga di comando, quindi è necessario eseguirlo come

pdftex  "\def\r{2} \input rt.tex"

dove viene salvato il codice sopra rt.tex

GLSL, 298 229 caratteri

precision lowp float;
uniform vec2 resolution;float r=100.;void main(){vec2 p=gl_FragCoord.xy-resolution.xy/2.;float h=sqrt(3.)/4.*r;gl_FragColor=vec4(length(p+vec2(r/2.,h))<r&&length(p+vec2(-r/2.,h))<r&&length(p-vec2(0.,h))<r);}

Provalo qui

indennità

• Il raggio può essere impostato cambiando rvariabile
• La larghezza del triangolo è espressa in pixel come richiesto (è necessario impostare lo zoom su 1x nella sandbox GLSL).

JavaScript (ES6) + HTML, 196 + 13 = 209 byte

Utilizza un approccio basato sul percorso anziché un approccio di riempimento pixel.

r=>{c.width=c.height=r*2
with(Math)with(c.getContext`2d`)scale(e=r*.578,e),beginPath(a=s=>s*PI/3),moveTo(2,1),[2,4,6].map(s=>arcTo(cos(i=a(s-1))+1,sin(i)+1,cos(j=a(s))+1,sin(j)+1,sqrt(3))),fill()}

<canvas id=c>

f=
r=>{c.width=c.height=r*2
with(Math)with(c.getContext`2d`)scale(e=r*.578,e),beginPath(a=s=>s*PI/3),moveTo(2,1),[2,4,6].map(s=>arcTo(cos(i=a(s-1))+1,sin(i)+1,cos(j=a(s))+1,sin(j)+1,sqrt(3))),fill()}

f(200)

//r=>{c.width=c.height=r*2
//with(Math)with(c.getContext`2d`)translate(r,r),scale(r,r),beginPath(a=s=>s*PI/3),S=sqrt(3),moveTo(1/S,0),[2,4,6].map(s=>arcTo(cos(i=a(s-1))/S,sin(i)/S,cos(j=a(s))/S,sin(j)/S,1)),fill()}

//r=>{c.width=c.height=r*2
//with(Math)with(c.getContext`2d`)translate(r,r),scale(r,r),beginPath(),P=PI/2,A=(s,_)=>(_?sin:cos)(s*PI/3)/sqrt(3),moveTo(A(0),0),[2,4,6].map(s=>arcTo(A(s-1),A(s-1,1),A(s),A(s,1),1)),fill()}

<canvas id=c>

Logo, 53 byte

to t :r filled 0[repeat 3[arc 60 :r fd :r rt 120]]end

usa il filledcomando per riempire la forma nel colore 0 (nero.) Il codice tra parentesi quadre esterne viene eseguito senza che venga tracciata alcuna linea, ma Logo tiene traccia dei movimenti della tartaruga e riempie la forma una volta che la parentesi è uscita.

Logo, 64 61 byte

to t :r repeat 3[pd arc 60 :r pu fd :r rt 120]fd 9 fill end

Penna giù, disegna un arco di 60 gradi con la tartaruga al centro, Penna su, sposta la penna all'inizio dell'arco, gira di 120 gradi.

Ripeti 3 volte, quindi spostati all'interno della forma e riempila.

Prova su http://turtleacademy.com/playground/en

Chiama come cs ht t 100(cancella schermo, nascondi tartaruga, tcon r = 100.)

MATL , 35 byte

9Bo&ZQ*3X^/G_G&:t!J*+8L&!-|G<A&e0YG

Questo produce un file chiamato image.png. Per l'input r, la dimensione dell'immagine è 2*r+1e la larghezza del triangolo è rcome richiesto.

Provalo su MATL Online! L'interprete online apre automaticamente il file creato e visualizza l'immagine con ridimensionamento arbitrario; cliccaci sopra per ottenere la versione di dimensioni reali.

In alternativa, ecco due esempi di output del compilatore offline in esecuzione su Matlab, con input 50e 100. L'ultima parte del codice 0YGè stata sostituita in IYGmodo che la figura venga visualizzata direttamente (con le dimensioni giuste) anziché essere scritta in un file.

Spiegazione

9B      % Push 9 in binary: [1 0 0 1] with logical values
o       % Convert to double
&ZQ     % Roots of polynomial with coefficients [1 0 0 1], as a 3×1 column vector
*       % Multiply by implicit input r
3X^/    % Divide by sqrt(3). This gives a 3×1 vector with the circle centers
G_G&:   % Push row vector [-r -r+1 ... r-1 r], with size 1×(2*r+1)
t!J*    % Duplicate, transpose, multiply by 1j
+       % Add with broadcast. This gives a (2*r+1)×(2*r+1) 2D-array of complex
        % numbers, which defines the pixel grid
8L      % Push [3 1 2]
&!      % Permute dimensions as indicated. This gives a 1×(2*r+1)×(2*r+1) 3D-array
-|      % Subtract with broadcast. Absolute value. This gives a 3×(2*r+1)×(2*r+1)
        % 3D-array with the distance from each circle center to each grid point
G<      % Less than r? Gives a 3×(2*r+1)×(2*r+1) 3D-array containing true or false
A       % All: this gives a 1×(2*r+1)×(2*r+1) array containing true for
        % columns of the original 3D-array that contained all true values
&e      % Squeeze the first singleton dimension to give a (2*r+1)×(2*r+1) 2D-array
0YG     % Save as image file with default file name

JavaScript (ES6) + SVG (HTML5), 28 + 102 = 130 byte

f=
n=>s.setAttribute('width',n)

<input type=number value=82 oninput=f(this.value)><br>
<svg id=s width=82 viewbox=0,0,82,82><path d=M0,71a82,82,0,0,0,82,0A82,82,0,0,0,41,0A82,82,0,0,0,0,71>

Il conteggio dei byte esclude il codice necessario per un comodo input dell'utente della dimensione desiderata.

MetaPost ( 242 226 byte)

outputtemplate:="%j-%c.ps";
prologues:=1
beginfig(1);
 len:=1cm;
 path p[];
 p[1]:=len * dir -30 {dir 90} .. len * dir  90;
 p[2]:=p[1] rotated 120;
 p[3]:=p[1] rotated 240;
 fill p[1] -- p[2] -- p[3] -- cycle;
endfig;
end.

Potrebbe essere possibile ridurlo un po ', sono nuovo di metapost.

k, 141 100 98 byte

s:*/2#;l:2*r:.:0:`
`0:(,"P1")," "/'$(,l,l),&/{(s'n+x)</:(s r)-s'y+n:r-!l}./:r*%(0 0;4 0;1 3)%4
\\

L'ingresso è preso da stdin, l'output è stderr(o stdindipende dall'interprete) nel pgmformato. Per esempio:

Spiegazione:

s:*/2#               /set s to a squaring function
r:.:0:`              /get user input, set to r
l:2*                 /width/height is 2 times r
r*%(0 0;4 0;1 3)%4   /the coordinates of circle centers
{ }./:               /for each coordinate pair (x, y) get a circle
                     /function to get a circle:
n:r-!l               /  set n to {r, r-1, ..., -(r-1)}
(s'n+x)</:(s r)-s'y+ /  use b^2<r^2-a^2 on all points to get a circle
                     /  where x and y shift the circle right and down
&/                   /get intersections of circles (fold binary and)
(,l,l),              /prepend height and width for PGM format
" "/'$               /convert to string, add spaces
(,"P1"),             /prepend PGM header
`0:                  /output to stderr
\\                   /exit

05AB1E , 66 byte

’)
¨€(ÿ,60)
lt(60’Ð’€š éà £Ø*
ht()
ï…_œã(ÿÿÿ)
„–_œã()
„ˆ 1:ht()’.e

Non è possibile utilizzare TIO, poiché apre una finestra e disegna lì il triangolo di Reuleaux.

Chiede input, quindi apre una finestra tartaruga Python che disegna il triangolo.

La risposta di Jonathan Allan mi ha dato l'ispirazione per farlo, anche se ho modificato un po 'il suo codice.

In sostanza, questa è una combinazione delle capacità di compressione di 05AB1E e della semplicità della grafica delle tartarughe di Python.

OpenSCAD , 91 byte

module t(r){intersection_for(t=[0,120,240]){rotate(t)translate([r/sqrt(3),0,0])circle(r);}}

Non sono sicuro di quanto sia kosher, dato che i pixel non sono in realtà un'unità ben definita in qualsiasi formato di griglia mesh che conosco. Al contrario, il modulo tdisegna un triangolo reuleaux di raggio dator in qualunque unità nativa sia in uso.

Esempio di output di anteprima per t(100):

SmileBASIC, 87 86 85 83 82 81 79 78 77 76 75 byte

INPUT R
C.5Y=R*.87C 1C.GPAINT.,0DEF C X
A=X*240GCIRCLE R*X,Y+2,R,A-60,A
END

Ungolfed:

INPUT RADIUS
CIRCLE 0.5
Y=RADIUS*(SQR(3)/2)
CIRCLE 1
CIRCLE 0
GPAINT 0,0
DEF CIRCLE X
 ANGLE=X*240
 GCIRCLE RADIUS*X,Y+2,RADIUS,ANGLE-60,ANGLE
END