Narysuj flagę Korei Południowej

58

Kiedy natknąłem się na to pytanie , przypomniałem sobie, że kiedyś widziałem dokładne zasady budowy flagi Korei Południowej. A to zupełnie inna konstrukcja.

wprowadź opis zdjęcia tutaj

Źródło: Wikipedia

Więc teraz narysuj dokładną konstrukcję tego!

Specyfikacja

Możesz renderować flagę do pliku lub ekranu za pomocą grafiki wektorowej lub rastrowej. Jeśli wyniki są rasteryzowane, obraz musi mieć wymiary co najmniej 450 x 300 pikseli.

Wszystkie proporcje długości i pozycje muszą być dokładnie takie, jak pokazano na poniższym schemacie:

wprowadź opis zdjęcia tutaj

Źródło: Wikipedia

Zauważ, że środki dwóch małych kółek są wyrównane z przekątną.

W przypadku kolorów należy użyć następującej palety:

  • Biały: #FFFFFF
  • Czarny: # 000000
  • Czerwony: # C60C30
  • Niebieski: # 003478

Czarnej granicy nie można narysować, chyba że system rysowania nie zezwala na określenie obszaru roboczego 3: 2 z przyczyn technicznych (w przeciwnym razie należy użyć obszaru roboczego 3: 2, a flaga powinna wypełnić całość). Jeśli musisz dodać granicę, może ona być dowolnie gruba - flaga powinna być uważana za ściśle wewnątrz czarnej granicy. Nie wolno rysować żadnych innych linii pomocniczych ani wskaźników długości. Oznacza to, że flaga powinna wyglądać dokładnie tak, jak na pierwszym obrazie.

Punktacja

To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach).

Jako ostrzeżenie, użycie istniejącej kompresji (jak osadzenie skompresowanego pliku GIF) wpada w kilka standardowych luk .

Martin Ender
źródło
2
Co ciekawe, flaga Korei zawiera wczesną formę systemu liczb binarnych ( britton.disted.camosun.bc.ca/jbbinflag.htm )
britishtea
Czy musimy narysować granicę, gdy używamy strony HTML większej niż flaga, ponieważ jest biały, nie widać żadnej separacji, nawet jeśli rozmiar płótna / elementu jest podobny do flagi
Optimizer
@Optimizer, nie, jeśli płótno jest ograniczone w sposób, który można w jakiś sposób uwidocznić (np. Przez wyróżnienie „elementu kontrolnego” w przeglądarce), wówczas nie potrzebujesz granicy. Czarną ramkę należy narysować tylko w rzadkim przypadku, gdy nie można technicznie określić zasięgu płótna.
Martin Ender
3
Zakładam, CountryData["ROK","Flag"]że się nie liczy?
wchargin
Ludzie
mylili

Odpowiedzi:

13

PHP / HTML / SVG, 324

(dodano podział linii dla czytelności)

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

Skompresowane dane są rozszerzane do tych samych danych SVG, co moja poprzednia odpowiedź pokazana poniżej, ale z dwiema zmianami ułatwiającymi kompresję:

  1. Dwie <use>sekcje są rozwinięte do oryginalnej zawartości <defs>sekcji. To wydłuża tekst źródłowy, ale zmniejsza entropię, dzięki czemu lepiej się kompresuje.

  2. W pierwszym <g>elemencie zmieniłem transform=translate(36,24)rotate(33.69)na transform=rotate(33.69)translate(43.27). Ma to ten sam efekt geometryczny, ale lepiej kompresuje, ponieważ sekwencja ><g transform=rotate(pojawia się teraz dwukrotnie.

Domyślnie PHP będzie to służyło Content-Type: text/html, więc nieprawidłowa składnia XML nie powinna stanowić problemu.

SVG / HTML, 463

Parser HTML nie jest zbytnio zorientowany na poprawną składnię, więc możemy pozbyć się cudzysłowów w parametrach, o ile nie zawierają spacji. Powinno być możliwe ściśnięcie tego nieco przy pomocy Javascript.

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

piskliwy kostuch
źródło
44

Python + Pycairo, 371 370 366 bajtów

Flaga

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)

Wysyła mały plik SVG o nazwie F.

Łokieć
źródło
C(*[.77,0,.05,.2,.19,.47][i::2])jest krótszy niżC(*[(.77,.05,.19),(0,.2,.47)][i%2])
isaacg,
Dlaczego piszesz s=SVGSurface("F",12,8);c=Context(s)zamiast po prostu c=Context(SVGSurface("F",12,8))?
Lily Chung,
@IstvanChung Dobry punkt.
Ell
32

HTML + CSS, 966 906 843 792 762 bajtów

W żadnym wypadku nie zwycięzca, ale dużo zabawy w rysowaniu w CSS. Można to jednak bardzo pograć w golfa.

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 solidjest tylko na pokaz, ponieważ <body>tag ma wyraźne granice, które mogą być obserwowane przez Inspektora lub podobne narzędzia, jak stwierdził PO

UWAGA Działa tylko w przeglądarce Firefox (lub Chrome canary / dev) ze względu na użycie transformacji i gradientów innych niż określone przez producenta.

Zobacz to w akcji

Optymalizator
źródło
Myślę, że powinieneś dołączyć tagi <link> lub <style> do swojej liczby postaci. Możesz zapisać kilka znaków: w CSS 0deg-> 0(dwa razy) i usunąć left:0z a:before. W HTML możesz użyć <p><ul></ul>. ( <p>zostanie wcześniej domyślnie zamknięty <ul>)
gronostaj
1
Działa w przeglądarce Firefox 32. Spektakularnie zawodzi w przeglądarce Safari 7.1.
200_success
1
Użyj LESS lub SASS dla CSS, który powinien dać ci całkiem sporo opcji, aby go znacznie skrócić. Dodatkowo :before{content:''}i :after{content:''}są dłuższe niż dodawanie kolejnego elementu (pomimo tego faktycznie wygląda lepiej).
David Mulder
@DavidMulder Chciałem raczej zabawnego czynnika w tym niż krótszym kodzie. Ludzie mogą odnosić się do czystego CSS łatwiej niż LESS lub SASS :)
Optymalizator
Działa również w najnowszym Chrome. @ 200_success Powinieneś być w stanie uruchomić go w Safari, dodając -webkit-przed wszystkimi literami transform:, ale nie trzeba dodawać , że dzięki temu będzie to trochę dłużej!
Klamka
20

BBC Basic, 349 343 znaków ASCII, tokenizowany rozmiar pliku 330

Pobierz emulator na http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

  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

Używanie prawidłowych kolorów dodawało dużo, ale gra w golfa wszystkimi poleceniami graficznymi aż do nieprzetworzonych kodów VDU daje oszczędność 6 znaków w porównaniu z moim oryginalnym postem. Cała grafika w BBC micro odbywa się za pomocą specyficznych dla maszyny kodów sterujących ASCII, więc zamiast używać komend graficznych wysokiego poziomu, możesz podawać bajty bezpośrednio do kontrolera VDU (zwykle krótszy, ale kosztem czytelności). Wartość kończąca się średnikiem zamiast przecinkiem to 16-bitowa reprezentacja little-endian 2 bajtów.

Wersja bez golfa

  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

Na początku programu przesuwam początek na środek ekranu.

Nie rysuję żadnych dużych kolorowych półokręgów. Zamiast tego uruchamiam pętlę, która rysuje małe czerwone i niebieskie kółka, obracając się w kierunku przeciwnym do ruchu wskazówek zegara. Robię prawie 3 pełne obroty (zaczynając od niebieskiego po prawej), co oczywiście jest więcej niż wystarczające do wypełnienia dysku. Zatrzymuję się na 3. rewolucji, gdy niebieski w prawym dolnym rogu znajduje się we właściwej pozycji, aby zrównać się z pasami (które trzeba wykreślić).

Kiedy kąt jest odpowiedni, rysuję jeden z pasków. wektor x, y do rysowania bieżącego małego niebieskiego koła służy do wskazania, w którym kierunku powinien być pasek. Dla każdego z 3 obrotów a*7DIV44obliczana jest inna wartość liczby całkowitej , która określa, czy należy narysować pierwszy, drugi lub trzeci takt z wewnętrzną krawędzią 6 / 8,7 / 8 lub 8/8 jednostek od środka ( zgodnie z jednostkami użytymi w specyfikacji pytania.) Ponieważ jednostki programu są 1/4 jednostek w specyfikacji, jest to nadal połowa jednostki, więc dzielimy ponownie przez 2 przed zapisaniem do zmiennej „b”, aby uniknąć powtarzania połowy później.

Słupki są rysowane w sposób ciągły, a w razie potrzeby środek jest usuwany. Zapobiega to łączeniu załamań. Zmienna z wskazuje, czy należy wyciąć pręt. To znaczy, gdy y jest ujemne dla środkowych słupków, a gdy x jest dodatnie dla pozostałych słupków.

MOVEto ruch absolutny. MOVEBYjest ruchem względnym. PLOT133traktuje dwie ostatnie pozycje kursora graficznego plus nową podaną (we współrzędnych względnych) jako trzy rogi równoległoboku i kreśli ten równoległobok.

Wynik (i omówienie ograniczeń językowych)

Wybrałem tryb ekranu 1280 x 800 pikseli logicznych = 640 x 400 pikseli fizycznych, który domyślnie ma czarne tło. Na tym rysuję biały prostokąt od -600, -400 do 600,400, aby działał jak moje „płótno”.

BBC Basic może obsługiwać 16 kolorów jednocześnie, z programowalnej palety. Ale obsługuje tylko 18-bitowy kolor, podczas gdy pytanie określa kolory jako 24-bitowe. Kolory jak najbliżej.

wprowadź opis zdjęcia tutaj

Level River St
źródło
2
Trochę przeredagowałem specyfikację dotyczącą granicy. Sposób, w jaki sobie z tym poradziłeś, jest prawie taki, jak zamierzałem.
Martin Ender
16

Pyton 3? Ó ( 552 549 bajtów)

Flaga

( Obraz w pełnym rozmiarze )

Edycja: Teraz, gdy mamy fragmenty stosu, oto test fragmentu stosu za pomocą Skulpt , z pomocą odpowiedzi ArtOfCode tutaj . Niestety, Skulpt nie wdrożył jeszcze w pełni Pythona, więc musiałem okaleczyć połowę mojego kodu, aby to zadziałało. Innymi słowy, ten fragment kodu ma jedynie wskazywać, jak działa mój program (bez konieczności pobierania Pythona).

(Uważam również, że może to nie działać w niektórych przeglądarkach ...)

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>


Rzeczywisty kod:

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

Ponieważ żółw jest taki powolny, jeśli chcesz natychmiastowych rezultatów, możesz dodać t.tracer(0)po pierwszym wierszu przed uruchomieniem skryptu.

Uwaga: z jakiegoś powodu żółw wciąż rysuje coś, co wygląda jak dodatkowe czarne piksele, mimo że już zadzwoniłem up(), i nie mam pojęcia, dlaczego ...

Sp3000
źródło
Wierzę, że ktoś zaimplementował Pythona (z turtle!) Na postie Stack Snippets; jeśli chcesz dowiedzieć się, jak to zrobić, możesz być jednym z pierwszych, którzy skorzystają z tej nowej funkcji! ;)
Klamka
@Doorknob musiałem zniszczyć połowę mojego kodu, aby nawet niejasno zrobić to, co chciałem, ale przynajmniej wizualnie robi to samo, co teraz w Pythonie. (Ale z jakiegoś powodu to nie działa na moim Chrome ...)
Sp3000,
2
Działa dobrze na Chrome iOS. Cieszę się, że ktoś znalazł zastosowanie w moim projekcie :)
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>

Jeśli Twoja przeglądarka obsługuje ES6, możesz wyświetlić ją na JSFiddle lub uruchomić fragment kodu .

Konstruuje flagę z kilku podstawowych kształtów, najpierw obracając płótno, aby uwzględnić kąty.

grc
źródło
Uwaga: to nie działa w Chrome 39, działa dobrze w FF> 29.
JBCP
<canvas width=576 height=384 id=D><script>c=D.getContext('2d')jest o 9 bajtów mniej. Ponadto, ponieważ cała strona jest biała, myślę, że musisz narysować granicę.
Optymalizator
@Optimizer Thanks. Jak rozumiem, granica jest potrzebna tylko wtedy, gdy masz nieskończone płótno.
grc,
5
Możesz to wypróbować dzięki Fragmentom stosu!
Beta Decay
@BetaDecay faktycznie zadziałało: 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]}}]

flaga

DavidC
źródło
3

C ++ ZBYT DUŻY

Próbowałem to przy użyciu mojej domowej biblioteki rysunków PPM . Jest technicznie skalowalny, ale jestem ograniczony przez moją funkcję rekurencyjnego wypełniania, ponieważ jest zawodna i lubi segfault, myślę, że zużywa zbyt dużo pamięci, więc nie pozwolę użytkownikowi ustawić skali. Obraz jest nieregularny, ponieważ współrzędne, które wpisałem dla każdego rogu słupków, są nieco wyłączone. wprowadź opis zdjęcia tutaj

Ustawiłem go tak, aby zaczynał od czarnego tła, następnie umieściłem biały okrąg na środku, a następnie czerwony i niebieski okrąg. Użyto rekurencyjnych wypełnień, aby dodać resztę czerwieni i niebieskiego. Następnie narysuj prostokąty białymi liniami, aby zaznaczyć czarne pasy. Podziel czarne tło na 4 sekcje z białymi liniami i użyj 4 rekurencyjnych wypełnień, aby każda sekcja była biała. Wykonanie tego w jednym przejściu spowodowałoby awarię. Renderowanie jest nadal bardzo wolne.

Nieskluczony kod główny (reszta biblioteki jest za duża, gra w golfa nie ma znaczenia)

#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");

}
użytkownik137
źródło
@SohamChowdhury Zupełnie niezamierzone, SEXY to południowo-wschodni róg, współrzędna punktu X, Y.
użytkownik137
3
Twoje jest jedynym rozwiązaniem, w którym flaga macha na wietrze!
CJ Dennis,
2

PostScript , 572 477 bajtów

Kod do gry w golfa:

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

Nieskluczony kod:

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

Wynik:

wynik

Thomas Fritsch
źródło
1

Python 2, 483 bajty

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]

Możliwe ulepszenia:

  • zakoduj cos, stałe grzechu
  • binarny PPM
  • przekształć na płaszczyznę [3,2]
  • optymalizuj instrukcje boolowskie

Wyjście jako tekst PPM, użycie:

python golf_korea.py > korea.ppm

wprowadź opis zdjęcia tutaj

wersja beta bez gry w golfa

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
źródło