Było już 9-dołkowe wyzwanie (i jeszcze jedno tutaj ), ale w zeszłym roku było tak bardzo dobrze. A poza tym jestem tam dopiero od 2 miesięcy (choć wydaje się, że to wieczność). I jest znacznie inny.

Tabela liderów: (zauważ, że ważenie dziur nie zostało jeszcze ustalone)

+---------------+------------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+
|Competitor     | Language   | Hole 1 | Hole 2 | Hole 3 | Hole 4 | Hole 5 | Hole 6 | Hole 7 | Hole 8 | Hole 9 | Total  |
+----------------------------------------------------------------------------------------------------------------------+
|Dennis         |CJam        |        | 31     |        |        |        |        |        |        |        | 31     |
+----------------------------------------------------------------------------------------------------------------------+
|Optimizer      |CJam        |        | 35     |        |        |        |        |        |        |        | 35     |
+----------------------------------------------------------------------------------------------------------------------+
|Martin Büttner |Mathematica |        | 222    |        |        |        |        |        |        |        | 222    |
+----------------------------------------------------------------------------------------------------------------------+
|Cameron        |Python      | 878    |        |        |        |        |        |        |        |        | 878    |
+----------------------------------------------------------------------------------------------------------------------+
|bubalou        |Processing 2| 717    |        |        |        |        |        |        |        |        | 717    |
+----------------------------------------------------------------------------------------------------------------------+
|Doorknob       |Python 2    |        |        |0.079711|        |        |        |        |        |        |0.079711|
+----------------------------------------------------------------------------------------------------------------------+
|Vulcan         |Java        |        |        |0.6949  |        |        |        |        |        |        |0.6949  |
+----------------------------------------------------------------------------------------------------------------------+
|Eli            |C++         |        |        |1.42042 |        |        |        |        |        |        |1.42042 |
+---------------+------------+--------+--------+--------+--------+--------+--------+--------+--------+--------+--------+

Inne otwory:

• dziura 2
• dziura 3

Ostatnio było tu dość wolno, więc jestem tutaj, aby rozpocząć 9-dołkowe pole golfowe, obejmując odrobinę wszystkiego, co widziałem tutaj w moim (choć ograniczonym) doświadczeniu. Będzie to pociągać za sobą:

• Ascii Art
• Wyjście graficzne
• Gra życia Conwaya
• Król wzgórza
• Złożoność Kołmogorowa
• Quines
• Przetwarzanie obrazu
• Matematyka
• Klasyczny golf.

Naprawdę nie mogę się doczekać, aby zobaczyć, co możesz zrobić!

Zasady konkursu

• Wybierz jeden język dla wszystkich otworów (w których uczestniczysz ... patrz punkt 4, aby uzyskać więcej informacji).
• Dla wszystkich dziur - standardowe luki nie są (wciąż) śmieszne.
• Następne wyzwanie pojawi się, gdy zobaczę, że jest wystarczająco dużo zgłoszeń, biorąc pod uwagę rozsądną ilość czasu. Na przykład król wzgórza potrwa dłużej.
• Ci nie muszą uczestniczyć we wszystkich otworach. Jeśli uznasz, że dołek jest szczególnie trudny, nie masz na to czasu itp., Otrzymasz 2 razy więcej punktów niż najniższy wynik. Proszę nie korzystać z tej zasady, pozostawiając 1 odpowiedź w golfa z 12 znakami i biorąc 24 jako wynik.

Punktacja

• Twój wynik opiera się na kulminacji wyników ze wszystkich dołków
• Najniższy wynik wygrywa (jak na prawdziwy golf)
• Tabela liderów zostanie umieszczona u góry tej strony

Postaram się jak najlepiej, aby upewnić się, że żadne pytania nie są duplikatami, wszystkie pytania mają obiektywne kryteria, są dobrze napisane i że wszystkie mają (względnie) równą wagę w kontekście całego konkursu.

Prosimy jednak o cierpliwość, gdy zawiodę.

I bez zbędnych ceregieli pierwsze wyzwanie!

Kula plazmy

Kula plazmowa jest najbardziej lubianym zabawki:

Twoim zadaniem jest narysowanie jednego.

Musisz narysować bazę:

Glob:

Tesla rzecz (?)

I oczywiście fajne pędy plazmy:

Jednak, gdy położysz rękę w pobliżu kuli plazmy (lub obiektu przewodzącego, jak mówi mi Wikipedia), przyciąga ona plazmę .

Twój glob powinien to odzwierciedlać.

Mówiąc ilościowo, twoja kula ma maksymalnie 16 zdjęć (patrz zdjęcie powyżej). „Obiekt” na powierzchni globu (podany przez kąt w radianach) będzie zawierał „siłę przewodzącą”, to znaczy ilość wiązek, które przyciąga. Tak więc obiekt o mocy 5 przyciągnie 5 wiązek (pojedyncza linia o grubości 5), pozostawiając 11 równomiernie rozłożoną na resztę globu :

Zauważ, że
1. czarny okrąg pośrodku pozostaje powyżej plazmy
2. że w tym przykładzie kąt będzie wynosić pi / 2.

Możesz mieć więcej niż jeden obiekt przewodzący, w takim przypadku nie jest wymagane, aby pędy były równo rozmieszczone. Są one jednak stosunkowo oddalone. Na przykład jest to w porządku dla 2 obiektów, 1 pod kątem pi / 4 moc 5 i kolejny pod kątem 5pi / 3 moc 3:

Powinieneś być w stanie zobaczyć każdy z końcowych punktów pędów (plazmy).

Jednak biorąc pod uwagę obiekt (lub sumę obiektów) o mocy większej niż 16, kula ziemska „pęknie”:

Notatki

• Średnica globu jest 1,5 razy większa niż długość podstawy, która jest kwadratem
• Kiedy kula się pęka, kula jest po prawej stronie. Jest styczna do prawej strony podstawy, a także do ziemi. Po rozbiciu kuli plazmy nie powinno być plazmy (dlaczego? Oczywiście zabezpieczenia! Bez słowa o tym, jak się zepsuła).
• Kolor wszystkiego oprócz pędów musi być czarny, a grubość 1 piksela. Kolor plazmy ma odcień 245 - 280, a nasycenie / wartość 100. Użyj tego pod „HSV”, jeśli nie masz pojęcia, o czym mówię.

Wejście

Dane wejściowe mogą być wprowadzane przez STDIN / argumenty wiersza poleceń / cokolwiek lub przez argumenty funkcji.

Powinny istnieć 2 dane wejściowe - długość podstawy kuli plazmy (w przypadku grafiki wektorowej uwzględnij oś) oraz tablicę takich obiektów:

[[angle,power],[angle,power],[angle,power]]

Więc dla żadnych obiektów (patrz pierwszy obrazek z 16 liniami) wejściem będzie

100,[]

Dla następnego (jeden obiekt, moc 5) będzie to:

100,[[1.570796,5]]

W ostatnim przykładzie:

100,[[0.785398,5],[5.23598,3]]

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach .

Przetwarzanie 2 - 717 znaków

Ponieważ przetwarzanie jest językiem stworzonym dla artystów i jestem bardzo początkującym programistą, nie oczekuję, że poradzę sobie z wieloma z tych wyzwań. Biorąc to pod uwagę, bardzo podoba mi się to, jak łatwo jest rysować w przetwarzaniu, i chciałem się z tym jeszcze pogodzić, więc te wyzwania powinny być interesujące.

int j,m,b,k,d,l;float w,c,h,x,y,z;float v[],p[],g[];void setup(){j=m=d=0;c=z=0;String i[]= loadStrings("f.txt");i[0]=i[0].replace("[","").replace("]","");String o[]=split(i[0],',');v=new float[o.length];p=new float[o.length-1];for(String s:o){if(!s.equals("")){v[j]=Float.parseFloat(s);}j++;}w=v[0];size((int)w*3,(int)w*3);h=w*.75;l=v.length;noLoop();}void draw(){translate(w/2,height);scale(1,-1);rect(0,0,w,w);if(l>2){while(m<j-1){m+=2;c+=v[m];}}if(c>16){ellipse(w+h,h,2*h,2*h);rect(w/2,w,1,h);}else{ellipse(w/2,w+h,2*h,2*h);rect(w/2,w,1,h);b=16;m=1;stroke(#1500ff);if(l>2){while(m<j){p[m-1]=cos(v[m])*h;p[m]=sin(v[m])*h;strokeWeight(v[m+1]);line(w/2,w+h,p[m-1]+w/2,p[m]+w+h);b-=v[m+1];m+=2;}}strokeWeight(1);c=(PI*2)/b;k=b;g=new float[b+b];while(b>0){g[d]=cos(z+c*b)*h;g[d+1]=sin(z+c*b)*h;m=0;if(l>2){while(m<j-1){if(abs(g[d]-p[m])<.1 && abs(g[d+1]-p[m+1])<.1){b=k+1;z=z+.1;d=-2;break;}m+=2;}}b--;d+=2;}d--;while(d>0){line(w/2,w+h,g[d]+w/2,g[d-1]+w+h);d-=2;}}stroke(#000000);fill(#000000);ellipse(w/2,w+h,w/9,w/9);}

Jestem pewien, że można to znacznie obniżyć i mogę to zrobić, gdy będę miał więcej czasu, ale na razie jestem z tego zadowolony.

wczytuje plik (f.txt) znajdujący się w folderze danych szkicu, aby uzyskać jego dane wejściowe. Wykorzystałem pomysł Kameronów, aby przesunąć wolne wiązki, dopóki się nie nakładają.

int j,m,b,k,d,l;
float w,c,h,x,y,z;
float v[],p[],g[];
void setup(){
j=m=d=0;
c=z=0;
String i[]= loadStrings("f.txt");
i[0]=i[0].replace("[","").replace("]","");
String o[]=split(i[0],',');
v=new float[o.length];
p=new float[o.length-1];
for(String s:o){if(!s.equals("")){v[j]=Float.parseFloat(s);}j++;}
w=v[0];
size((int)w*3,(int)w*3);
h=w*.75;
l=v.length;
noLoop();
}

void draw()
{
  translate(w/2,height);
  scale(1,-1);
  rect(0,0,w,w);
  if(l>2) 
  {
    while(m<j-1)
    {
      m+=2;
      c+=v[m];
    }
  }
  if(c>16)
  {
    ellipse(w+h,h,2*h,2*h);
    rect(w/2,w,1,h);
  }
  else
  {
    ellipse(w/2,w+h,2*h,2*h);
    rect(w/2,w,1,h);
    b=16;m=1;
    stroke(#1500ff);
    if(l>2)
    { 
      while(m<j)
      {
        p[m-1] = cos(v[m]) * h;
        p[m] = sin(v[m]) * h;
        strokeWeight(v[m+1]);
        line(w/2,w+h,p[m-1]+w/2,p[m]+w+h);
        b-=v[m+1];
        m+=2;
      }
    }
    strokeWeight(1);
    c=(PI*2)/b;
    k=b;
    g=new float[b+b];
    while(b>0)
    {
      g[d] = cos(z+c*b) * h;
      g[d+1] = sin(z+c*b) * h;
      m=0;
      if(l>2)
      {
        while(m<j-1)
        {
          if(abs(g[d]-p[m])<.1 && abs(g[d+1]-p[m+1])<.1)
          {
            b=k+1;
            z=z+.1;
            d=-2;
            break;
          }
          m+=2;
        }
      }
      b--;
      d+=2;
    }
    d--;
    while(d>0)
    {
      line(w/2,w+h,g[d]+w/2,g[d-1]+w+h);
      d-=2;
    }
  }
    stroke(#000000);
    fill(#000000);
    ellipse(w/2,w+h,w/9,w/9);
}

Przykłady:

100, [[0.785398,3], [5.23598,5]]

100, []

100, [[1.72398,12], [5.23598,5]]

zacznij przetwarzanie tutaj

Python, 878 znaków

W żadnym wypadku nie jest to dobrze gra w golfa, ale chciałem znaleźć odpowiedź na ten problem.

import matplotlib.pyplot as P
from math import *
L=len
M=min
Y=P.plot
K=P.Circle
Z=P.gcf().gca().add_artist
f=sin
g=cos
k={'color':(0,0,0)}
j={'color':(.16,0,1)}
def Q(S,C):
    P.axis([-S,S*2.5,0,S*3.5],**k)
    Y([0,S,S,0,0],[0,0,S,S,0],**k)
    Y([S/2,S/2],[S,7*S/4],**k)
    Z(K([S/2,7*S/4],S/20,**k))

    k['fill']=False

    A,B=zip(*C)

    N=16-sum(B)
    if N<0:
        Z(K([7*S/4,3*S/4],3*S/4,**k))

    else:
        Z(K([S/2,7*S/4],3*S/4,**k))
        if L(C)==0:
            D(16,0,S)
        elif L(C)==1:
            D(N,A[0],S)
            Y([S/2,S/2+3*S*g(A[0])/4],[7*S/4,7*S/4+3*S*f(A[0])/4],linewidth=B[0],**j)
        else:
            for c in C:
                Y([S/2,S/2+3*S*g(c[0])/4],[7*S/4,7*S/4+3*S*f(c[0])/4],linewidth=c[1],**j)
            D(N,J(N,A),S)
    P.show()


def J(N,A):
    T=d=0
    t=2*pi/N
    while d<0.1:
        T+=0.1
        d=M(M(a-T-floor((a-T)/t)*t for a in A),\
            M(T+ceil((a-T)/t)*t-a for a in A))
    return T


def D(N,I,S):
    a=I
    for i in range(N):
        Y([S/2,S/2+3*S*g(a)/4],[7*S/4,7*S/4+3*S*f(a)/4],**j)
        a+=2*pi/N

I kilka przykładowych wyników

Q(100,[[pi/4,6],[-4.2*pi/8,1]])

Q(100,[[0.785398,10],[5.23598,7]])

Q(100,[[pi/4,3],[pi/2,3],[3*pi/2,2],[5*pi/4,2]])

Python 2.7, 378 375

from turtle import *;import sys
(s,P),A,B=eval(sys.argv[1]),90,180
n,S=sum([b for(a,b) in P]),.75*s;l=16-n
for i in 'abcd':fd(s);lt(A)
pu()
if l<0:goto(s+S,0)
else:goto(s/2,s)
pd();circle(S);pu();goto(s/2,s);lt(A);pd();fd(S)
def C():fd(S);fd(-S)
if n<16:
 color('blue')
 for i in range(l):rt(360/l);C()
 for a,p in P:pensize(p);rt(a*57.3);C()
color('black')
shape('circle')

Odczytuje swoje parametry z argumentu wiersza poleceń.

Przykładowe obrazy:

(parametry = 100,[[0.785398,5],[5.23598,3]])

(parametry = 100,[])

(parametry = 100,[[1.72398,12],[5.23598,5]])