Zeichnen Sie die südkoreanische Flagge

58

Als ich auf diese Frage stieß, fiel mir ein, dass ich auch einmal genaue Regeln für den Bau der südkoreanischen Flagge gesehen hatte. Und das ist eine ganz andere Konstruktion.

Bildbeschreibung hier eingeben

Quelle: Wikipedia

Sie müssen jetzt eine genaue Konstruktion für diese zeichnen!

Spezifikation

Sie können das Flag mithilfe von Vektor- oder Rastergrafiken in eine Datei oder einen Bildschirm rendern. Wenn Ihre Ausgabe gerastert ist, muss Ihr Bild eine Größe von 450 x 300 Pixel oder mehr haben.

Alle Längenverhältnisse und Positionen müssen genau den Angaben in der folgenden Abbildung entsprechen:

Bildbeschreibung hier eingeben

Quelle: Wikipedia

Beachten Sie, dass die Mitten der beiden kleinen Kreise auf die Diagonale ausgerichtet sind.

Für die Farben müssen Sie die folgende Palette verwenden:

  • Weiß: #FFFFFF
  • Schwarz: # 000000
  • Rot: # C60C30
  • Blau: # 003478

Die schwarze Grenze darf nur gezeichnet werden, wenn Sie in Ihrem Zeichnungssystem aus technischen Gründen keine 3: 2-Zeichenfläche angeben können (andernfalls sollten Sie eine 3: 2-Zeichenfläche verwenden und die Flagge sollte diese vollständig ausfüllen). Wenn Sie die Grenze hinzufügen müssen, kann sie beliebig dick sein - die Flagge sollte streng innerhalb der schwarzen Grenze betrachtet werden. Andere Hilfslinien oder Längenindikatoren dürfen nicht gezeichnet werden. Das heißt, die Flagge sollte genau wie im ersten Bild angezeigt werden.

Wertung

Dies ist Codegolf, daher gewinnt die kürzeste Antwort (in Bytes).

Zur Warnung: Die Verwendung vorhandener Komprimierung (wie das Einbetten eines komprimierten GIF) ist in mehrere Standardlücken unterteilt .

Martin Ender
quelle
2
Interessanterweise enthält die koreanische Flagge eine frühe Form des Binärzahlensystems ( britton.disted.camosun.bc.ca/jbbinflag.htm )
britishtea 20.10.14
Müssen wir den Rand zeichnen, wenn wir eine HTML-Seite verwenden, die größer als die Flagge ist, ist keine Trennung sichtbar, selbst wenn die Größe der Zeichenfläche / des Elements der Flagge ähnelt
Optimizer
@Optimizer, nein, wenn die Zeichenfläche auf eine Weise begrenzt ist, die irgendwie sichtbar gemacht werden kann (z. B. durch Hervorheben des "Inspect-Elements" Ihres Browsers), brauchen Sie keine Begrenzung. Der schwarze Rand sollte nur in dem seltenen Fall gezeichnet werden, in dem die Ausdehnung der Leinwand technisch nicht definiert werden kann.
Martin Ender
3
Ich nehme an, CountryData["ROK","Flag"]zählt nicht?
Wchargin

Antworten:

13

PHP / HTML / SVG, 324

(Zeilenumbrüche zur besseren Lesbarkeit hinzugefügt)

<?=gzinflate(base64_decode('tVHBioMwFPyVwF5WSOzLi/tswQjdu9cevIk1KqtriaFd9utrgpSWFva0PPImMwzDkGTz
uWXnvrl8Tj8aOPAUebLNs5Y5W33PZrKjtpOrXPOuVEy7KMiD54mKMY3yrO5tPTTMaonM9MOg32qCWgHb5Nmpch076kIih/2y
PC4jRRCIU6BhbkwGV7lmAagk3d5nCfwQdKByVBwOFLagQu6exZLNzk5fjU+B9S4u/dF1Gh/apRw6Cb83uzHm0S69/cWbSIkx
YfSf5QT6dkk5UoACIeAfXTftepb/za8='));

Die komprimierten Daten werden auf die gleichen SVG-Daten wie in meiner vorherigen Antwort (siehe unten) erweitert, jedoch mit zwei Änderungen, um die Komprimierung zu unterstützen:

  1. Die beiden <use>Abschnitte werden auf den ursprünglichen Inhalt des <defs>Abschnitts erweitert. Dadurch wird der Quelltext länger, die Entropie wird jedoch verringert, sodass die Komprimierung verbessert wird.

  2. Im ersten <g>Elemente, änderte ich transform=translate(36,24)rotate(33.69)zu transform=rotate(33.69)translate(43.27). Dies hat geometrisch den gleichen Effekt, wird jedoch besser komprimiert, da die Sequenz ><g transform=rotate(jetzt zweimal angezeigt wird.

Standardmäßig dient PHP als Content-Type: text/html, daher sollte die ungültige XML-Syntax kein Problem darstellen.

SVG / HTML, 463

Der HTML-Parser kümmert sich nicht zu sehr um die korrekte Syntax, daher können wir Anführungszeichen in den Parametern beseitigen, solange sie keine Leerzeichen enthalten. Es sollte möglich sein, dies mit etwas Javascript weiter zu reduzieren.

<svg viewBox=0,0,72,48><defs><path d=M-25-6V6Zm3,0V6m3,0V-6M19-6V6Zm3,0V6m3,0V-6Z stroke=#000
stroke-width=2 id=p /></defs><g transform=translate(36,24)rotate(33.69)><circle r=12 fill=#c60c30
/><path d=M12,0A12,12,0,0,1-12,0A6,6,0,0,0,0,0A6,6,0,0,1,12,0Z fill=#003478 /><use xlink:href=#p
/><path d=M17,0h10z stroke=#fff stroke-width=1 /><g transform=rotate(112.62)><use xlink:href=#p
/><path d=M-27,0h4Zm6,0h4ZM20,0h4Z stroke=#fff stroke-width=1 /></g></g></svg>

zimperliches Ossifrage
quelle
44

Python + Pycairo, 371 370 366 Bytes

Flagge

from cairo import*
p=3.141593
c=Context(SVGSurface("F",12,8))
C=c.set_source_rgb;R=c.rectangle;T=c.rotate;F=c.fill
C(1,1,1);R(0,0,12,8);F()
c.translate(6,4);T(.588);b=3188
for o in[(0,.2,.47),(.77,.05,.19)]*2:C(*o);i=b/2%2;b+=1;c.arc(i,0,2-i,0,p+i*p);F();T(p)
C(0,0,0)
for x in(p,1.966)*2:
 for y in.5,0,1:
    for z in-1,1:R(3+y,-z,1./3,z*(2.75+b%2)/3);F()
    b/=2
 T(x)

Gibt eine winzige SVG-Datei mit dem Namen aus F.

Ell
quelle
C(*[.77,0,.05,.2,.19,.47][i::2])ist kürzer alsC(*[(.77,.05,.19),(0,.2,.47)][i%2])
isaacg 20.10.14
Warum schreibst du s=SVGSurface("F",12,8);c=Context(s)anstatt nur c=Context(SVGSurface("F",12,8))?
Lily Chung
@IstvanChung Guter Punkt.
Ell
32

HTML + CSS, 966 906 843 792 762 Bytes

Kein Gewinner zu jeder Zeit, aber viel Spaß beim Zeichnen in CSS. Dies kann jedoch viel Golf gespielt werden.

CSS, HTML :

*{position:fixed}a{background:linear-gradient(0deg,#003478 50%,#C60C30 50%);width:2in;height:2in;transform:rotate(.6rad);top:1in;left:2in}d,e{width:50%;height:50%;background:#C60C30;left:0;top:25%}a,d,e{border-radius:50%}d{background:#003478;left:50%}b,i{width:1in;height:26em;top:-1em;left:15em;transform:rotate(.98rad)}g,f,k,j{width:1in;height:17%;background:repeating-linear-gradient(0deg,#000,#000 1em,#fff 1em,#fff 1.5em);bottom:0;left:0}g,j,p{top:-.5em}b{transform:rotate(-.98rad)}c,p,v,x{height:2em;width:.5em;background:#fff;transform:rotate(.98rad)}p{top:2.8in;left:28em;transform:rotate(-.98rad) scale(1,4)}x{top:3.9em;left:28.4em}c,v{top:23.8em;transform:none}c{top:3.5em}body{height:4in;width:6in;border:1px solid
<a><d><e></a><b><f><g></b><i><j><k></i><p></p><x><v><c

;border:1px solidDies ist nur zur Veranschaulichung <body>gedacht , da das Tag klare Grenzen aufweist, die von Inspector oder ähnlichen Tools, wie vom OP angegeben, eingehalten werden können

HINWEIS Funktioniert nur in Firefox (oder Chrome Canary / Dev), da keine herstellerspezifischen Transformationen und Farbverläufe verwendet werden.

Sehen Sie es in Aktion

Optimierer
quelle
Ich denke, Sie sollten <link> - oder <style> -Tags in Ihre Zeichenanzahl aufnehmen. Sie können einige Zeichen speichern: in CSS 0deg-> 0(zweimal) und entfernen left:0aus a:before. In HTML könnten Sie verwenden <p><ul></ul>. ( <p>wird vor implizit geschlossen <ul>)
gronostaj 20.10.14
1
Funktioniert in Firefox 32. Scheitert spektakulär in Safari 7.1.
200_success
1
Verwenden Sie LESS oder SASS für das CSS, was Ihnen eine ganze Reihe von Optionen bieten sollte, um es ein wenig zu verkürzen. Zusätzlich :before{content:''}und :after{content:''}länger als nur das Hinzufügen eines weiteren Elements (obwohl dies in der Tat besser aussieht).
David Mulder
@DavidMulder Ich wollte den Spaßfaktor in diesem und nicht in kürzerem Code. Menschen können leichter mit reinem CSS in Verbindung gebracht werden als mit LESS oder SASS :)
Optimizer
Funktioniert auch in aktuellem Chrome. @ 200_success sollten Sie in der Lage sein , es in Safari zu arbeiten erhalten durch Zugabe -webkit-vor alle transform:s, aber unnötig zu sagen , dass es ziemlich viel länger machen würde!
Türklinke
20

BBC Basic, 349 343 ASCII-Zeichen, Token-Dateigröße 330

Laden Sie den Emulator unter http://www.bbcbasic.co.uk/bbcwin/bbcwin.html herunter

  p=1049q=25r=100VDU4118;275;-1,49,3076;19,7,-1;-1;531;255;7693;q;40;0;q,97,1200;800;29,640;400;
  FORa=38TO56STEP0.01x=r*COS(a)y=r*SIN(a)b=a*7DIV44/2IFb=3.5z=y<0ELSEz=x>0
  VDU18;1,p;-x;-y;q,153,r;0;18;2,p;x;y;q,153,r;0;18;0
  IFABS(y)DIV1=56VDUp;x*b+y;y*b-x;q;x/3;y/3;q,113,-2*y;2*x;18;7:b-=0.1VDUp;x*b+y/12;y*b-x/12;q;x/2;y/2;q,112-z,-y/6;x/6;
  NEXT

Das Verwenden der richtigen Farben fügte viel hinzu, aber das Golfen aller Grafikbefehle bis hinunter zu rohen VDU-Codes ergibt eine Einsparung von insgesamt 6 Zeichen im Vergleich zu meinem ursprünglichen Beitrag. Alle Grafiken auf dem BBC micro werden über maschinenspezifische ASCII-Steuercodes erstellt. Anstatt also allgemeine Grafikbefehle zu verwenden, können Sie Bytes direkt an den VDU-Controller senden (in der Regel kürzer, aber mit großem Aufwand für die Lesbarkeit). Ein mit Semikolon statt Komma endender Wert ist eine 16-Bit-Little-Endian-Darstellung von 2 Bytes.

Ungolfed-Version

  MODE16
  VDU19,1,-1,49,4,12                :REM adjust shade of red 
  VDU19,7,-1,-1,-1,-1               :REM adjust shade of white to full brightness (63 is 2's complement representation of -1
  VDU19,4,-1,0,13,30                :REM adjust shade of blue
  RECTANGLEFILL40,0,1200,800        :REM plot background rectangle
  ORIGIN640,400
  FORa=38TO56STEP0.01
    x=COS(a)*100
    y=SIN(a)*100
    GCOL1:CIRCLEFILL-x,-y,100       :REM red
    GCOL4:CIRCLEFILLx,y,100         :REM blue
    GCOL0                           :REM black
    b=a*7DIV44/2                    :REM divide a by 2*(22/7) to get integer representation, then divide by 2 again.
    IFb=3.5THENz=y<0ELSEz=x>0       :REM decide whether to cut bar
    REM If the angle is correct (100*sin(a) = 56) draw bar. If required, cut out the middle of the bar.
    IFABS(INT(y))=56 MOVEx*b+y,y*b-x:MOVEBY x/3,y/3:PLOT113,-2*y,2*x:GCOL7:b-=0.1:MOVEx*b+y/12,y*b-x/12:MOVEBY x/2,y/2:IFz PLOT113,-y/6,x/6
  NEXT

Zu Beginn des Programms verschiebe ich den Ursprung in die Mitte des Bildschirms.

Ich zeichne keine großen farbigen Halbkreise. Stattdessen führe ich eine Schleife aus, die kleine rote und blaue Kreise zeichnet und sich gegen den Uhrzeigersinn dreht. Ich mache fast 3 komplette Umdrehungen (beginnend mit Blau rechts), was offensichtlich mehr als genug ist, um die Scheibe auszufüllen. Ich halte bei der 3. Umdrehung an, gerade als das Blau rechts unten in der richtigen Position ist, um mit den Balken (die geplottet werden müssen) übereinzustimmen.

Wenn der Winkel stimmt, zeichne ich einen der Balken. Der Vektor x, y zum Zeichnen des aktuellen kleinen blauen Kreises gibt an, in welche Richtung der Balken zeigen soll. Für jede der 3 Umdrehungen wird ein anderer Wert der ganzen Zahl a*7DIV44berechnet, der angibt, ob der erste, zweite oder dritte Balken mit seiner Innenkante 6 / 8,7 / 8 oder 8/8 Einheiten von der Mitte entfernt gezeichnet werden soll ( entsprechend den in der Frage verwendeten Einheiten.) Da die Programmeinheiten 1/4 der in der Frage angegebenen Einheiten sind, ist dies immer noch eine halbe Einheit, sodass wir vor dem Speichern in die Variable ´b´ erneut durch 2 teilen, um eine wiederholte Halbierung zu vermeiden später.

Die Balken werden durchgezogen, und die Mitte wird bei Bedarf gelöscht. Dies verhindert, dass Knicke die Halbstangen verbinden. Die Variable z gibt an, ob ein Balken geschnitten werden soll. Das heißt, wenn y für die mittleren Balken negativ ist und wenn x für die anderen Balken positiv ist.

MOVEist ein absoluter Zug. MOVEBYist ein relativer Zug. PLOT133Berücksichtigt die letzten beiden Grafikcursorpositionen sowie die neue (in relativen Koordinaten) als drei Ecken eines Parallelogramms und zeichnet dieses Parallelogramm.

Ausgabe (& Diskussion von Spracheinschränkungen)

Ich habe einen Bildschirmmodus von 1280 x 800 logischen Pixeln = 640 x 400 physischen Pixeln ausgewählt, der standardmäßig einen schwarzen Hintergrund hat. Darauf zeichne ich ein weißes Rechteck von -600, -400 bis 600.400, um als meine "Leinwand" zu fungieren.

BBC Basic kann 16 Farben gleichzeitig von einer umprogrammierbaren Palette verarbeiten. Es werden jedoch nur 18-Bit-Farben unterstützt, während in der Frage die Farben als 24-Bit-Farben angegeben sind. Die Farben so nah wie möglich.

Bildbeschreibung hier eingeben

Level River St
quelle
2
Ich habe die Spezifikation bezüglich der Grenze ein wenig umformuliert. Die Art und Weise, wie Sie damit umgegangen sind, ist so ziemlich so, wie ich es beabsichtigt habe.
Martin Ender
16

Python 3-Schildkröte ( 552 549 Byte)

Flagge

( Bild in voller Größe )

Bearbeiten: Jetzt, da wir Stapel-Snippets haben, ist hier ein Stapel-Snippet-Test mit Skulpt , mit Hilfe von ArtOfCodes Antwort hier . Leider hat Skulpt Python noch nicht vollständig implementiert, daher musste ich die Hälfte meines Codes verstümmeln, damit dies funktioniert. Mit anderen Worten, dieses Snippet soll nur angeben, wie mein Programm funktioniert (ohne dass Python aufgerufen werden muss).

(Außerdem stelle ich fest, dass dies in einigen Browsern möglicherweise nicht funktioniert ...)

function out(a){var b=document.getElementById("output");b.innerHTML+=a}function builtinRead(a){if(void 0===Sk.builtinFiles||void 0===Sk.builtinFiles.files[a])throw"File not found: '"+a+"'";return Sk.builtinFiles.files[a]}
$(document).ready(function run(){Sk.canvas="canvas";Sk.configure({output:out,read:builtinRead});try{Sk.importMainWithBody("<stdin>",!1,'import turtle\nimport math\nt=turtle.Turtle()\nt.speed(9)\nR="#c60c30"\nr=56.3\nk=0.6\ns=60*k\noffsetx,offsety=-215,-145\nt.up()\nt.goto(offsetx,offsety)\nt.down()\ndef q():t.rt(90)\ndef Q():t.lt(90)\ndef K():t.color("black");t.begin_fill();q()\ndef A(g,G):t.fd(g);Q();t.fd(G);Q();t.fd(g);Q();t.fd(G);Q()\ndef E():t.up();t.fd(s);t.down();Q();t.end_fill();t.up();t.fd(30*k);t.down();\ndef i():K();t.up();t.bk(s);t.down();A(120*k,20*k);E()\ndef I():K();t.up();t.fd(5*k);t.down();A(55*k,20*k);t.up();t.bk(65*k);t.down();A(55*k,20*k);E()\ndef C():t.circle(120*k,180)\nA(720*k,480*k)\nt.seth(r)\nt.up()\nt.goto(459.8*k+offsetx,173.4*k+offsety)\nt.down()\nt.color(R)\nt.begin_fill()\nC()\nt.end_fill()\nt.begin_fill()\nt.color("#003478")\nC()\nt.circle(s)\nt.end_fill()\nt.color(R)\nC()\nt.begin_fill()\nt.circle(s)\nt.end_fill()\nq()\nt.up()\nt.fd(s)\nt.down()\ni()\ni()\ni()\nt.up()\nt.bk(530*k)\nt.down()\nI()\nI()\nI()\nt.up()\nt.fd(170*k)\nt.rt(2*r)\nt.fd(180*k)\nt.down()\nI()\ni()\nI()\nt.up()\nt.bk(530*k)\nt.down()\ni()\nI()\ni()\n')}catch(a){throw Error(a.toString());}})
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.2/jquery.min.js"></script><script src="http://www.skulpt.org/static/skulpt.min.js" type="text/javascript"></script><script src="http://www.skulpt.org/static/skulpt-stdlib.js" type="text/javascript"></script>
<canvas height="320" width="480" id="canvas" style="border:1px solid gray">Your browser does not support HTML5 Canvas!</canvas>


Tatsächlicher Code:

import turtle as t
b=t.begin_fill
c=t.circle
e=t.end_fill
f=t.fillcolor
R="#c60c30"
r=56.3
F=t.fd
B=t.bk
s=60
def q():t.rt(90)
def Q():t.lt(90)
def K():f(0,0,0);b();q()
def A(g,G):exec("F(g);Q();F(G);Q();"*2)
def E():F(s);Q();e();F(30)
def i():K();B(s);A(120,20);E()
def I():K();F(5);A(55,20);B(65);A(55,20);E()
def C():c(120,180)
A(720,480)
t.seth(r)
t.up()
t.goto(459.8,173.4)
f(R)
b()
C()
e()
b()
f("#003478")
C()
c(s)
e()
C()
f(R)
b()
c(s)
e()
q()
F(s)
i()
i()
i()
B(530)
I()
I()
I()
F(170)
t.rt(2*r)
F(180)
I()
i()
I()
B(530)
i()
I()
i()
t.ht()

Da die Schildkröte so langsam ist, können Sie, wenn Sie sofort Ergebnisse erzielen möchten, diese t.tracer(0)nach der ersten Zeile hinzufügen , bevor Sie das Skript ausführen.

Hinweis: Aus irgendeinem Grund zeichnet Turtle weiterhin zusätzliche schwarze Pixel, obwohl ich bereits angerufen habe up(), und ich habe keine Ahnung, warum ...

Sp3000
quelle
Ich glaube, jemand hat Python (mit Turtle!) In den Stack Snippets-Post implementiert. Wenn Sie herausfinden möchten, wie, könnten Sie einer der Ersten sein, die diese neue Funktion nutzen! ;)
Türklinke
@Doorknob Ich musste die Hälfte meines Codes zerstören, damit er auch nur vage das tat, was ich wollte, aber zumindest macht er optisch das Gleiche wie jetzt in Python. (Aber es funktioniert aus irgendeinem Grund nicht auf meinem Chrome ...)
Sp3000
2
Funktioniert gut auf Chrome iOS. Froh zu sehen, dass jemand eine Verwendung für mein Projekt gefunden hat :)
ArtOfCode
14

HTML + ES6, 388

<canvas id=D width=576 height=384><script>c=D.getContext('2d')
T=x=>c.translate(x*72,x*48)
R=(x,y)=>T(4)+c.rotate(x*.59)+T(-4)+eval('for(i=j=0;i*j<6;i+=(j^=1))c.fillRect(72+24*i+(i>2)*288,144+j*52,16,44+52*(y>>i&1-j))')
A=(w,x,y,z)=>(c.fillStyle=c.fill()+c.beginPath()||w)*c.arc(x*4,192-y,48*y,0,3.1,z)||A
R(-1,21)
R(2,7)
A(r='#C60C30',72,2,1)('#003478',72,2)(0,84,1,1)(r,60,1)()</script>

Wenn Ihr Browser ES6 unterstützt, können Sie es in JSFiddle anzeigen oder das Snippet ausführen.

Die Flagge wird aus einigen Grundformen konstruiert, wobei die Leinwand zuerst gedreht wird, um die Winkel zu berücksichtigen.

grc
quelle
Nur ein Hinweis, dies funktioniert nicht in Chrome 39, funktioniert gut in FF> 29.
JBCP
<canvas width=576 height=384 id=D><script>c=D.getContext('2d')ist 9 Bytes weniger. Da die ganze Seite weiß ist, müssen Sie den Rand zeichnen.
Optimierer
@Optimizer Danke. Soweit ich weiß, wird der Rand nur benötigt, wenn Sie eine unendliche Leinwand haben.
Grc
5
Sie könnten dies mit Stack Snippets versuchen!
Beta Decay
@BetaDecay es hat tatsächlich funktioniert: o
grc
6

Mathematica 404 450

b=1&~Array~13;a=ReplacePart[b,7-> 0];d=Disk;r=RGBColor;
z@{q_,p_,s_}:=ArrayPlot[{q,q,{},p,p,{},s,s},Frame-> False,ImageSize-> 155];
m=r@@{0,.2,.5};
o=r@@{.8,0,.2};
t=-19.1;u=-12.75;v=-5;q=-3.33;
Graphics[{Line[{{-36,-24},{36,-24},{36,24},{-36,24},{-36,-24}}],
Inset[Rotate[z@#,#2 125 Degree],#3]&@@@{{{b,a,b},1,{t,u}},{{a,b,a},1,{-t,-u}},
{{a,a,a},-1,{-t,u}},{{b,b,b},-1,{t,-u}}},
{o,d[{0,0},12,{-.2 Pi,.8Pi}],m, d[{0,0},12,{.8Pi,1.8Pi}],o,d[{v,-q},6],m,d[{-v,q},6]}}]

Flagge

DavidC
quelle
3

C ++ ZU GROSS

Versuchte dies mit meiner hausgemachten PPM-Zeichnungsbibliothek . Es ist technisch skalierbar, aber ich bin durch meine rekursive Füllfunktion eingeschränkt, da es unzuverlässig ist und gerne fehlerhaft arbeitet. Ich denke, es verbraucht zu viel Speicher, sodass der Benutzer die Skalierung nicht festlegen kann. Das Bild ist unregelmäßig, da die Koordinaten, die ich für jede Ecke der Balken eingegeben habe, geringfügig abweichen. Bildbeschreibung hier eingeben

Ich habe es so eingerichtet, dass es mit einem schwarzen Hintergrund beginnt, dann habe ich einen weißen Kreis in die Mitte und dann rote und blaue Kreise in die Mitte. Verwendet rekursive Füllungen, um den Rest von Rot und Blau hinzuzufügen. Dann zeichnete ich Rechtecke mit weißen Linien, um die schwarzen Balken zu markieren. Teilen Sie den schwarzen Hintergrund in 4 Abschnitte mit weißen Linien und verwenden Sie 4 rekursive Füllungen, um jeden Abschnitt weiß zu machen. Wenn Sie dies in einem Durchgang tun, wäre ein Segfehler aufgetreten. Es ist immer noch sehr langsam zu rendern.

Ungolfed Hauptcode (der Rest der Bibliothek ist zu groß, Golfen ist egal)

#include "PPMDraw.h"
#include <iostream>

int main(){
    std::cout << "Drawing Korean Flag" << std::endl;

    int scale = 150;
    int width = 3 * scale;
    int height = 2 * scale;

    int xc = width/2;
    int yc = height/2;

    // coords for the bar corners
    float nwax = -0.773; float nway = -0.813;
    float nwbx = -0.707; float nwby = -0.773;
    float nwcx = -1.000; float nwcy = -0.360;
    float nwdx = -1.050; float nwdy = -0.400;
    float nwex = -0.667; float nwey = -0.747;
    float nwfx = -0.613; float nwfy = -0.693;
    float nwgx = -0.880; float nwgy = -0.293;
    float nwhx = -0.947; float nwhy = -0.333;
    float nwix = -0.560; float nwiy = -0.667;
    float nwjx = -0.507; float nwjy = -0.627;
    float nwkx = -0.773; float nwky = -0.227;
    float nwlx = -0.840; float nwly = -0.267;

    float neax = 0.747; float neay = -0.813;
    float nebx = 0.867; float neby = -0.627;
    float necx = 0.813; float necy = -0.587;
    float nedx = 0.680; float nedy = -0.773;
    float neex = 0.893; float neey = -0.587;
    float nefx = 1.030; float nefy = -0.400;
    float negx = 0.960; float negy = -0.360;
    float nehx = 0.840; float nehy = -0.547;
    float neix = 0.640; float neiy = -0.747;
    float nejx = 0.920; float nejy = -0.333;
    float nekx = 0.853; float neky = -0.293;
    float nelx = 0.587; float nely = -0.693;
    float nemx = 0.533; float nemy = -0.667;
    float nenx = 0.667; float neny = -0.493;
    float neox = 0.600; float neoy = -0.440;
    float nepx = 0.480; float nepy = -0.627;
    float neqx = 0.693; float neqy = -0.440;
    float nerx = 0.813; float nery = -0.267;
    float nesx = 0.747; float nesy = -0.227;
    float netx = 0.627; float nety = -0.400;

    float swax = -0.773; float sway = 0.200;
    float swbx = -0.507; float swby = 0.613;
    float swcx = -0.560; float swcy = 0.653;
    float swdx = -0.840; float swdy = 0.253;
    float swex = -0.880; float swey = 0.280;
    float swfx = -0.760; float swfy = 0.453;
    float swgx = -0.813; float swgy = 0.493;
    float swhx = -0.947; float swhy = 0.320;
    float swix = -0.733; float swiy = 0.507;
    float swjx = -0.613; float swjy = 0.680;
    float swkx = -0.667; float swky = 0.720;
    float swlx = -0.787; float swly = 0.547;
    float swmx = -0.987; float swmy = 0.347;
    float swnx = -0.707; float swny = 0.760;
    float swox = -0.773; float swoy = 0.800;
    float swpx = -1.053; float swpy = 0.387;

    float seax = 0.747; float seay = 0.200;
    float sebx = 0.813; float seby = 0.253;
    float secx = 0.693; float secy = 0.427;
    float sedx = 0.627; float sedy = 0.387;
    float seex = 0.853; float seey = 0.280;
    float sefx = 0.920; float sefy = 0.320;
    float segx = 0.800; float segy = 0.507;
    float sehx = 0.733; float sehy = 0.453;
    float seix = 0.960; float seiy = 0.347;
    float sejx = 1.036; float sejy = 0.387;
    float sekx = 0.893; float seky = 0.573;
    float selx = 0.840; float sely = 0.520;
    float semx = 0.600; float semy = 0.427;
    float senx = 0.667; float seny = 0.467;
    float seox = 0.547; float seoy = 0.653;
    float sepx = 0.480; float sepy = 0.613;
    float seqx = 0.707; float seqy = 0.493;
    float serx = 0.773; float sery = 0.547;
    float sesx = 0.640; float sesy = 0.733;
    float setx = 0.547; float sety = 0.680;
    float seux = 0.813; float seuy = 0.573;
    float sevx = 0.880; float sevy = 0.613;
    float sewx = 0.747; float sewy = 0.800;
    float sexx = 0.693; float sexy = 0.747;

    PPMDraw flag = PPMDraw(width, height);
    flag.fill(0, 0, 0);

    // draw white circle in middle
    flag.set_color(255, 255, 255);
    flag.draw_fill_circle(xc, yc, scale/2);

    // draw red and blue portions of circle
    flag.set_color(255, 0, 0);
    flag.draw_fill_circle(xc - .21*scale, yc - .14*scale, scale/3.9);
    flag.set_color(0, 0, 255);
    flag.draw_fill_circle(xc + .21*scale, yc + .14*scale, scale/3.9);
    flag.set_color(255, 0, 0);
    flag.recursive_fill(xc + .21*scale, yc - .21*scale);
    flag.set_color(0, 0, 255);
    flag.recursive_fill(xc - .21*scale, yc + .21*scale);

    // draw the northwest bars
    flag.set_color(255, 255, 255);

    flag.draw_line(xc + nwax*scale, yc + nway*scale, xc + nwbx*scale, yc + nwby*scale);
    flag.draw_line(xc + nwax*scale, yc + nway*scale, xc + nwdx*scale, yc + nwdy*scale);
    flag.draw_line(xc + nwbx*scale, yc + nwby*scale, xc + nwcx*scale, yc + nwcy*scale);
    flag.draw_line(xc + nwcx*scale, yc + nwcy*scale, xc + nwdx*scale, yc + nwdy*scale);

    flag.draw_line(xc + nwex*scale, yc + nwey*scale, xc + nwfx*scale, yc + nwfy*scale);
    flag.draw_line(xc + nwex*scale, yc + nwey*scale, xc + nwhx*scale, yc + nwhy*scale);
    flag.draw_line(xc + nwfx*scale, yc + nwfy*scale, xc + nwgx*scale, yc + nwgy*scale);
    flag.draw_line(xc + nwhx*scale, yc + nwhy*scale, xc + nwgx*scale, yc + nwgy*scale);

    flag.draw_line(xc + nwix*scale, yc + nwiy*scale, xc + nwjx*scale, yc + nwjy*scale);
    flag.draw_line(xc + nwix*scale, yc + nwiy*scale, xc + nwlx*scale, yc + nwly*scale);
    flag.draw_line(xc + nwjx*scale, yc + nwjy*scale, xc + nwkx*scale, yc + nwky*scale);
    flag.draw_line(xc + nwlx*scale, yc + nwly*scale, xc + nwkx*scale, yc + nwky*scale);
    //NE
    flag.draw_line(xc + neax*scale, yc + neay*scale, xc + nebx*scale, yc + neby*scale);
    flag.draw_line(xc + neax*scale, yc + neay*scale, xc + nedx*scale, yc + nedy*scale);
    flag.draw_line(xc + nebx*scale, yc + neby*scale, xc + necx*scale, yc + necy*scale);
    flag.draw_line(xc + necx*scale, yc + necy*scale, xc + nedx*scale, yc + nedy*scale);

    flag.draw_line(xc + neex*scale, yc + neey*scale, xc + nefx*scale, yc + nefy*scale);
    flag.draw_line(xc + neex*scale, yc + neey*scale, xc + nehx*scale, yc + nehy*scale);
    flag.draw_line(xc + nefx*scale, yc + nefy*scale, xc + negx*scale, yc + negy*scale);
    flag.draw_line(xc + nehx*scale, yc + nehy*scale, xc + negx*scale, yc + negy*scale);

    flag.draw_line(xc + neix*scale, yc + neiy*scale, xc + nejx*scale, yc + nejy*scale);
    flag.draw_line(xc + neix*scale, yc + neiy*scale, xc + nelx*scale, yc + nely*scale);
    flag.draw_line(xc + nejx*scale, yc + nejy*scale, xc + nekx*scale, yc + neky*scale);
    flag.draw_line(xc + nelx*scale, yc + nely*scale, xc + nekx*scale, yc + neky*scale);

    flag.draw_line(xc + nemx*scale, yc + nemy*scale, xc + nenx*scale, yc + neny*scale);
    flag.draw_line(xc + nemx*scale, yc + nemy*scale, xc + nepx*scale, yc + nepy*scale);
    flag.draw_line(xc + nepx*scale, yc + nepy*scale, xc + neox*scale, yc + neoy*scale);
    flag.draw_line(xc + nenx*scale, yc + neny*scale, xc + neox*scale, yc + neoy*scale);

    flag.draw_line(xc + neqx*scale, yc + neqy*scale, xc + nerx*scale, yc + nery*scale);
    flag.draw_line(xc + neqx*scale, yc + neqy*scale, xc + netx*scale, yc + nety*scale);
    flag.draw_line(xc + nerx*scale, yc + nery*scale, xc + nesx*scale, yc + nesy*scale);
    flag.draw_line(xc + netx*scale, yc + nety*scale, xc + nesx*scale, yc + nesy*scale);

    //sw
    flag.draw_line(xc + swax*scale, yc + sway*scale, xc + swbx*scale, yc + swby*scale);
    flag.draw_line(xc + swax*scale, yc + sway*scale, xc + swdx*scale, yc + swdy*scale);
    flag.draw_line(xc + swbx*scale, yc + swby*scale, xc + swcx*scale, yc + swcy*scale);
    flag.draw_line(xc + swcx*scale, yc + swcy*scale, xc + swdx*scale, yc + swdy*scale);

    flag.draw_line(xc + swex*scale, yc + swey*scale, xc + swfx*scale, yc + swfy*scale);
    flag.draw_line(xc + swex*scale, yc + swey*scale, xc + swhx*scale, yc + swhy*scale);
    flag.draw_line(xc + swfx*scale, yc + swfy*scale, xc + swgx*scale, yc + swgy*scale);
    flag.draw_line(xc + swhx*scale, yc + swhy*scale, xc + swgx*scale, yc + swgy*scale);

    flag.draw_line(xc + swix*scale, yc + swiy*scale, xc + swjx*scale, yc + swjy*scale);
    flag.draw_line(xc + swix*scale, yc + swiy*scale, xc + swlx*scale, yc + swly*scale);
    flag.draw_line(xc + swjx*scale, yc + swjy*scale, xc + swkx*scale, yc + swky*scale);
    flag.draw_line(xc + swlx*scale, yc + swly*scale, xc + swkx*scale, yc + swky*scale);

    flag.draw_line(xc + swmx*scale, yc + swmy*scale, xc + swnx*scale, yc + swny*scale);
    flag.draw_line(xc + swmx*scale, yc + swmy*scale, xc + swpx*scale, yc + swpy*scale);
    flag.draw_line(xc + swpx*scale, yc + swpy*scale, xc + swox*scale, yc + swoy*scale);
    flag.draw_line(xc + swnx*scale, yc + swny*scale, xc + swox*scale, yc + swoy*scale);

    //se
    flag.draw_line(xc + seax*scale, yc + seay*scale, xc + sebx*scale, yc + seby*scale);
    flag.draw_line(xc + seax*scale, yc + seay*scale, xc + sedx*scale, yc + sedy*scale);
    flag.draw_line(xc + sebx*scale, yc + seby*scale, xc + secx*scale, yc + secy*scale);
    flag.draw_line(xc + secx*scale, yc + secy*scale, xc + sedx*scale, yc + sedy*scale);

    flag.draw_line(xc + seex*scale, yc + seey*scale, xc + sefx*scale, yc + sefy*scale);
    flag.draw_line(xc + seex*scale, yc + seey*scale, xc + sehx*scale, yc + sehy*scale);
    flag.draw_line(xc + sefx*scale, yc + sefy*scale, xc + segx*scale, yc + segy*scale);
    flag.draw_line(xc + sehx*scale, yc + sehy*scale, xc + segx*scale, yc + segy*scale);

    flag.draw_line(xc + seix*scale, yc + seiy*scale, xc + sejx*scale, yc + sejy*scale);
    flag.draw_line(xc + seix*scale, yc + seiy*scale, xc + selx*scale, yc + sely*scale);
    flag.draw_line(xc + sejx*scale, yc + sejy*scale, xc + sekx*scale, yc + seky*scale);
    flag.draw_line(xc + selx*scale, yc + sely*scale, xc + sekx*scale, yc + seky*scale);

    flag.draw_line(xc + semx*scale, yc + semy*scale, xc + senx*scale, yc + seny*scale);
    flag.draw_line(xc + semx*scale, yc + semy*scale, xc + sepx*scale, yc + sepy*scale);
    flag.draw_line(xc + sepx*scale, yc + sepy*scale, xc + seox*scale, yc + seoy*scale);
    flag.draw_line(xc + senx*scale, yc + seny*scale, xc + seox*scale, yc + seoy*scale);

    flag.draw_line(xc + seqx*scale, yc + seqy*scale, xc + serx*scale, yc + sery*scale);
    flag.draw_line(xc + seqx*scale, yc + seqy*scale, xc + setx*scale, yc + sety*scale);
    flag.draw_line(xc + serx*scale, yc + sery*scale, xc + sesx*scale, yc + sesy*scale);
    flag.draw_line(xc + setx*scale, yc + sety*scale, xc + sesx*scale, yc + sesy*scale);

    flag.draw_line(xc + seux*scale, yc + seuy*scale, xc + sevx*scale, yc + sevy*scale);
    flag.draw_line(xc + seux*scale, yc + seuy*scale, xc + sexx*scale, yc + sexy*scale);
    flag.draw_line(xc + sevx*scale, yc + sevy*scale, xc + sewx*scale, yc + sewy*scale);
    flag.draw_line(xc + sexx*scale, yc + sexy*scale, xc + sewx*scale, yc + sewy*scale);

    // fill in the black to white
    flag.draw_line(xc, yc - scale/2, xc, 0);
    flag.draw_line(xc, yc + scale/2, xc, height);
    flag.draw_line(xc - scale/2, yc, 0, yc);
    flag.draw_line(xc + scale/2, yc, width, yc);

    flag.recursive_fill(0, 0);
    flag.recursive_fill(0, height-1);
    flag.recursive_fill(width - 1, 0);
    flag.recursive_fill(width - 1, height - 1);

    flag.save("flag.ppm");

}
user137
quelle
@SohamChowdhury Völlig ungewollt ist SEXY die südöstliche Ecke, Punkt X, Y-Koordinate.
user137
3
Ihre ist die einzige Lösung, bei der die Flagge im Wind weht!
CJ Dennis
2

PostScript , 572 477 Bytes

Golf Code:

5 5 scale 36 24 translate /R{.75 .05 .19 setrgbcolor}def/B{0 .20 .47 setrgbcolor}def/a 2 3 atan def/b{0 setgray[18 -6 2 12 21 -6 2 12 24 -6 2 12]rectfill 1 setgray{[18 -.5 2 1 24 -.5 2 1]rectfill}if{21 -.5 2 1 rectfill}if}def a neg rotate R 0 0 12 0 180 arc closepath fill B 0 0 12 180 0 arc closepath fill R -6 0 6 0 360 arc closepath fill B 6 0 6 0 360 arc closepath fill true true b 2 a mul rotate false true b 180 rotate true false b -2 a mul rotate false false b
showpage

Ungolfed-Code:

5 5 scale                                     % over-all scale
36 24 translate                               % over-all shift
/R {.75 .05 .19 setrgbcolor} def              % prodecure for setting red color
/B {0 .20 .47 setrgbcolor} def                % procedure for setting blue color
/a 2 3 atan def                               % calculate angle = arctan(2/3) = 33.7°
/b {                                          % procedure for drawing bars
 0 setgray                                    %   black
 [18 -6 2 12 21 -6 2 12 24 -6 2 12] rectfill  %   draw 3 bars
 1 setgray                                    %   white
 {[18 -.5 2 1 24 -.5 2 1] rectfill} if        %   conditionally draw gap in inner/outer bars 
 {21 -.5 2 1 rectfill} if                     %   conditionally draw gap in middle bar 
} def
a neg rotate                                  % rotate -33.7°
R 0 0 12 0 180 arc closepath fill             % big red half circle
B 0 0 12 180 0 arc closepath fill             % big blue half circle
R -6 0 6 0 360 arc closepath fill             % small red circle
B  6 0 6 0 360 arc closepath fill             % small blue circle
true true b                                   % draw bars (with gap in all bars)
2 a mul rotate                                % rotate 67.4°
false true b                                  % draw bars (with gap in inner/outer bars)
180 rotate                                    % rotate 180°
true false b                                  % draw bars (with gap in middle bar)
-2 a mul rotate                               % rotate -67.4°
false false b                                 % draw bars (without gaps)
showpage

Ergebnis:

Ergebnis

Thomas Fritsch
quelle
1

Python 2, 483 Bytes

from math import*
w,k,r,b="255 "*3,"0 "*3,"198 12 48 ","0 52 120 "
print "P3 600 400 255 "
a=atan2(2,3)
c,s=cos(a),sin(a)
T=lambda x,y:(c*x-s*y,s*x+c*y)
S=lambda x,y:150<x<216.6and x%25<16.6and y*y<2500
C=lambda x,y,p=50:(x-p)**2+y*y<2500
for y in range(-200,200):
 for x in range(-300,300):X,Y=T(x,y);W,Z=T(-x,y);print [[w,k][(S(abs(X),Y)and(Y*Y>16or(166.6<X<191.4or-200>X or 0>X>-166.6)))or(S(abs(W),Z)and(W>0 or abs(Z)>4))],[b,r][(Z<0 or C(W,Z))and not C(W,Z,-50)]][W*W+Z*Z<10000]

Mögliche Verbesserungen:

  • hardcode the cos, sin Konstanten
  • binäres PPM
  • in die [3,2] Ebene transformieren
  • Optimieren Sie die Booleschen Anweisungen

Ausgabe als Text-PPM, Verwendung:

python golf_korea.py > korea.ppm

Bildbeschreibung hier eingeben

ungolfed beta version

from math import*
w,k,r,b="255 255 255 ", "0 0 0 ", "255 0 0 ", "0 0 255 "
g="0 255 0 "
print "P3 600 400 255 "
a=atan2(2,3)
c,s=cos(a),sin(a)
trans=lambda x,y:(c*x-s*y,s*x+c*y)
stripe=lambda x:150<x<216.6 and x%25<16.6
small=lambda x,y,p=50:(x-p)**2+y*y<2500
for y in range(-200,200):
 for x in range(-300,300):
  X,Y=trans(x,y)
  W,Z=trans(-x,y)
  if stripe(abs(X)) and Y*Y<2500:
   if abs(Y)>4:  
    print k
   else:
    if X>0:
     if 166.6<X<191.4:
      print k
     else:
      print w
    else:
     if -200<X<-166.6:
      print w
     else:
      print k
  elif stripe(abs(W)) and Z*Z<2500 and(W>0 or abs(Z)>4):
   print k
  elif W*W+Z*Z<100*100:
   if (Z<0 or small(W,Z)) and not small(W,Z,-50):
    print r
   else:
    print b
  else:
   print w
Karl Napf
quelle