Ya ha habido un desafío de 9 hoyos (y otro aquí ), pero fue muuuucho el año pasado. Y, además, que sólo han sido de alrededor de 2 meses (aunque parece que para siempre). Y es considerablemente diferente.

Tabla de clasificación: (tenga en cuenta que la ponderación de los agujeros aún no se ha establecido)

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

Otros agujeros:

• hoyo 2
• hoyo 3

Últimamente ha sido lento por aquí, así que estoy aquí para comenzar el próximo campo de golf de 9 hoyos, lo que implica un poco de todo lo que he visto aquí en mi experiencia (aunque limitada). Esto implicará:

• Arte Ascii
• Salida gráfica
• El juego de la vida de Conway
• Rey de la colina
• Complejidad de Kolmogorov
• Quines
• Procesamiento de imágenes
• Matemáticas
• Código clásico de golf.

¡Tengo muchas ganas de ver lo que puedes hacer!

Normas de competencia

• Elegirás 1 idioma para todos los agujeros (en los que participas ... ver el punto 4 para más información).
• Para todos los agujeros, las lagunas estándar (todavía) no son divertidas.
• El próximo desafío aparecerá cuando vea que hay suficientes envíos en un tiempo razonable. El rey de la colina, por ejemplo, llevará más tiempo.
• Usted no tiene que participar en todos los agujeros. Si encuentra un hoyo particularmente desafiante, no tenga tiempo para hacerlo, etc., recibirá 2 veces más puntos que la puntuación más baja. No aproveche esta regla dejando 1 respuesta de golfscript con 12 caracteres y tomando 24 como puntaje.

Puntuación

• Su puntaje se basa en la culminación de los puntajes de todos los agujeros
• La puntuación más baja gana (según el golf real)
• La tabla de clasificación se colocará en la parte superior de esta página.

Haré todo lo posible para asegurarme de que ninguna pregunta sea duplicada, que todas las preguntas tengan criterios objetivos, estén bien escritas y que todas tengan un peso (relativamente) igual en el contexto de todo el concurso.

Sin embargo, tenga paciencia cuando falle.

Y, sin más preámbulos, ¡el primer desafío!

El globo de plasma

Un globo de plasma es el juguete favorito de todos:

Tu trabajo es dibujar uno.

Debes dibujar una base:

un globo:

Una cosita tesla (?)

Y, por supuesto, brotes de plasma geniales:

Sin embargo, cuando coloca su mano cerca de un globo de plasma (o un objeto conductor como Wikipedia me dice), atrae el plasma .

Tu globo debería reflejar eso.

Para decirlo cuantitativamente, su globo tiene un máximo de 16 brotes (vea la imagen de arriba). Un "objeto" en la superficie del globo (dado por un ángulo en radianes) contendrá "potencia conductiva", es decir, la cantidad de haces que atrae. Por lo tanto, un objeto con una potencia de 5 atraerá 5 haces (una sola línea con un grosor de 5) dejando que 11 se distribuya uniformemente en el resto del mundo :

Tenga en cuenta que
1. el círculo negro en el medio permanece por encima del plasma
2. que en este ejemplo, el ángulo sería pi / 2.

Es posible que tenga más de un objeto conductor y, en ese caso, no es necesario que los brotes estén igualmente espaciados. Sin embargo, están relativamente espaciados. Por ejemplo, esto está bien para 2 objetos, 1 en el ángulo pi / 4 potencia 5 y otro en el ángulo 5pi / 3 potencia 3:

Debería poder ver cada uno de los puntos finales de los brotes (de plasma).

Sin embargo, dado un objeto (o suma de objetos) con un poder superior a 16, el globo se "romperá":

Notas

• El diámetro del globo es 1.5 veces más grande que la longitud de la base, que es un cuadrado
• Cuando el globo se rompe, el globo está en el lado derecho. Es tangente al lado derecho de la base, así como al suelo. No debe haber plasma cuando el globo de plasma está roto (¿por qué? ¡Características de seguridad, por supuesto! Ni una palabra sobre cómo se rompió en primer lugar).
• El color de todo excepto los brotes debe ser negro y de 1 píxel de grosor. El color del plasma tiene una tonalidad de 245 a 280 y una saturación / valor de 100. Use esto bajo "HSV" si no tiene idea de lo que estoy hablando.

Entrada

La entrada puede ser a través de STDIN / línea de comando args / lo que sea o mediante argumentos de función.

Debería haber 2 entradas: longitud de la base del globo de plasma (incluya un eje si usa gráficos vectoriales) y una matriz de objetos como este:

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

Entonces, para ningún objeto (ver la primera imagen con 16 líneas) la entrada sería

100,[]

Para el siguiente (un objeto, potencia 5) sería:

100,[[1.570796,5]]

Para el último ejemplo:

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

Este es el código de golf, por lo que gana el código más corto en bytes .

Procesando 2 - 717 caracteres

Como el procesamiento es un lenguaje hecho para artistas, y soy un programador muy novato, no espero tener un buen desempeño en muchos de estos desafíos. Dicho esto, realmente me gusta lo simple que es dibujar cosas en el procesamiento, y he tenido la intención de jugar un poco más, por lo que estos desafíos deberían ser interesantes.

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

Estoy seguro de que esto se puede reducir considerablemente y puedo intentar hacerlo cuando tenga más tiempo, pero por ahora estoy contento con eso.

lee en un archivo (f.txt) ubicado en la carpeta de datos del boceto para obtener su entrada. Usé la idea de Camerons de cambiar las vigas libres hasta que no se superpongan.

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

Ejemplos:

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

100, []

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

obtener procesamiento aquí

Python, 878 caracteres

De ninguna manera es un buen campo de golf, pero quería ver una respuesta para este hoyo.

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

Y algunas salidas de muestra

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

Lee sus parámetros del argumento de la línea de comandos.

Imágenes de muestra:

(parámetros = 100,[[0.785398,5],[5.23598,3]])

(parámetros = 100,[])

(parámetros = 100,[[1.72398,12],[5.23598,5]])