Il y a déjà eu un défi 9 trous (et un autre ici ), mais c'était tellement l'an dernier. Et d'ailleurs, je ne suis là que depuis 2 mois (bien que cela semble éternel). Et c'est considérablement différent.

Tableau des leaders: (notez que la pondération des trous n'est pas encore établie)

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

Autres trous:

• trou 2
• trou 3

Il a été lent ici ces derniers temps, donc je suis ici pour lancer le prochain parcours de golf de 9 trous, impliquant une poignée de tout ce que j'ai vu ici dans mon expérience (bien que limitée). Cela impliquera:

• Art Ascii
• Sortie graphique
• Le jeu de la vie de Conway
• roi de la colline
• Complexité de Kolmogorov
• Quines
• Traitement d'image
• Math
• Golf de code classique.

J'ai vraiment hâte de voir ce que vous pouvez faire!

Règlement du concours

• Vous choisirez 1 langue pour tous les trous (auxquels vous participez ... voir point 4 pour plus d'informations).
• Pour tous les trous - les failles standard ne sont (toujours) pas drôles.
• Le prochain défi apparaîtra lorsque je constaterai qu'il y a suffisamment de soumissions compte tenu d'un délai raisonnable. Le roi de la colline, par exemple, prendra plus de temps.
• Vous n'êtes pas obligé de participer à tous les trous. Si vous trouvez un trou particulièrement difficile, n'avez pas le temps de le faire, etc., vous recevrez 2 fois plus de points que le score le plus bas. Veuillez ne pas profiter de cette règle en laissant 1 réponse golfscript avec 12 caractères et en prenant 24 comme score.

Notation

• Votre score est basé sur le point culminant des scores de tous les trous
• Le score le plus bas gagne (selon le vrai golf)
• Le classement sera placé en haut de cette page

Je ferai de mon mieux pour m'assurer qu'aucune question n'est en double, que toutes les questions ont des critères objectifs, qu'elles sont bien écrites et qu'elles ont toutes (relativement) le même poids dans le contexte de l'ensemble du concours.

Cependant, veuillez être patient lorsque j'échoue.

Et, sans plus attendre, le premier défi!

Le globe de plasma

Un globe plasma est le jouet préféré de tous:

Votre travail consiste à en dessiner un.

Vous devez dessiner une base:

un globe:

Un truc Tesla (?)

Et, bien sûr, des pousses de plasma cool:

Cependant, lorsque vous placez votre main près d'un globe de plasma (ou d'un objet conducteur comme Wikipedia me le dit), il attire le plasma .

Votre globe devrait refléter cela.

Pour le dire quantitativement, votre globe a un maximum de 16 pousses (voir l'image ci-dessus). Un «objet» à la surface du globe (donné par un angle en radians) contiendra une «puissance conductrice», c'est-à-dire la quantité de faisceaux qu'il attire. Ainsi, un objet d'une puissance de 5 attirera 5 faisceaux (une seule ligne avec une épaisseur de 5), laissant 11 se répartir uniformément sur le reste du globe :

Notez que
1. le cercle noir au milieu reste au-dessus du plasma
2. que dans cet exemple, l'angle serait pi / 2.

Vous pouvez avoir plus d'un objet conducteur, et dans ce cas, il n'est pas nécessaire que les pousses soient également espacées. Cependant, ils doivent être relativement espacés. Par exemple, cela est correct pour 2 objets, 1 à l'angle pi / 4 puissance 5 et un autre à l'angle 5pi / 3 puissance 3:

Vous devriez pouvoir voir chacun des points d'extrémité des pousses (de plasma).

Cependant, étant donné un objet (ou une somme d'objets) avec une puissance supérieure à 16, le globe "se brisera":

Remarques

• Le diamètre du globe est 1,5 fois plus grand que la longueur de la base, qui est un carré
• Lorsque le globe se brise, le globe est sur le côté droit. Il est tangent au côté droit de la base ainsi qu'au sol. Il ne devrait pas y avoir de plasma lorsque le globe de plasma est cassé (pourquoi? Caractéristiques de sécurité bien sûr! Aucun mot sur la façon dont il s'est cassé en premier lieu.)
• La couleur de tout sauf les pousses doit être noire et d'une épaisseur de 1 pixel. La couleur du plasma a une teinte 245 - 280, et une saturation / valeur 100. Utilisez ceci sous "HSV" si vous ne savez pas de quoi je parle.

Contribution

L'entrée peut se faire via STDIN / arguments de ligne de commande / quoi que ce soit ou via des arguments de fonction.

Il devrait y avoir 2 entrées - longueur de la base du globe plasma (inclure un axe si vous utilisez des graphiques vectoriels), et un tableau d'objets comme celui-ci:

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

Donc, pour aucun objet (voir la première image avec 16 lignes), l'entrée serait

100,[]

Pour le suivant (un objet, puissance 5) ce serait:

100,[[1.570796,5]]

Pour le dernier exemple:

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

C'est le code-golf, donc le code le plus court en octets l' emporte.

Traitement de 2 à 717 caractères

Comme le traitement est un langage fait pour les artistes et que je suis un programmeur très novice, je ne m'attends pas à réussir très bien sur plusieurs de ces défis. Cela étant dit, j'aime vraiment à quel point il est simple de dessiner des choses dans le traitement, et j'ai voulu jouer encore avec, donc ces défis devraient être intéressants.

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

Je suis sûr que cela peut être considérablement minimisé et je peux essayer de le faire quand j'aurai plus de temps, mais pour l'instant j'en suis satisfait.

lit dans un fichier (f.txt) situé dans le dossier de données de l'esquisse pour obtenir son entrée. J'ai utilisé l'idée de Camerons de déplacer les faisceaux libres jusqu'à ce qu'ils ne se chevauchent pas.

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

Exemples:

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

100, []

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

obtenez le traitement ici

Python, 878 caractères

Ce n'est pas du tout bien joué au golf, mais je voulais voir une réponse pour ce trou.

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

Et quelques exemples de sorties

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

Il lit ses paramètres à partir de l'argument de ligne de commande.

Exemples d'images:

(paramètres = 100,[[0.785398,5],[5.23598,3]])

(paramètres = 100,[])

(paramètres = 100,[[1.72398,12],[5.23598,5]])