Le drapeau du Népal ( Wikipedia , Numberphile ) est très différent des autres. Il contient également des instructions de dessin spécifiques (incluses dans l'article Wikipedia). Je veux que vous fassiez un programme qui dessinera le drapeau du Népal.

L'utilisateur entre la hauteur demandée du drapeau (de 100 à 10000 pixels) et le programme sort le drapeau du Népal. Vous pouvez choisir n'importe quelle façon de dessiner le drapeau: tout, de l'art ASCII à OpenGL.

Il s'agit d'un concours de popularité, donc le gagnant sera la réponse la plus votée le 1er février, alors ne vous inquiétez pas de la longueur du code, mais rappelez-vous qu'un code plus court peut obtenir plus de votes positifs.

Il n'y a qu'une seule exigence: vous n'êtes pas autorisé à utiliser les ressources Web.

S'amuser :)

SVG, 1375, 1262, 1036, 999, 943, 939

<svg>
<defs>
<style>.w{fill:white}</style>
<g id="f"><path d="M1,1L1,20L18,20L6,10L17,10z" style="stroke:#003893;fill:#dc143c"/></g>
<g id="m"><polygon points="1,0 -.5,.86 -.5,-.86"/></g>
<g id="b"><polygon points="1,0 -.5,.86 -.5,-.86"/><polygon points="1,0 -.5,.86 -.5,-.86"transform="rotate(32)"/></g>
<g id="t"><use xlink:href="#b"/><use xlink:href="#b"transform="rotate(60)"/></g>
<g id="s">
<use xlink:href="#m"/>
<use xlink:href="#m"transform="rotate(20)"/>
<use xlink:href="#m"transform="rotate(45)"/>
<use xlink:href="#m"transform="rotate(70)"/>
<use xlink:href="#m"transform="rotate(90)"/>
</g>
</defs>
<g transform="scale(.7)">
<use xlink:href="#f" x="5" y="6"transform="scale(19,23)"/>
<use xlink:href="#t" x="2.8" y="7"class="w"transform="scale(70)"/>
<path d="M157,292 A 40,35 0 1 0 237,292 43,45 0 1 1 157,292z"class="w"/>
<use xlink:href="#s" x="5.6" y="8.9"class="w"transform="scale(35)"/>
</g>
</svg>

SVG n'a pas vraiment d'entrée utilisateur, AFAIK, vous pouvez donc changer l'échelle en modifiant cette ligne:

<g transform="scale(.7)">

JavaScript, 569 537 495 442 caractères (ASCII)

h="";M=Math;Z=M.max;Y=M.min;function d(a,b,r,s,t){n=M.sqrt(a*a+e*e);return n-(r+M.abs((M.atan2(a,e
)/M.PI*b+t)%1-0.5)*s*n)}f=parseInt(prompt(),10);for(g=0;g<f;g++){for(k=0;k<2*f;k++)e=k/(0.5*f)-0.8
,q=g/(0.25*f),u=q-1.08,v=q-1.29,z=e*e+u*u-0.3364,E=Z(-e-0.8,Y(Z(0.62*e+0.8-q,-2.06+q),Z(1*e+0.8+
0.85-q,-3.87+q))),p=0>Y(d(q-2.91,6,0.38,0.7,10),Y(Z(e*e+v*v-0.3025,-z),Z(d(q-1.54,8,0.25,0.6,10.5)
,q-1.7)))?" ":-0.13>E?";":0>=E?"8":"",h+=p;h+="\n"}h 

Pour exécuter: copier-coller sur la console du navigateur (par exemple: outils de développement Chrome ou Firebug)

Résultat :

8 
8888 
8888888 
8888;88888 
8888;;;;88888 
8888;;;;;;;888888 
8888;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;888888 
8888;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;; ;  ;  ; ;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;; ;;;;;               ;;;;; ;;;;;;;;;;;;;;;;88888 
8888;;;  ;;;;;;           ;;;;;;  ;;;;;;;;;;;;;;;;;;;888888 
8888;;;;   ;;;             ;;;   ;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;                       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;                   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;8888888888888888888888888888888888888888888888888888888 
8888;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;888 
8888;;;;;;;;;   ;;;   ;;;   ;;;;;;;;;;888 
8888;;;;;;;;;;             ;;;;;;;;;;;;;888 
8888;;;;                         ;;;;;;;;;888 
8888;;;;;;                     ;;;;;;;;;;;;;888 
8888;;;;;;;                   ;;;;;;;;;;;;;;;;888 
8888;;;                           ;;;;;;;;;;;;;;888 
8888;;;;;                       ;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;                   ;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;                       ;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;; ;;;;;             ;;;;; ;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;  ;;;;   ;;;;  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888888888888888888888888888888888888888888888888888888888888888888888888 
888888888888888888888888888888888888888888888888888888888888888888888888888 

EDIT: hauteur ajoutée comme entrée utilisateur comme suggéré par ST3. cela fonctionne mieux avec de grandes valeurs (par exemple: 120)

Mathematica

La Constitution intérimaire du Népal - annexe 1 (par rapport à l'article 6), p. 260 et 262, fournit 25 instructions détaillées sur la façon de construire le drapeau. (voir http://www.ccd.org.np/resources/interim.pdf ). Les chiffres dans les commentaires renvoient aux instructions correspondantes de la constitution.

Nous aurons besoin de fonctions pour dessiner des triangles équilatéraux et déterminer la distance d'un point à une ligne:

ClearAll[triangle]
triangle[a_?NumericQ,b_?NumericQ,c_?NumericQ,labeled_:True]:=
Block[{x,y,pt,sqr},sqr=#.#&;
pt[a1_,b1_,c1_]:=Reduce[sqr[{x,y}]==b1^2&&sqr[{x,y}-{a1,0}]==c1^2&&y>0,{x,y}];
{(
(*Polygon[{{0,0},{a,0},{x,y}}]*)
Polygon[{{-a/2(*0*),0},{a/2,0},{x-a/2,y}}]),
If[labeled,
{Text[Style[Framed[a,Background->LightYellow],11],{a/2,0}],
Text[Style[Framed[b,Background->LightYellow],11],{x/2,y/2}],
Text[Style[Framed[c,Background->LightYellow],11],{(a+x)/2,y/2}]},{}]}/.ToRules[pt[a,b,c]]]

(*distance from point to a line *)
dist[line_,{x0_,y0_}]:=(Abs[a x0+b y0+c]/.{x0-> m[[1]],y0-> m[[2]]})/Sqrt[a^2+b^2]; (* used below *)

Le code restant, avec des nombres se référant aux instructions. De loin, la partie la plus difficile est de faire les rayons de la lune et du soleil. GeometricalTransformationest pratique pour faire des traductions et des rotations.

    (*shape inside flag*)
(*1*)
w=100;a={0,0};b={w,0};
lAB=Line[{a,b}];
tA=Text["A",Offset[{-10,-20},a]];
tB=Text["B",Offset[{20,-20},b]];

(*2*)
c={0,w 4/3};d={0,w};
lAC=Line[{a,c}];
tC=Text["C",Offset[{-10,20},c]];
lAD=Line[{a,d}];
tD=Text["D",Offset[{-10,0},d]];
lBD=Line[{b,d}];

(*3*)
e=Solve[(x-w)^2+y^2==(w)^2&&y==w-x,{x,y}][[1,All,2]];
tE=Text["E",Offset[{15,0},e]];

(*4*)
f={0,e[[2]]};tF=Text["F",Offset[{-10,0},f]];
g={w,e[[2]]};tG=Text["G",Offset[{15,0},g]];
lFG=Line[{f,g}];
poly={a,b,e,g,c};

(*5*)lCG= Line[{c,g}];

(*moon*)
(*6*)
lineCG=N[((f[[2]]-c[[2]])/w)x+c[[2]](*100*)];
h={w/4,0};tH=Text["H",Offset[{0,-20},h]];
i={h[[1]],lineCG/.x->h[[1]]};tI=Text["I",Offset[{10,0},i]];
lHI={Dashed, LightGray,Line[{h,i}]};

(*7*)
j={0,f[[2]]+(c[[2]]-f[[2]])/2};tJ=Text["J",Offset[{-10,10},j]];
lineJG=N[((f[[2]]-j[[2]])/g[[1]])x+j[[2]]];
k={Solve[lineCG==j[[2]],x][[1,1,2]],j[[2]]};tK=Text["K",Offset[{10,10},k]];
(*k={Solve[lineCG\[Equal]c[[2]],x][[1,1,2]],j[[2]]};tK=Text["K",Offset[{10,10},k]];*)
lJK={Dashed, LightGray,Line[{j,k}]};

(*8*)l={i[[1]],j[[2]]};tL=Text["L",Offset[{0,10},l]];
(*9*)lJG={LightGray,Dashed,Line[{j,g}]};
(*10*)m={h[[1]],(lineJG/.x-> h[[1]])};tM=Text["M",Offset[{0,10},m]];
(*11*)distMfromBD=dist[{1,1,-w(*100*)},m];
 n={i[[1]],m[[2]]-distMfromBD};tN=Text["N",Offset[{0,0},n]];
(*ln=Abs[l[[2]]-n[[2]]];*)
(*12*)o={0,m[[2]]};tO=Text["O",Offset[{-10,0},o]];
lM={Dashed,LightGray,Line[{o,{g[[1]],o[[2]]}}]};

(*13*)
radiusLN=l[[2]]-n[[2]];
p={m[[1]]-radiusLN,m[[2]]};tP=Text["P",Offset[{0,10},p]];
q={m[[1]]+radiusLN,m[[2]]};tQ=Text["Q",Offset[{0,10},q]];
moonUpperEdge={White,Circle[l,radiusLN,{Pi,2 Pi}]};
moonLowerEdge={White,Circle[m,radiusMQ,{Pi,2 Pi}]};


(*14*)radiusMQ=q[[1]]-m[[1]];


(*15*)radiusNM=m[[2]]-n[[2]];
arc={Yellow,Circle[n,radiusNM,{Pi/7,6 Pi/7}]};
{r,s}=Solve[(x-l[[1]])^2+(y-l[[2]])^2==(radiusLN)^2 &&(x-n[[1]])^2+(y-n[[2]])^2==(radiusNM)^2,{x,y}][[All,All,2]];
tR=Text["R",Offset[{0,0},r]];
tS=Text["S",Offset[{0,0},s]];
t={h[[1]],r[[2]]};
tT={Black,Text["T",Offset[{0,0},t]]};


(*16*)radiusTS=Abs[t[[1]]-s[[1]]];
(*17*)radiusTM=Abs[t[[2]]-m[[2]]];

(*18 triangles*)
t2=Table[GeometricTransformation[GeometricTransformation[triangle[4,4,4,False][[1]],RotationTransform[k Pi/8]],{TranslationTransform[t]}],{k,-4,3}];
midRadius=(Abs[radiusTM+radiusTS]/2-2);
pos=1;table2=GeometricTransformation[t2[[pos++]],{TranslationTransform[#]}]&/@Table[midRadius {Cos@t,Sin[t]},{t,Pi/16,15 Pi/16,\[Pi]/8}];

(*19 sun*)u={0,f[[2]]/2};tU=Text["U",Offset[{-10,0},u]];
lineBD=N[(d[[2]]/w)x+d[[2]]];
v={-Solve[lineBD==u[[2]],x][[1,1,2]],u[[2]]};tV=Text["V",Offset[{10,0},v]];
lUV={LightGray,Dashed,Line[{u,v}]};

(*20*)w={h[[1]],u[[2]]};tW={Black,Text["W",Offset[{0,0},w]]};
(*21*)
(*22*)

t3=Table[GeometricTransformation[GeometricTransformation[triangle[9,9,9,False][[1]],RotationTransform[k Pi/6]],{TranslationTransform[w]}],{k,-3,9}];
midRadius3=(Abs[radiusTM+radiusTS]/2+2.5);
pos=1;
table3=GeometricTransformation[t3[[pos++]],{TranslationTransform[#]}]&/@Table[midRadius3 {Cos@t,Sin[t]},{t,0,2 Pi,2\[Pi]/12}];



Show[
Graphics[{Gray,
(*1*)lAB,tA,tB,
(*2*)lAC,tC,lAD,tD,lBD,
(*3*)tE,
(*4*)tF,lFG,tG,{Red,Opacity[.4],Polygon[poly]},
(*5*)lCG,
(*6*)tH,lCG,tI,lHI,
(*7*)tJ,lJK,tK,
(*8*)tL,
(*9*)lJG,
(*10*)tM,
(*11*)tN,
(*12*)lM,tO,
(*13*)moonUpperEdge,tP,tQ,
(*14*)moonLowerEdge,
(*15*)arc,tR,tS,tT,
(*16*){White,Dashed,Circle[t,radiusTS(*,{0, Pi}*)]},

(*17*){White,Opacity[.5],Disk[t,radiusTM,{0, 2 Pi}]},
(*18 triangles*){White,(*EdgeForm[Black],*)table2},
(*19 sun*)tU,tV,lUV,

(*20*)tW,{Opacity[.5],White,Disk[w,Abs[m[[2]]-n[[2]]]]},
(*21*)Circle[w,Abs[l[[2]]-n[[2]]]],
(*22*){Black(*White*),EdgeForm[Black],triangle[4,4,4,False](*table3*)},
{White,(*EdgeForm[Black],*)table3},

(*23*)
{Darker@Blue,Thickness[.03],Line[{a,b,e,g,c,a}]}

},
Ticks-> None(*{{0,100},{0,80,120,130}}*), BaseStyle-> 16,AspectRatio-> 1.3,Axes-> True],

(*cresent moon*)
RegionPlot[{(x-25)^2+(y-94.19)^2<21.4^2&&(x-25)^2+(y-102.02)^2>21.4^2},{x,0,100},{y,30,130},PlotStyle->{Red,White}]]

Le drapeau suivant, issu du code ci-dessus, est fabriqué conformément aux instructions de la constitution.

Les couleurs sont modifiées pour faciliter la visualisation des lignes de construction. Les lettres se réfèrent à des points et des lignes dans les instructions.

Soit dit en passant, les drapeaux du monde peuvent être appelés directement dans Mathematica. Par exemple:

Graphics[CountryData["Nepal", "Flag"][[1]], ImageSize->{Automatic,200}]

Python

import turtle, sys
from math import sqrt, sin, cos, pi

height = int(sys.argv[1])
width = height / 4 * 3
turtle.screensize(width, height)
t = turtle.Turtle()

# the layout
t.pencolor("#0044cc")
t.fillcolor("#cc2244")
t.pensize(width / 25)
t.pendown()
t.fill(True)
t.forward(width)
t.left(135)
t.forward(width)
t.right(135)
t.forward(width / sqrt(2))
t.right(90)
t.goto(0, height)
t.forward(height)
t.fill(False)
t.penup()

# the bottom star
t.fillcolor("#ffffff")
t.pencolor("#ffffff")
t.pensize(1)
radius = width / 5
x = width / 4
y = height / 4
t.goto(x + radius, y)
t.pendown()
t.fill(True)
for i in range(24):
    t.goto(x + radius * (5 + (-1) ** i) / 6 * cos(i * pi / 12), y + radius * (5 + (-1) ** i) / 6 * sin(i * pi / 12))
t.fill(False)
t.penup()

# the top star
radius = width / 9
x = width / 4
y = height * 2 / 3
t.goto(x + radius, y)
t.pendown()
t.fill(True)
for i in range(28):
    t.goto(x + radius * (6 + (-1) ** i) / 7 * cos(i * pi / 14), y + radius * (6 + (-1) ** i) / 7 * sin(i * pi / 14))
t.fill(False)
t.penup()

# the moon
radius = width / 5
x = width / 4
y = height / sqrt(2)
t.goto(x + radius, y)
t.pendown()
t.fill(True)
for i in range(30):
    t.goto(x + radius * cos(i * pi / 30), y - radius * sin(i * pi / 30))
for i in range(30):
    t.goto(x - radius * cos(i * pi / 30), y - radius / 2 * sin(i * pi / 30))
t.fill(False)
t.penup()
t.hideturtle()

raw_input("press enter")

Utilise les tortues Tk de python, exemple python nepal.py 150et python nepal.py 200respectivement:

R (ne parlons pas de longueur )

nepaliflag = function(imaginary = FALSE, color = c("red", "white", "blue")){
    #Draws flag of Nepal with default colors red for inner area, white for Sun and Moon,
    #and blue for outer border
    #Based on instructions from http://www.servat.unibe.ch/icl/np01000_.html
    #Coded by Darshan Baral, with help from Urja Acharya
    #Fork at https://github.com/darshanbaral/R_codes/blob/master/nepali_flag.r
    graphics.off()
    windows(width = 6, height = 8)
    par(mar = c(3, 0.5, 2, 0.5))
    fs = 1 #Arbitrary scale unit for flag
    plot(fs, fs, xlim = c(0, fs), ylim = c(0, 1.5*fs),
         type = "p", pch = NA, axes = FALSE,
         xlab = "", ylab = "",
         asp = 1)

    title(main = "Flag of Nepal")

    #Perpendicular distance from a to bc
    dist_point_line <- function(a, b, c) {
        v1 <- b - c
        v2 <- a - b
        m <- cbind(v1,v2)
        return(abs(det(m))/sqrt(sum(v1*v1)))
    }

    #Distance from a to b
    dist_2_points <- function(a, b) {
        return(sqrt((a[1]-b[1])^2+(a[2]-b[2])^2))
    }

    #Intersection between lines ab and mn
    lines_intersection = function(a,b,m,n){
        A1 = b[2] - a[2]
        B1 = a[1] - b[1]
        C1 = a[1]*b[2] - a[2]*b[1]

        A2 = n[2] - m[2]
        B2 = m[1] - n[1]
        C2 = m[1]*n[2] - m[2]*n[1]      

        Delta = A1*B2 - A2*B1
        if(Delta == 0){
            return("Lines are parallel")
        } else {
            x = (B2*C1 - B1*C2)/Delta
            y = (A1*C2 - A2*C1)/Delta
            return(c(x,y))
        }
    }

    A = c(0,0)
    B = c(fs, 0)
    C = c(0, 4*B[1]/3)
    D = c(0, B[1])
    E = c( (B[1] - B[1]/sqrt(2)), B[1]/sqrt(2) )
    tE = c(E[1], A[2]) #Projecting E onto x-axis
    F = c(0, E[2] )
    G = c(B[1], E[2] )

    F_C = dist_2_points(F,C) #Distance between points F and C
    F_G = dist_2_points(F,G)
    B_tE = dist_2_points(B,tE)
    E_tE = dist_2_points(E,tE)

    upper_angle = pi/2 - atan(F_C/F_G) #Corner angle of upper triangle
    lower_angle = pi/2 - atan(E_tE/B_tE) #Corner angle of bottom triangle

    H = c(B[1]/4,0)
    I = c(H[1], G[2]+(G[1]-H[1])*(C[2]-F[2])/G[1] )
    J = c(0, 0.5*(C[2] + F[2]) )
    K = c( (C[2]-J[2])*G[1]/(C[2]-F[2]), J[2])
    L = c(H[1],J[2])
    M = lines_intersection(J, G, H, I)
    M_BD = dist_point_line(M, B, D) #Perpendicular distance between point M and line BD
    N = c(H[1], M[2]-M_BD)
    O = c(0, M[2])
    L_N = dist_2_points(L, N)
    L_M = dist_2_points(L, M)
    P = c(M[1] - sqrt(L_N^2 - L_M^2), M[2])
    Q = c(M[1] + sqrt(L_N^2 - L_M^2), M[2])
    L_Q = dist_2_points(L, Q)
    M_Q = dist_2_points(M, Q)
    M_N = dist_2_points(M, N)

    #Points of intersection of two circles
    temp_1 = (L_Q^2 - M_N^2 + M_N^2 ) / (2 * M_N)
    temp_2 = sqrt(L_Q^2 - temp_1^2)

    R = c(N[1]-temp_2, L[2]-temp_1)
    S = c(N[1]+temp_2, L[2]-temp_1)
    T = c(H[1], R[2])
    T_N = dist_2_points(T, N)
    T_S = dist_2_points(T, S)
    T_M = dist_2_points(T, M)

    U = c(A[1], 0.5 * (A[2]+F[2]))
    temp_U = c(H[1],U[2])
    V = lines_intersection(U, temp_U, B, E)
    W = c(H[1], U[2])

    #Draw inner polygon in red
    area = rbind(G, C, A, B, E)    
    polygon(area, col = color[1], border = NA)

    #Draw Moon arcs
    symbols (x = L[1], y = L[2], circles=c(L_N), add =TRUE, inches=FALSE, fg = NA, bg = color[2])
    symbols (x = M[1], y = M[2], circles=c(M_Q), add =TRUE, inches=FALSE, fg = NA, bg = color[2])
    symbols (x = L[1], y = L[2], circles=c(L_N), add =TRUE, inches=FALSE, fg = NA, bg = color[1])
    symbols (x = T[1], y = T[2], circles=c(T_M), add =TRUE, inches=FALSE, bg = color[2], fg = NA)

    #Draw Sun circles
    symbols (x = W[1], y = W[2], circles=c(M_N), add =TRUE, fg = NA, inches=FALSE, bg = NA)

    #Obtain points of triangles of the Sun
    sun_points = c(0,0)
    theta = 0
    for (i in 1:24){
        if (i %% 2 != 0){
            sun_points = rbind( sun_points, c( W[1]+L_N*cos(theta), W[2]+L_N*sin(theta)) )
        } else {
            sun_points = rbind( sun_points, c( W[1]+M_N*cos(theta), W[2]+M_N*sin(theta)) )
        }
        theta = theta + 2*pi/24
    }
    sun_points = sun_points[2:25,]

    #Obtain points of triangles of the Moon
    moon_points = c(0,0)
    theta = 0 - pi/8
    for (i in 1:20){
        if (i %% 2 != 0){
            moon_points = rbind( moon_points, c( T[1]+T_M*cos(theta), T[2]+T_M*sin(theta)) )
        } else {
            moon_points = rbind( moon_points, c( T[1]+T_S*cos(theta), T[2]+T_S*sin(theta)) )
        }
        theta = theta + pi/16
    }
    moon_points = moon_points[2:21,]

    par(xpd = TRUE)

    Ax = c(A[1] - T_N, A[2]) #Shift A to the left with a distance of TN
    Cx = c(C[1] - T_N, C[2])
    Ay = c(A[1], A[2] - T_N)
    By = c(B[1], B[2] - T_N) #Shift B to the bottom with a distance of TN

    Gx = c(G[1] + T_N, G[2])
    Gy = c(G[1], G[2] - T_N)
    Ey = c(E[1], E[2] - T_N)

    Kx = c(K[1] + T_N/cos(upper_angle), K[2]) #a point on parallel line TN away from upper slanting line
    Ix = c(I[1] + T_N/cos(upper_angle), I[2]) #another point on parallel line TN away from upper slanting line

    Bb = c(B[1] + T_N/cos(lower_angle), B[2]) #a point on parallel line TN away from lower slanting line
    Ee = c(E[1] + T_N/cos(lower_angle), E[2]) #another point on parallel line TN away from lower slanting line

    #Point of intersection for offsetting borders in corners
    Ap = lines_intersection(Ax, Cx, Ay, By) 
    Cp = lines_intersection(Kx, Ix, Ax, Cx)
    Gp = lines_intersection(Ix, Kx, Ey, Gy)
    Ep = lines_intersection(Bb, Ee, Ey, Gy)
    Bp = lines_intersection(Ay, By, Ee, Bb)

    #Draw triangles for Sun and Moon
    polygon(sun_points, col = color[2], border = NA)    
    polygon(moon_points, col = color[2], border = NA)   

    #Draw outer border
    borders = rbind(B, Bp, Ap, Cp, Gp, Ep, Bp, B, A, C, G, E, B)                
    polygon(borders, col=color[3], border = NA)

    #Draw white polygon on outside of upper triangle to get rid of part of initial circle
    outer_white = rbind(Cp,Gp,c(Gp[1],Cp[2]))
    polygon(outer_white,col = "white", border = NA)

    #Draw grids, cirlces, and points if imaginary is TRUE
    if (imaginary == TRUE){
        main_points = rbind(A, B, C, D, E, F, G, H, I, J, K, L, M, N, 
                            O, P, Q, R, S, T, U, V, W)  
        points(main_points, pch = 19, cex = 0.5)
        text(main_points, c("A", "B", "C", "D", "E", "F", "G", "H", "I",
                            "J", "K", "L", "M", "N", "O", "P", "Q", "R",
                            "S", "T", "U", "V", "W"), pos = 3, font =2)
        lines(rbind(H,I), lty = 2)
        lines(rbind(J,G), lty = 2)
        lines(rbind(J,K), lty = 2)
        lines(rbind(U,V), lty = 2)

        #Draw Moon arcs
        symbols (x = L[1], y = L[2], circles=c(L_N), add =TRUE, inches=FALSE, bg = NA)
        symbols (x = M[1], y = M[2], circles=c(M_Q), add =TRUE, inches=FALSE, bg = NA)
        symbols (x = N[1], y = N[2], circles=c(M_N), add =TRUE, inches=FALSE, bg = NA)
        symbols (x = T[1], y = T[2], circles=c(T_S), add =TRUE, inches=FALSE, bg = NA)
        symbols (x = T[1], y = T[2], circles=c(T_M), add =TRUE, inches=FALSE, bg = NA)

        #Draw Sun circles
        symbols (x = W[1], y = W[2], circles=c(M_N), add =TRUE, inches=FALSE, bg = NA)
        symbols (x = W[1], y = W[2], circles=c(L_N), add =TRUE, inches=FALSE, bg = NA)          
    }
}

Python (+ PIL), 578

Parce que je m'ennuie assez aujourd'hui ..

from PIL import Image,ImageDraw
from math import*
I,k,l,m,n,o,_=Image.new('P',(394,480)),479,180,465,232,347,255;D=ImageDraw.Draw(I);P,G=D.polygon,D.pieslice
I.putpalette([_,_,_,0,0,_,_,20,60])
def S(x,y,r,e,l,b):
 p,a,h=[],2*pi/e,r*l;c,d=[0,-a/2][b],[a/2,0][b]
 for i in range(e):p+=[(x+r*cos(i*a+c),y+r*sin(i*a+c)),(x+h*cos(i*a+d),y+h*sin(i*a+d))]
 P(p,fill=0)
P([(0,0),(393,246),(144,246),(375,k),(0,k)],fill=1)
P([(14,25),(o,n),(110,n),(o,m),(14,m)],fill=2)
S(96,o,68,12,.6,0)
G([(31,90),(163,221)],0,l,fill=0)
G([(28,68),(166,200)],0,l,fill=2)
S(96,178,40,16,.7,1)
I.show()