Code Golf: ascii art stars zeichnen

Question

Da diese Woche noch niemand eine Code-Golf-Herausforderung gepostet hat, versuche ich es mal damit. Ich mache das, damit ihr während der langen Kompilierungszyklen etwas anderes tun könnt, als mit Schwertern zu spielen.

Die Herausforderung:

Zeichnen von ASCII-Sternen mit drei Zahlen auf der Standardeingabe (Anzahl der Zacken, Art des Sterns (der Stern wird gezeichnet, indem man Scheitelpunkte verbindet, die n Scheitelpunkte voneinander entfernt sind) und Durchmesser des Sterns). Beispiele:

Input:                        Input:                       Input:

5 2 20                        7 2 20                       7 3 20

Output:                       Output:                      Output:

             x                        x                        x
            xx                        xx                       x
            xx                       x  xx   xx                xx      x
           x x                       x   xxxx x                xx     xx
  xx      x  x                      xxxxx  x  x                x x  xxx
   xxxx   x  x                   xxxx       x x                x x x  x
   x   xxx   x                 xx  x         xx         xxx    x  x  x
    x   x xxxx                 x   x          xx         x xxxxx xx  x
     x  x    xxx                x x           x x         xx   xxxxxx
     x x     x  xxx             x x           x  x          x xx   xxxxxx
      x      x     xx            x            x   x          x x   x     xxx
     x x     x  xxx              x            x  x          x xx   xxxxxx
     x x     xxx                x x           x x         xx   xxxxxx
    x   x xxxx                  x x           xx         x xxxxx xx  x
   x   xxx   x                 xx  x         xx         xxx    x  x  x
   xxxx   x  x                   xxxx       x x                x x x  x
  xx      x  x                      xxxxx  x  x                x x  xxx
           x x                      x    xxxx x                xx     xx
            xx                       x  xx   xx                xx      x
            xx                       x x                       x
             x                        x                        x

Da die korrekte Rasterung der Linien für eine Code-Golf-Herausforderung eine PITA sein kann, werde ich etwas Spielraum lassen, aber nicht zu viel. Mehr Beispiele:

Das ist gut genug:

    x           x                   x       x
     xx       xx                    x       x
       x     x                       x     x
     x  xx xx  x                      x   x
          x                            x x
         x x                            x
      xxx   xxx                      x     x
      x       x               xxxxxxxxxxxxxxxxxxxxx
     x         x                xx    x   x    xx
   xx  x     x  xx                xx x     x xx
  x               x                 xxx   xxx
xxxxxxxxxxxxxxxxxxxxx                 xxxxx
        x   x                      x  xx xx  x
                                  x xx     xx x
                                 xxx         xxx
         x x                    xx     x x     xx

          x
                                        x

Das reicht nicht aus:

            x                  xx               xx
            xx                   x             x
            xx                    x           x
           x x                     xx       xx
 xx       x  x                       x     x
  xxxx   x   x                     x  xx xx  x
  x   xxxx   x                          x
   x    xxxx x                         x x
    x  x    xxx                     xxx   xxx
     xx      x xxxxxx               x       x
     xx      x xxxxxx              x         x
     xx     xxx                  xx  x     x  xx
    x  x xxx x                  x               x
    x xxx    x                xxxxxxxxxxxxxxxxxxxxx
   xxx  x    x                        x   x
 xx      x   x
          x  x
          x  x                         x x
           x x
            xx
                                        x

 Lack of precission              Lack of clipping

Viel Spaß!

Answer 1

Rubin - 323 276 304 297

a,b,c=gets.split.map &:to_i
o=(0..c).map{' '*c}
m=(1..a).map{|i|r=2*h=Math::PI*i/a
[(1+Math.sin(r))*c/2+0.5,(1+Math.cos(r))*c/2]}
a.times{|n|j,i,x,y=*m[n],*m[n-b]
j,x,i,y=i,y,j,x if k=((i-y)/(j-x))**2>1
s,z=[x,j].sort
s.to_i.upto(z){|m|t=i+(m-j)*(i-y)/(j-x)
k ?(o[t][m]='x'):(o[m][t]='x')}}
puts o

             x              xx                   x                      xx          
             x              x x                  x                      x x         
            xx              x  x    xx           xx       x            x   x        
           x x             x    xxxx x           xx      xx      xxxxxxxxxxxxxxxx   
 xxx      x  x             xxxxx xx  x           x x    xx       x   x       x  x   
  x xxx   x  x         xxxxx       x x    x      x x   x x       x  x         x x   
  x    xxx   x       xx   x         xx     xxxx  x  xxx x        x x           xx   
   x    x xxxx        x  x           x       x xxxxxx   x        xx             x   
    x  x     xxx      x  x           xxx      x  x xxxxx         x              xx  
     x x     x  xxx    xx            x  x      x xx  x xxxxx    xx              x x 
     xx      x     xx  xx            x   x      xx    x     xxxx x              x  x
     xx      x  xxx    xx            x  x      x xx   x xxxx    xx              x x 
     x x     xxx       xx            xxx      x  x xxxxx         x              xx  
    x  x  xxxx        x  x           x       x xxxxxxx x         xx             x   
   x   xxx   x       xx  x          xx     xxxx  x  xxx x        x x           xx   
  x xxx  x   x         xxxxx       x x    x      x  x  xx        x  x         x x   
 xxx      x  x            x xxxx xx  x           x x    xx       x   x       x  x   
          x  x             x    xxxx x           x x     x       xxxxxxxxxxxxxxxx   
           x x             x   x    xx           xx       x            x   x        
            xx              x x                  xx                     x x         
             x              xx                   x                       x

Answer 2

C# : 555 428 Zeichen

using System.Drawing;class P{static void Main(string[]a){int p=int.Parse(a[0]),i=int.Parse(a[1]),l=int.Parse(a[2]),n;var o=System.Console.Out;var b=new Bitmap(l*4/3,l*4/3);var g=Graphics.FromImage(b);g.TranslateTransform(l/8,l/3);for(n=0;n<p;n++){g.DrawLine(Pens.Red,0,0,l,0);g.TranslateTransform(l,0);g.RotateTransform(360*i/p);}for(i=0;i<b.Height;i++,o.WriteLine())for(p=0;p<b.Width;p++)o.Write(b.GetPixel(p,i).A>0?"#":" ");}}

Sterne 5 2 20

            #
           # #
           # #
           # #
          #   #
          #   #
  #####################
   ##    #     #    ##
     #   #     #   #
      #  #     #  #
       ##       ##
        ##     ##
        # #   # #
       #   ###   #
       #   # #   #
       # ##   ## #
      # #       # #
      ##         ##
      #           #

Answer 3

OCaml, 659 Zeichen (wc -c).

Verwendet den klassischen Bresenham-Algorithmus zum Zeichnen der Linien, der zum Spaß rekursiv ist. Speichern als stars.ml und laufen mit echo 5 2 20 | ocaml stars.ml .

let pl b x y=b.(x).[y]<-'x'
let ln b x0 y0 x1 y1 =
let rec h p x0 y0 x1 y1 =
if x0>x1 then h p x1 y1 x0 y0
else(
let dx,dy,ys=x1-x0,abs(y1-y0),if y0<y1 then 1 else -1 in
let rec k x y e=
if x<=x1 then(
p y x;
if e<dy then k(x+1)(y+ys)(e-dy+dx)
else k(x+1)y(e-dy)
)in
k x0 y0(dx/2)
)in
if abs(y1-y0)>abs(x1-x0)then
h(fun x y->pl b y x)y0 x0 y1 x1
else h(pl b)x0 y0 x1 y1
let f=float
let g n s d=
let b=Array.init d(fun _->String.make d ' ')in
let r=f(d/2)-.0.1 in
let k h i=int_of_float(r+.r*.h(6.2831853*.(f(i mod n)/.(f n))))in
let x,y=k cos,k sin in
for i=0 to n do ln b(x i)(y i)(x(i+s))(y(i+s))done;Array.iter print_endline b
let()=Scanf.scanf"%d %d %d"g

Ausgänge

            x                  x                       x
           xx                  xxx                     xx
           xx                 x   x   xxx              xx       x
          x x                 x  xxxxx  x              x x     x
 xx      x  x              xxxxxx   xx  x              x x   xxx
  xxxxx x   x           xxx  x        x x       xxx    x  x x x
  x    xxxx x           x   x          xx        xxxxxxx  xx  x
   x   x   xxx           x  x           xx         x   xxxxx x
    x x     x xxxx       x x            x x         x  xx  xxxxxx
     x      x     xx      xx            x  x         xxx    x    xxx
     x      x  xxx        x             x x          xxx    x xxxx
    x x     xxx           xx            xx          x  xx xxxx
   x   x xxxx            x x           xx          x  xxxxxx x
  x   xxx   x            x  x         x x        xxxxx x  xx  x
  xxxx  x   x           xxx x        x  x       xx     x  x x x
 xx      x  x              xxxxxx   x   x              x x   xxx
          x x                x   xxxxx  x              x x     x
           xx                 x  xx   xxx              xx       x
           xx                 x x                      xx
            x                  x                       x

Answer 4

Mein erster Versuch mit Code-Golf...

Python - 550 533 507 484 451 437 Zeichen

Speichern unter k.py . Laufen als python k.py 5 2 20

import sys,math as m
A=abs;R=range;X=round
p,t,w=map(int,sys.argv[1:])
G=[[' ']*-~w for i in R(w+1)]
def L(a,b,c,d):
 s=A(d-b)>A(c-a)
 if s:a,b,c,d=b,a,d,c
 if a>c:a,b,c,d=c,d,a,b
 f=c-a;e=f/2;y=int(X(b));x=int(X(a))
 while x<X(c):
  e-=A(d-b);p,q=((x,y),(y,x))[s];G[p][q]='x';x+=1
  if e<0:y+=(-1,1)[y<d];e+=f
r=w/2;k=m.pi*2/p
s=[(m.sin(k*i)*r+r,m.cos(k*i)*r+r)for i in R(p+t)]
for i in R(p):L(*(s[i]+s[i+t]))
for i in G:print''.join(i)

(Man kann möglicherweise 2 weitere Zeichen einsparen, indem man den Einzug der zweiten Ebene durch Tabulatoren ersetzt...)

Die erweiterte Version ist hier verfügbar: http://gist.github.com/591485

Beispielhafte Ausgabe:

             x                x                     x
            xx                xx                    x
            xx               x  xx    x             xx      x
           x x               x    xxxxx             xx     xx
  xx      x  x              x xxxx x  x             x x  xxx
   xxxx  x   x            xxxx      x x             x x x  x
   x   xxx   x         xxx x         xx      xxx    x  x  x
    x   x xxxx         x   x          xx      x xxxxx xx  x
     x x     xxx        x x           x x      xx   xxxxxx
      x      x  xxx     x x           x  x       x xx   xxxxx
      x      x     x     x            x           x x   xx   xxx
     x x     x  xxx      x            x  x       x xx   xxxxx
    x   x    xxx        x x           x x      xx   xxxx  x
    x    xxxxx          x x           xx      x xxxxx xx  x
   x   xxx   x         xxx x         xx      xxx    x xx   x
  x xxx   x  x            xxxx      x x             x x x  x
  xx       x x              x xxxx x  x             xx   xx x
           x x              x     xxxxx             xx     xx
            xx               x  xx                  x
             x               x x                    x
                              x

Answer 5

VBScript, 584 511 482 Bytes

Ich habe auch den Bresenham-Algorithmus für Linien verwendet.

g=Split(WScript.StdIn.ReadAll):t=g(1):d=g(2):ReDim r(d*d)
For i=0 To d*d:r(i)=" ":Next
c=1.57:u=(d-1)/2:b=c*4/g(0):For i=1 To g(0)
Z n:x=g:Z n+c:y=g:Z n-b*t:f=g:Z n-b*t+c:n=n+b
s=Abs(g-y)>Abs(f-x):If s Then W x,y:W f,g
If x>f Then W x,f:W y,g
p=f-x:q=Abs(g-y):h=p\2:v=(y>g)*2+1
For x=x To f:r((s+1)*(y*d+x)-s*(x*d+y))="x"
h=h-q:If h<0 Then y=y+v:h=h+p
Next:Next:For i=0 To d:WScript.Echo Mid(Join(r,""),i*d+1,d):Next
Sub W(a,b):e=a:a=b:b=e:End Sub
Sub Z(e):g=Int(u*Cos(e)+u):End Sub

Ausgabe:

            x               x                    x            
           xx               xx                   x            
           xx              x  xx  xxx            xx      x    
          x x              x  xxxx  x            xx     xx    
  xx     x  x            xxxxx   x  x            x x   xx     
   xxxx  x  x         xxx x       x x      xx    x x xx x     
   x   xxx  x         x  x         xx       xxxxxx  x  x      
    x  x  xxx          x x          xx       x   xxxx  x      
     x x    xxx        x x          x x       xx xx  xxx      
     xx     x  xxx      x           x  x        xx   xx xxxx  
     xx     x     xx    x           x   x       xx   xx    xxx
     x x    x xxxx     x x          x  x      xx xx  xxxxxx   
    x  x   xxx         x x          xxx      x   xxxxxxx      
   x    xxx x         x  x          x       x xxxx  x  x      
   xxxxx x  x         xxx x        xx      xxx   x x xx x     
  xx     x  x            xxxxx   xx x            x x   xx     
          x x              x  xxxx  x            xx     xx    
           xx              x   x  xxx            xx      x    
           xx               xxx                  x            
            x               x                    x            

Erweiterter Code:

Dim PI, args, output, i
PI = 4 * Atn(1)

args = Split(WScript.StdIn.ReadAll, " ")
output = Join(Star(args(0), args(1), args(2)), vbNullString)

For i = 1 To Len(output) Step args(2)
    WScript.Echo Mid(output, i, args(2))
Next

Function Star(spikes, star_type, diameter)
    Dim result(), i, vertexes(), angle, radius, p1, p2
    ReDim result(diameter * diameter - 1)
    ReDim vertexes(spikes - 1)

    For i = 0 To UBound(result)
        result(i) = " "
    Next

    radius = (diameter - 1) / 2
    For i = 0 To UBound(vertexes)
        vertexes(i) = Array(CLng(radius * Cos(angle) + radius), _
            CLng(radius * Sin(angle) + radius))
        angle = angle - (2 * PI / spikes)
    Next

    For i = 0 To UBound(vertexes)
        p1 = vertexes(i)
        p2 = vertexes((i + star_type) Mod spikes)
        DrawLine p1(0), p2(0), p1(1), p2(1), result, diameter
    Next

    Star = result
End Function

Sub DrawLine(ByVal x0, ByVal x1, ByVal y0, ByVal y1, arr, diameter)
    Dim steep, deltax, deltay, error, ystep

    steep = Abs(y1 - y0) > Abs(x1 - x0)
    If steep Then
        Swap x0, y0
        Swap x1, y1
    End If
    If x0 > x1 Then
        Swap x0, x1
        Swap y0, y1
    End If

    deltax = x1 - x0
    deltay = Abs(y1 - y0)
    error = deltax \ 2
    If y0 < y1 Then ystep = 1 Else ystep = -1

    For x0 = x0 To x1
        If steep Then
            arr(x0 * diameter + y0) = "x"
        Else
            arr(y0 * diameter + x0) = "x"
        End If
        error = error - deltay
        If error < 0 Then
            y0 = y0 + ystep
            error = error + deltax
        End If
    Next
End Sub

Function Swap(a, b)
    Dim temp
    temp = a
    a = b
    b = temp
End Function