Já houve um desafio de 9 buracos (e outro aqui ), mas isso foi muuuuito no ano passado. Além disso, eu só estou aqui há 2 meses (embora pareça uma eternidade). E é consideravelmente diferente.

Quadro de Líderes: (observe que a ponderação dos furos ainda não foi estabelecida)

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

Outros furos:

• buraco 2
• buraco 3

Tem sido lento por aqui ultimamente, por isso estou aqui para iniciar o próximo campo de golfe de 9 buracos, envolvendo um punhado de tudo o que tenho visto aqui em minha (embora limitada) experiência. Isso implicará:

• Ascii Art
• Saída gráfica
• Jogo da vida de Conway
• Rei da colina
• Complexidade de Kolmogorov
• Quines
• Processamento de imagem
• Matemática
• Código de golfe clássico.

Estou realmente ansioso para ver o que você pode fazer!

Regras da Competição

• Você escolherá 1 idioma para todos os buracos (dos quais participa ... consulte o ponto 4 para obter mais informações).
• Para todos os buracos - as brechas padrão (ainda) não são engraçadas.
• O próximo desafio será exibido quando constatar que há envios suficientes, com um tempo razoável. O rei da colina, por exemplo, levará mais tempo.
• Você não precisa participar de todos os buracos. Se você acha um buraco particularmente desafiador, não tem tempo para fazê-lo, etc., receberá 2 vezes mais pontos que a pontuação mais baixa. Por favor, não tire proveito desta regra deixando 1 resposta com 12 caracteres e tendo 24 como pontuação.

Pontuação

• Sua pontuação é baseada no ponto culminante das pontuações de todos os buracos
• Menor pontuação ganha (conforme o golfe real)
• A tabela de classificação será colocada no topo desta página

Farei o possível para garantir que nenhuma pergunta seja duplicada, que todas as perguntas tenham critérios objetivos, sejam bem escritas e que tenham peso (relativamente) igual no contexto de todo o concurso.

No entanto, por favor, seja paciente quando eu falhar.

E, sem mais delongas, o primeiro desafio!

O Globo de Plasma

Um globo de plasma é o brinquedo favorito de todos:

Seu trabalho é desenhar um.

Você deve desenhar uma base:

um globo:

Uma coisa de tesla (?)

E, é claro, brotos de plasma frios:

No entanto, quando você coloca a mão perto de um globo de plasma (ou de um objeto condutor, como a Wikipedia me diz), ele atrai o plasma .

Seu globo deve refletir isso.

Para colocar quantitativamente, seu globo tem no máximo 16 fotos (veja a imagem acima). Um "objeto" na superfície do globo (dado por um ângulo em radianos) conterá "potência condutora", ou seja, a quantidade de feixes que atrai. Portanto, um objeto com uma potência de 5 atrai 5 feixes (uma única linha com espessura de 5), deixando 11 para se espalharem uniformemente pelo resto do globo :

Observe que
1. o círculo preto no meio permanece acima do plasma
2. que, neste exemplo, o ângulo seria pi / 2.

Você pode ter mais de um objeto condutor e, nesse caso, não é necessário que as fotos sejam igualmente espaçadas. No entanto, eles são relativamente espaçados. Por exemplo, isso é válido para 2 objetos, 1 no ângulo pi / 4 de potência 5 e outro no ângulo 5pi / 3 de potência 3:

Você deve conseguir ver cada um dos pontos finais das sessões (de plasma).

No entanto, dado um objeto (ou soma de objetos) com potência maior que 16, o globo "quebrará":

Notas

• O diâmetro do globo é 1,5 vezes maior que o comprimento da base, que é um quadrado
• Quando o globo quebra, o globo está do lado direito. É tangente ao lado direito da base e do solo. Não deve haver plasma quando o globo de plasma está quebrado (por quê? Recursos de segurança, é claro! Nenhuma palavra sobre como ele quebrou em primeiro lugar).
• A cor de tudo, exceto as fotos, deve ser preta e 1 pixel de espessura. A cor do plasma tem matiz 245 - 280 e saturação / valor 100. Use isso em "HSV" se você não tem idéia do que estou falando.

Entrada

A entrada pode ser feita por meio de STDIN / linha de comando args / qualquer que seja ou por meio de argumentos de função.

Deve haver 2 entradas - comprimento da base do globo de plasma (inclua um eixo se estiver usando gráficos vetoriais) e uma matriz de objetos como este:

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

Portanto, para nenhum objeto (veja a primeira foto com 16 linhas), a entrada seria

100,[]

Para o próximo (um objeto, poder 5), seria:

100,[[1.570796,5]]

Para o último exemplo:

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

Isso é código-golfe, então o código mais curto em bytes vence.

Processando 2 - 717 caracteres

Como o processamento é uma linguagem feita para artistas e sou um programador muito novato, não espero me sair muito bem em muitos desses desafios. Dito isto, eu realmente gosto de como é simples desenhar coisas no processamento, e tenho pensado em brincar um pouco mais com isso, então esses desafios devem ser interessantes.

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

Tenho certeza de que isso pode ser consideravelmente melhor e posso tentar fazer isso quando tiver mais tempo, mas por enquanto estou feliz com isso.

lê em um arquivo (f.txt) localizado na pasta de dados do esboço para obter sua entrada. Usei a idéia dos Cameron de mudar as vigas livres até que não se sobrepusessem.

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

Exemplos:

100, [[0,785398,3], [5,23598,5]]

100, []

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

obtenha o processamento aqui

Python, 878 caracteres

De maneira alguma isso é bom para o golfe, mas eu queria ver uma resposta para esse buraco.

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 algumas saídas de amostra

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

Ele lê seus parâmetros a partir do argumento da linha de comandos.

Imagens de exemplo:

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

(parâmetros = 100,[])

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