Hintergrund

Heute (oder gestern) ist (oder war) der 23.11. Oder der Fibonacci-Tag! Was gibt es Schöneres, als einen Fibonacci-Kuchen zuzubereiten?

Beispiele

3

    ii
i_i_ii_i_i 

8

              ii              
              ii              
              ii              
              ii              
              ii              
              ii              
              ii              
              ii              
            i ii i            
            i ii i            
            i ii i            
            i ii i            
            i ii i            
          i i ii i i          
          i i ii i i          
          i i ii i i          
        i i i ii i i i        
        i i i ii i i i        
      i i i i ii i i i i      
    i i i i i ii i i i i i    
i_i_i_i_i_i_i_ii_i_i_i_i_i_i_i

Herausforderung

^{Du machst nicht wirklich einen Kuchen, nur die Kerzen, weil ich keinen Kuchen zubereiten kann}

Um den Kuchen zuzubereiten, müssen Sie zuerst die ersten n Fibonacci-Zahlen aufsteigend sortieren. Die Höhe der Kerze ( i) wird durch den Wert der aktuellen Fibonacci-Zahl bestimmt. Die Kerzen sind durch einen Unterstrich ( _) getrennt.

Der Kuchen sollte symmetrisch sein. So sollten die Kerzen dann gekippt und verkettet werden.

Beispielkonstruktion

Input: 6
First 6 Fibonacci Numbers: 1, 1, 2, 3, 5, 8
Candle heights:

          i
          i
          i
        i i
        i i
      i i i
    i i i i
i i i i i i
-----------
1 1 2 3 5 8

Output would be:
          ii
          ii
          ii
        i ii i
        i ii i
      i i ii i i
    i i i ii i i i
i_i_i_i_i_ii_i_i_i_i_i 

Referenz Fibonacci-Nummern

Als Referenz sind hier die ersten 15 Fibonacci-Zahlen. In dieser Herausforderung fängst du an 1.

1,1,2,3,5,8,13,21,34,55,89,144,233,377,610

Pyth, 31 Bytes

jaPJ_.ts_BuaaGks>4GtQ]\idXeJ" _

Probieren Sie es online aus: Demonstration

Erläuterung:

jaPJ_.ts_BuaaGks>4GtQ]\idXeJ" _   implicit: Q = input number
          u        tQ]\i          reduce the list [1, ..., Q-2], start with G=["i"]
            aGk                      append the empty string to G
           a   s>4G                  append the sum of the last 4 strings in G to G
                                  this gives ["i", "", "i", "", "ii", "", "iii",..]
       s_B                        extend the list with the reversed list
     .t                  d        pad to a rectangle with spaces and transposes
   J_                             reverse the order and assign to J
  PJ                              remove the last string of J
 a                                and append
                         XeJ" _   the last string of J with spaces replaced by "_"
j                                 print each string on a separate line

J, 58 Bytes

3 :''' i_''{~|.|:(,|.)(#&1,2#~0&=)"*}.,0,.(%-.-*:)t.1+i.y'

Verwendet (%-.-*:)t.für die Fibonacci-Generation. Erklärung kann etwas später kommen.

Verwendung:

   f=.3 :''' i_''{~|.|:(,|.)(#&1,2#~0&=)"*}.,0,.(%-.-*:)t.1+i.y'
   f 5
        ii        
        ii        
      i ii i      
    i i ii i i    
i_i_i_i_ii_i_i_i_i

Probieren Sie es hier online aus.

CJam, 41 39 Bytes

"i""_"1$ri({1$1$4$+}*]),f{Se[}W<_W%+zN*

Dies druckt eine ganze Menge führender Leerzeichen. Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

"i""_"1$ e# Push "i", "_", and a copy of "i".
ri(      e# Read an integer from STDIN and subtract 1.
{        e# Do that many times:
  1$     e#   Copy the last underscore.
  1$4$+  e#   Copy the last strings of i's and concatenate them.
}*       e#
]),      e# Wrap the results in an array, pop the last string, and get its length.
f{       e# For each remaining string, push the string and the length; then:
  Se[    e#   Pad the string to that length by prepending spaces.
}
W<       e# Remove the last string (underscore).
         e# We have now generated the columns of the left half of the output.
_W%+     e# Append a reversed copy (columns of right half).
z        e# Transpose rows with columns.
N*       e# Separate the rows by linefeeds.

TeaScript, 93 84 76 + 1 = 77 Bytes

+1 Byte für "Eingaben sind Zahlen?" Kontrollkästchen

r×ß(p.R((w=F(x©-F(i¬©+"i"R(F(i¬±)t¡ß(j=i<w-1?" ":"_",(A=l¿i>0?j+l:l)µ)+Av©j§

Ungolfed-Version:

r(x)m(#(p.R((w=F(x))-F(i+1))+"i"R(F(i+1))))t()m(#(j=i<w-1?" ":"_",(A=ls``.m(#i>0?j+l:l)j``)+Av))j`
`

Danke an @ Vɪʜᴀɴ für die Tipps.

Python 2, 117 Bytes

a=b='i'
l=a,
exec"l+='_',b,;a,b=b,b+a;"*~-input()
for r in map(None,*l+l[::-1])[::-1]:print''.join(x or' 'for x in r)

Die Idee ist einfach: Erzeugen Sie das Bild in Spalten von unten nach oben, von links nach rechts, wobei die gespiegelte rechte Hälfte die Rückseite der linken ist. Die Spalten werden durch Iteration der Fibonacci-Wiederholung auf Zeichenfolgen von erzeugt i, die mit durchsetzt sind_ ' s für die unterste Zeile durchsetzt sind.

Um das Bild mit Spalten zu drucken, die von unten beginnen, müssen wir es drehen, dh transponieren und umkehren. Leider gibt es in Python keine einfache Möglichkeit, ein Array von Zeilen ungleicher Länge zu transponieren. Die eingebaute zipschneidet auf die kürzeste Zeile ab. Dies nutzt den map(None,_)Trick, muss aber Nonedanach alle in Leerzeichen konvertieren .

Haskell, 182 176 Bytes

import Data.List
f=0:scanl(+)1f
b n c s|length s<n=b n c(c:s)|0<1=s
m s=s++reverse s
c n=mapM_ putStrLn$transpose$m$map(b(f!!n)' ')$intersperse"_"$map(\x->[1..f!!x]>>"i")[1..n]

Rufen Sie an c.

( fSchamlos gestohlen von /programming/232861/fibonacci-code-golf )

Matlab, 172 152 Bytes

Leider hat Matlab keine eingebaute Fibonacci-Funktion und die String-Manipulation ist etwas umständlich.

function t(n);f=@(n)getfield([0 1;1 1]^n,{3});m=char(flipud(bsxfun(@(a,b)(a<=f(b/2)&mod(b,2)==0)*'i',(1:f(n))',2:2*n)));m(end,2:2:end)='_';[m fliplr(m)]

Mit Zeilenumbrüchen:

function t(n);
f=@(n)getfield([0 1;1 1]^n,{3});
m=char(flipud(bsxfun(@(a,b)(a<=f(b/2)&mod(b,2)==0)*'i',(1:f(n))',2:2*n)));
m(end,2:2:end)='_';
[m fliplr(m)]

Ruby, 151 146 142 137 132 Bytes

->n{s=1,1;3.upto(n){s<<s[-1]+s[-2]};s.map!{|i|[' ']*(s[-1]-i)+[?i]*i}.transpose.map!{|a|v=a*'_ '[a.count(?i)<=>n];puts v+v.reverse}}

137 Bytes

->n{s=1,1;3.upto(n){s<<s[-1]+s[-2]};o=s.map{|i|[' ']*(s[-1]-i)+[?i]*i}.transpose.map{|a|v=a*' ';v+v.reverse};o[-1]=o[-1].tr' ',?_;puts o}

142 Bytes

->n{s=1,1;(3..n).map{s<<s[-1]+s[-2]};puts s.map{|i|[' ']*(s[-1]-i)+[?i]*i}.transpose.map{|a|v=a*' ';v+v.reverse}.tap{|c|c[-1]=c[-1].tr' ',?_}}

146 Bytes

->n{s=1,1;(3..n).map{s<<s[-1]+s[-2]};puts s.map{|i|[' ']*(s[-1]-i)+[?i]*i}.transpose.map{|a|v=a.join' ';v+v.reverse}.tap{|c|c[-1]=c[-1].tr' ',?_}}

151 Bytes

->n{s=1,1;(3..n).map{s<<s[-1]+s[-2]};puts s.map{|i|[' ']*(s[-1]-i)+['i']*i}.transpose.map{|a|v=a.join ' ';v+v.reverse}.tap{|c|c[-1]=c[-1].tr ' ', '_'}}

Ungolfed:

-> n {
  s = 1,1
  3.upto(n) {
    s << s[-1] + s[-2]
  }
  s.map! { |i|
    [' '] * (s[-1]-i) + [?i] * i
  }.
  transpose.
  map! { |a|
    v = a * '_ '[a.count(?i)<=>n]
    puts v + v.reverse
  }
}

Verwendung:

->n{s=1,1;3.upto(n){s<<s[-1]+s[-2]};s.map!{|i|[' ']*(s[-1]-i)+[?i]*i}.transpose.map!{|a|v=a*'_ '[a.count(?i)<=>n];puts v+v.reverse}}[8]

Ausgabe:

              ii              
              ii              
              ii              
              ii              
              ii              
              ii              
              ii              
              ii              
            i ii i            
            i ii i            
            i ii i            
            i ii i            
            i ii i            
          i i ii i i          
          i i ii i i          
          i i ii i i          
        i i i ii i i i        
        i i i ii i i i        
      i i i i ii i i i i      
    i i i i i ii i i i i i    
i_i_i_i_i_i_i_ii_i_i_i_i_i_i_i

Python 2, 213

Dank DSM 12 Byte eingespart.

def f(r):
 a=b=1
 while r:yield a;a,b=b,a+b;r-=1
n=list(f(input()))
n.remove(1)
h=max(n)-1
r=1
while h:
 l='  '*(len(n)+1)+('i '*r)[:-1];print(l+l[::-1]);h-=1
 if h in n:r+=1;n.pop()
l='i_'*r+'i_i'
print l+l[::-1]

Ungolfed-Version.

max_height = input()
def fib(r):
    a=b=1
    while r:
        yield a
        a,b = b, a + b
        r-=1

numbers = [x for x in fib(max_height) if x>1]
highest = max(numbers) -1
rows = 1
while highest:
    line =' '*((len(numbers)+1)*2) + ' '.join('i'*rows)
    print(line + line[::-1])
    highest -= 1
    if highest in numbers:
        rows += 1
        numbers.pop()

line = '_'.join('i'*(rows+2))
print(line + line[::-1])