Es gab bereits eine 9-Loch-Challenge (und eine andere hier ), aber das war letztes Jahr soooo. Und außerdem bin ich erst seit 2 Monaten dort (obwohl es wie für immer scheint). Und das ist ganz anders.

Leader Board: (Bitte beachten Sie, dass die Gewichtung der Löcher noch nicht festgelegt wurde.)

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

Andere Löcher:

• Loch 2
• Loch 3

In letzter Zeit ist es hier langsam geworden, also bin ich hier, um den nächsten 9-Loch-Golfplatz zu eröffnen, der ein bisschen von all dem beinhaltet, was ich hier in meiner (wenn auch begrenzten) Erfahrung gesehen habe. Dies beinhaltet:

• Ascii Art
• Grafische Ausgabe
• Conways Spiel des Lebens
• König des Hügels
• Kolmogorov Komplexität
• Quines
• Bildverarbeitung
• Mathematik
• Klassischer Code Golf.

Ich freue mich sehr darauf zu sehen, was Sie tun können!

Wettbewerbsregeln

• Sie wählen 1 Sprache für alle Löcher (an denen Sie teilnehmen ... siehe Punkt 4 für weitere Informationen).
• Für alle Löcher - Standardlücken sind (noch) nicht lustig.
• Die nächste Herausforderung wird erscheinen, wenn ich sehe, dass genügend Einreichungen innerhalb eines angemessenen Zeitraums vorliegen. König des Hügels zum Beispiel wird länger dauern.
• Sie müssen nicht an allen Löchern teilnehmen. Wenn Sie ein Loch als besonders herausfordernd empfinden, keine Zeit dafür haben, erhalten Sie 2-mal so viele Punkte wie die niedrigste Punktzahl. Bitte nutzen Sie diese Regel nicht aus, indem Sie 1 Golfscript-Antwort mit 12 Zeichen hinterlassen und 24 als Punktzahl verwenden.

Wertung

• Ihre Punktzahl basiert auf dem Ergebnis der Punkte aus allen Löchern
• Niedrigste Punktzahl gewinnt (nach echtem Golf)
• Die Bestenliste wird oben auf dieser Seite platziert

Ich werde mein Möglichstes tun, um sicherzustellen, dass keine Fragen Duplikate sind, dass alle Fragen objektive Kriterien haben, gut geschrieben sind und dass sie im Kontext des gesamten Wettbewerbs (relativ) das gleiche Gewicht haben.

Bitte haben Sie jedoch etwas Geduld, wenn ich versage.

Und ohne weiteres die erste Herausforderung!

Der Plasma-Globus

Eine Plasmakugel ist jedermanns Lieblingsspielzeug:

Ihre Aufgabe ist es, einen zu zeichnen.

Sie müssen eine Basis zeichnen:

ein Globus:

Ein Tesla-Ding (?)

Und natürlich coole Plasmaaufnahmen:

Wenn Sie jedoch Ihre Hand in die Nähe einer Plasmakugel halten (oder eines leitfähigen Objekts, wie Wikipedia es mir sagt), wird das Plasma angezogen .

Ihr Globus sollte das widerspiegeln.

Um es quantitativ auszudrücken, Ihr Globus hat maximal 16 Triebe (siehe obiges Bild). Ein "Objekt" auf der Oberfläche des Globus (angegeben durch einen Winkel im Bogenmaß) enthält "leitende Kraft", dh die Menge der Strahlen, die es anzieht. Ein Objekt mit einer Potenz von 5 zieht also 5 Strahlen an (eine einzelne Linie mit einer Dicke von 5), sodass sich 11 Strahlen gleichmäßig auf dem gesamten Globus ausbreiten :

Beachten Sie, dass
1. der schwarze Kreis in der Mitte über dem Plasma bleibt
2. dass in diesem Beispiel der Winkel pi / 2 wäre.

Möglicherweise haben Sie mehr als ein leitfähiges Objekt, und in diesem Fall ist es nicht erforderlich, dass die Triebe gleich weit voneinander entfernt sind. Sie sind jedoch relativ weit voneinander entfernt. Zum Beispiel ist dies für 2 Objekte in Ordnung, 1 im Winkel pi / 4 Potenz 5 und ein anderes im Winkel 5pi / 3 Potenz 3:

Sie sollten in der Lage sein, jeden der Endpunkte der Triebe (des Plasmas) zu sehen.

Bei einem Objekt (oder einer Summe von Objekten) mit einer Stärke von mehr als 16 wird der Globus jedoch "zerbrechen":

Anmerkungen

• Der Durchmesser des Globus ist 1,5-mal größer als die Länge der Basis, die ein Quadrat ist
• Wenn der Globus zerbricht, befindet sich der Globus auf der rechten Seite. Es berührt sowohl die rechte Seite der Basis als auch den Boden. Es sollte kein Plasma geben, wenn die Plasmakugel zerbrochen ist (warum? Sicherheitsmerkmale natürlich! Kein Wort darüber, wie sie überhaupt zerbrochen ist.)
• Die Farbe von allem außer den Trieben muss schwarz und 1 Pixel dick sein. Die Farbe des Plasmas hat Farbton 245 - 280 und Sättigung / Wert 100. Verwenden Sie diese Option unter "HSV", wenn Sie keine Ahnung haben, wovon ich spreche.

Eingang

Die Eingabe kann über STDIN / Befehlszeilenargumente / whatever oder über Funktionsargumente erfolgen.

Es sollten 2 Eingänge vorhanden sein - Länge der Basis der Plasmakugel (einschließlich einer Achse bei Verwendung von Vektorgrafiken) und eine Reihe von Objekten wie das folgende:

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

Also für keine Objekte (siehe erstes Bild mit 16 Zeilen) wäre die Eingabe

100,[]

Für das nächste (ein Objekt, Potenz 5) wäre es:

100,[[1.570796,5]]

Für das letzte Beispiel:

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

Das ist Code-Golf, also gewinnt der kürzeste Code in Bytes .

Verarbeitung 2 - 717 Zeichen

Da die Verarbeitung eine für Künstler entwickelte Sprache ist und ich ein sehr unerfahrener Programmierer bin, erwarte ich, dass ich bei vielen dieser Herausforderungen nicht sehr gut abschneide. Abgesehen davon gefällt mir sehr, wie einfach es ist, Dinge in der Verarbeitung zu zeichnen, und ich wollte noch ein bisschen mehr damit herumspielen, daher sollten diese Herausforderungen interessant sein.

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

Ich bin mir sicher, dass man hier erheblich Golf spielen kann, und ich kann versuchen, das zu tun, wenn ich mehr Zeit habe, aber im Moment bin ich damit zufrieden.

Liest eine Datei (f.txt) ein, die sich im Datenordner der Skizze befindet, um ihre Eingabe zu erhalten. Ich habe Camerons Idee benutzt, die freien Strahlen zu verschieben, bis sie sich nicht mehr überlappen.

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

Beispiele:

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

100,[]

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

erhalten die Verarbeitung hier

Python, 878 Zeichen

Auf keinen Fall ist das gut gelungen, aber ich wollte eine Antwort für dieses Loch sehen.

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

Und einige Beispielausgaben

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

Es liest seine Parameter aus dem Kommandozeilenargument.

Beispielbilder:

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

(parameters = 100,[])

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