C'è già stata una 9 Hole Challenge (e un'altra qui ), ma è stato davvero l'anno scorso. E poi, io sono stato solo in giro per 2 mesi (anche se sembra come per sempre). Ed è notevolmente diverso.

Classifica: (notare che la ponderazione per i fori non è ancora stata stabilita)

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

Altri fori:

• buca 2
• buco 3

Ultimamente è stato lento qui, quindi sono qui per dare il via al prossimo campo da golf a 9 buche, coinvolgendo un'infarinatura di tutto ciò che ho visto qui nella mia esperienza (anche se limitata). Ciò comporterà:

• Ascii Art
• Uscita grafica
• Il gioco della vita di Conway
• re della Collina
• Complessità di Kolmogorov
• Quines
• Elaborazione delle immagini
• Matematica
• Codice classico golf.

Non vedo davvero l'ora di vedere cosa puoi fare!

Regole di concorrenza

• Sceglierai 1 lingua per tutte le buche (a cui partecipi ... vedi punto 4 per maggiori informazioni).
• Per tutti i buchi - le scappatoie standard non sono (ancora) divertenti.
• La prossima sfida apparirà quando vedrò che ci sono abbastanza invii dato un ragionevole lasso di tempo. Il re della collina, ad esempio, impiegherà più tempo.
• Non è necessario partecipare a tutte le buche. Se trovi una buca particolarmente impegnativa, non hai il tempo di farlo, ecc., Riceverai 2 volte più punti del punteggio più basso. Si prega di non trarre vantaggio da questa regola lasciando 1 risposta di golfscript con 12 caratteri e prendendo 24 come punteggio.

punteggio

• Il tuo punteggio si basa sul culmine dei punteggi di tutte le buche
• Il punteggio più basso vince (come per il golf reale)
• La classifica verrà posizionata nella parte superiore di questa pagina

Farò del mio meglio per assicurarmi che nessuna domanda sia duplicata, che tutte abbiano criteri oggettivi, che siano ben scritte e che abbiano tutti (relativamente) lo stesso peso nel contesto dell'intero concorso.

Tuttavia, per favore sii paziente quando fallisco.

E, senza ulteriori indugi, la prima sfida!

Il globo al plasma

Un globo al plasma è il giocattolo preferito da tutti:

Il tuo lavoro è quello di disegnarne uno.

Devi disegnare una base:

un globo:

A tesla thingy (?)

E, naturalmente, fantastici germogli al plasma:

Tuttavia, quando metti la mano vicino a un globo al plasma (o ad un oggetto conduttivo come mi dice Wikipedia), attira il plasma .

Il tuo globo dovrebbe riflettere questo.

Per dirla quantitativamente, il tuo globo ha un massimo di 16 tiri (vedi foto sopra). Un "oggetto" sulla superficie del globo (dato da un angolo in radianti) conterrà "potenza conduttiva", cioè la quantità di raggi che attira. Quindi un oggetto con una potenza di 5 attirerà 5 raggi (una sola linea con spessore 5) lasciando 11 a diffondersi uniformemente nel resto del globo :

Si noti che
1. il cerchio nero al centro rimane sopra il plasma
2. che in questo esempio l'angolo sarebbe pi / 2.

Potresti avere più di un oggetto conduttivo e, in tal caso, non è necessario che i tiri siano equamente distanziati. Tuttavia, sono relativamente distanziati. Ad esempio, questo vale per 2 oggetti, 1 ad angolo pi / 4 potenza 5 e un altro ad angolo 5pi / 3 potenza 3:

Dovresti essere in grado di vedere ciascuno dei punti finali dei germogli (di plasma).

Tuttavia, dato un oggetto (o somma di oggetti) con potenza maggiore di 16, il globo "si spezzerà":

Appunti

• Il diametro del globo è 1,5 volte più grande della lunghezza della base, che è un quadrato
• Quando il globo si rompe, il globo si trova sul lato destro. È tangente al lato destro della base e al suolo. Non dovrebbe esserci plasma quando il globo al plasma è rotto (perché? Caratteristiche di sicurezza ovviamente! Nessuna parola su come si è rotto in primo luogo.)
• Il colore di tutto tranne i germogli deve essere nero e 1 pixel di spessore. Il colore del plasma ha tonalità 245-280, e la saturazione / valore di 100. Usare questo sotto "HSV" se non avete idea di cosa sto parlando.

Ingresso

L'input può essere tramite STDIN / args della riga di comando / qualunque cosa o tramite argomenti di funzione.

Dovrebbero esserci 2 input: lunghezza della base del globo al plasma (includere un asse se si utilizza la grafica vettoriale) e una matrice di oggetti come questo:

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

Quindi per nessun oggetto (vedi prima immagine con 16 righe) l'input sarebbe

100,[]

Per il prossimo (un oggetto, potenza 5) sarebbe:

100,[[1.570796,5]]

Per l'ultimo esempio:

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

Questo è code-golf, quindi vince il codice più breve in byte .

Elaborazione di 2-717 caratteri

Poiché l'elaborazione è un linguaggio creato per gli artisti e sono un programmatore alle prime armi, non mi aspetto di fare molto bene su molte di queste sfide. Detto questo, mi piace davvero quanto sia semplice disegnare le cose in elaborazione, e ho avuto intenzione di giocarci ancora un po ', quindi queste sfide dovrebbero essere interessanti.

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);}

Sono sicuro che questo può essere notevolmente ridotto e potrei provare a farlo quando avrò più tempo, ma per ora sono contento.

legge in un file (f.txt) situato nella cartella dei dati dello schizzo per ottenere il suo input. Ho usato l'idea di Camerons di spostare i raggi liberi fino a quando non si sovrappongono.

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);
}

Esempi:

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

100, []

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

ottenere l'elaborazione qui

Python, 878 caratteri

Questo non è affatto buono, ma volevo vedere una risposta per questa buca.

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

E alcuni output di esempio

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

Legge i suoi parametri dall'argomento della riga di comando.

Immagini di esempio:

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

(parametri = 100,[])

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