Code Golf: Bienenstock

Question

Die Herausforderung

Der kürzeste Code nach Zeichenzahl, der aus Benutzereingaben einen Bienenstock erzeugt.

Ein Bienenstock ist definiert als ein Gitter aus Sechsecken in einer Größe, die vom Benutzer als zwei positive Zahlen größer als Null eingegeben wird (eine Überprüfung der Eingabe ist nicht erforderlich). Die erste Zahl ( W ) stellt die Breite des Bienenstocks dar - oder - wie viele Sechsecke sich in jeder Reihe befinden. Die zweite Zahl ( H ) stellt die Höhe des Bienenstocks dar - oder - wie viele Sechsecke sich auf jeder Spalte befinden.

Ein einzelnes Sechseck wird aus drei ASCII-Zeichen gebildet: _ , / et \ und drei Zeilen:

 __
/  \
\__/

Die Sechsecke vervollständigen sich gegenseitig: Die erste Spalte des Bienenstocks ist "niedrig", die zweite "hoch" - abwechselnd und in demselben Muster, das W Sechsecke bildet. Dies wird H Mal wiederholt, um insgesamt WxH Sechsecke zu bilden.

Testfälle:

Input:
    1 1
Output:
     __
    /  \
    \__/

---

Input:
    4 2
Output:
        __    __
     __/  \__/  \
    /  \__/  \__/
    \__/  \__/  \
    /  \__/  \__/
    \__/  \__/

---

Input:
    2 5
Output:
        __ 
     __/  \
    /  \__/
    \__/  \
    /  \__/
    \__/  \
    /  \__/
    \__/  \
    /  \__/
    \__/  \
    /  \__/
    \__/

---

Input:
    11 3
Output:
        __    __    __    __    __
     __/  \__/  \__/  \__/  \__/  \__
    /  \__/  \__/  \__/  \__/  \__/  \
    \__/  \__/  \__/  \__/  \__/  \__/
    /  \__/  \__/  \__/  \__/  \__/  \
    \__/  \__/  \__/  \__/  \__/  \__/
    /  \__/  \__/  \__/  \__/  \__/  \
    \__/  \__/  \__/  \__/  \__/  \__/

---

Die Anzahl der Codes umfasst die Ein- und Ausgabe (d. h. das gesamte Programm).

Answer 1

C#, 216 Zeichen

class B{static void Main(string[]a){int b=0,i=0,w=int.Parse(a[0])+1,z=2*w*(int.Parse(a[1])+1);for(;i<z;b=(i%w+i/w)%2)System.Console.Write("\\/ "[i>w&(w%2>0?i<z-1:i!=2*w-1)?b>0?0:1:2]+(++i%w<1?"\n":b>0?"__":"  "));}}

Weniger verschleiert:

class B{
    static void Main(string[]a){
       int b=0,
           i=0,
           w=int.Parse(a[0])+1,
           z=2*w*(int.Parse(a[1])+1);

       for(;i<z;b=(i%w+i/w)%2)
           System.Console.Write(
             "\\/ "[i>w&(w%2>0?i<z-1:i!=2*w-1)?b>0?0:1:2]
             +
             (++i%w<1?"\n":b>0?"__":"  ")
           );
    }
}

Ich habe die folgende Methode verwendet:

input: 4 2
cols:  0 00 1 11 2 22 3 33 4 44     
row 0:" |  | |__| |  | |__| |"
    1:" |__|/|  |\|__|/|  |\|"
    2:"/|  |\|__|/|  |\|__|/|"
    3:"\|__|/|  |\|__|/|  |\|"
    4:"/|  |\|__|/|  |\|__|/|"
    5:"\|__|/|  |\|__|/|  | |"

1. Iterieren Sie von Null bis (W+1)*(H*2+1). Das *2 steht dafür, dass jeder Kamm 2 Zeilen hoch ist, und +1, um die erste Zeile und das Zeilenende zu berücksichtigen.
2. Rendern von zwei "Teilen" eines Sechsecks pro Iteration:
3. Entscheiden Sie sich zwischen " ", "\", und "/" für den ersten Teil
4. Entscheiden Sie sich zwischen "__", " ", und " \n " für den zweiten Teil

Das Muster wird deutlich, wenn man sich eine ausreichend große Wabe ansieht. Die Hälfte der Logik ist nur dazu da, Ausnahmen in der ersten Reihe, am Ende der zweiten Reihe und in der letzten Zelle zu behandeln.

Answer 2

Rubin, 164

$ ruby -a -p bh.rb

strager Meisterwerk in Ruby...

w,h = $F; w=w.to_i
(1..(h = h.to_i * 2 + 2)).each { |y|        
  (0...(w * 3 + (y != ((w & 1) != 0 ? 2 : h) ? 1:0))).each { |x|
    $> << ('_ \__/  ' [
      y - 1 != 0 ?
        (y - 2 | x) != 0 ?
          (x + y % 2 * 3) % 6 + 2 : 1 : (x % 6 < 4) ? 1:0]).chr
  }
  $> << $/
}

alias

w,h=$F;w=w.to_i
(1..(h=h.to_i*2+2)).each{|y|(0...(w*3+(y!=((w&1)!=0?2:h)?1:0))).each{|x|$><<('_ \__/  '[y-1!=0?(y-2|x)!=0?(x+y%2*3)%6+2:1:(x%6<4)?1:0]).chr}
$><<$/}

Answer 3

NewLisp: 257 Zeichen

Ich bin sicher, dass dies keine optimale Lösung ist:

(silent(define(i v)(println)(set v(int(read-line))))(i'w)(i'h)(set't(+(* 3 w)1))(set'l " __/ \\__/ ")(define(p s e(b 0))(println(slice(append(dup" "b)(dup(s 6 l)w))0 e)))(p 0 t)(p 4(- t(% w 2))1)(dotimes(n(- h 1))(p 6 t)(p 9 t))(p 6 t)(p 9(- t(%(+ w 1)2))))

Weniger verschleiert:

(silent
  (define (i v)
          (println)
          (set v (int (read-line))))
  (i 'w)
  (i 'h)
  (set 't (+ (* 3 w) 1))
  (set 'l "    __/  \\__/  ")
  (define (p s e (b 0))
          (println (slice (append (dup " " b) (dup (s 6 l) w)) 0 e)))
  (p 0 t)
  (p 4 (- t (% w 2)) 1)
  (dotimes (n (- h 1))
    (p 6 t)
    (p 9 t))
  (p 6 t)
  (p 9 (- t(% (+ w 1)2))))

Ich bin mir sicher, dass ich die Schleife auch anders schreiben und so zwei Zeilen und ein paar Zeichen einsparen könnte, aber es ist schon spät...

Answer 4

Golfscript, 88 Zeichen

Auf der Grundlage der mobrule die Lösung. Es war eine Menge Arbeit, sie kleiner zu machen als diese! Die Zeilenumbrüche dienen nur der Übersichtlichkeit.

~:r;:c 3*):W 6/"    __"*n
[][0]r[3 6]*+{[" ""__/  \\"99*+>W<]+.},;
c 2%-1 1if:r%)[-1<]+r%
n*

Erläuterung:

~:r;,:c              # read input into rows, columns
3 *):W               # store c*3+1 into W
6 /"    __"*n        # write out "    __" W/6 times, plus newline
[]                   # initialize output array
[0]r[3 6]*+          # create array [0] + [3,6] repeated r times
{                    # for every entry in the input array...
[" ""__/  \\"99*+    #   create the magic string
>W<                  #   truncate it between [n:W], where n is the cur entry
]+                   #   store this line in the output array
.},;                 # repeat for every entry in array
                     # now to handle the extra cases:
c 2%-1 1if:r%        # reverse the array if c is odd, do nothing if it's even
)[-1<]               # take the last entry in the array, cut off the last char
+r%                  # put it back on the array, and un-reverse it
n*                   # now join the array with newlines

---

Hier ist mein ursprünglicher Eintrag unter 118 Zeichen :

Später Eintrag, aber es ist der 2. kleinste! (Ich benutze sie nur, um Golfscript zu lernen). Die Zeilenumbrüche dienen der Übersichtlichkeit.

~:r;:c 2%:o;c 2/:b"    __"*n:e
{e" ""\\"if"__/  \\"b*o{"__"e{"":e}"/"if}{"":e}if n
"/""  \\__/"b*o"  \\"""if n}r*
"\\__/  "b o+*

Answer 5

C89 - 261 notwendige Zeichen

Alle Leerzeichen können entfernt werden. Meine Lösung nutzt die Rotation der Tafel...

x,y,W,h,B[999],*a,*b,*c,*d;
main(w){
  for(scanf("%d%d",&h,&w);y<h;y++,*b++ = *c++ = 63)
    for(x=0,
        W=w*2+2-(h==1),
        a=B+y*W*3+y%2,
        b=a+W,
        c=b+W,
        d=c+W;x++<w;)

      *a++ = 60,
      *a++ = *d++ = 15,
      *b++ = *c++ = 63,
      *b++ = *c++ = 0,
      *d++ = 60;

  for(x=W;--x>=0;puts(""))
    for(y=0;y<h*3+1;putchar(B[x+y++*W]+32));
}