Hintergrundgeschichte

^{Haftungsausschluss: Kann erfundene Informationen über Kängurus enthalten.}

Kängurus durchlaufen mehrere Entwicklungsstufen. Je älter und stärker sie werden, desto höher und länger können sie springen, und desto öfter können sie springen, bevor sie hungrig werden.

In Stufe 1 ist das Känguru sehr klein und kann überhaupt nicht springen. Trotzdem bedarf es ständig der Ernährung. Wir können das Aktivitätsmuster eines Kängurus der Stufe 1 so darstellen.

o

In Stufe 2 kann das Känguru kleine Sprünge machen, aber nicht mehr als 2, bevor es hungrig wird. Wir können das Aktivitätsmuster eines Kängurus der Stufe 2 so darstellen.

 o o
o o o

Nach Stufe 2 bessert sich das Känguru schnell. In jeder weiteren Phase kann das Känguru etwas höher (1 Einheit in der grafischen Darstellung) und doppelt so oft springen. Das Aktivitätsmuster eines Kängurus der Stufe 3 sieht beispielsweise so aus.

  o   o   o   o
 o o o o o o o o
o   o   o   o   o

Für die Stufe n besteht das Aktivitätsmuster aus 2 ^n-1 V-förmigen Sprüngen der Höhe n .

Beispielsweise für die Stufe 4 gibt es 8 springt von der Höhe 4 .

   o     o     o     o     o     o     o     o
  o o   o o   o o   o o   o o   o o   o o   o o
 o   o o   o o   o o   o o   o o   o o   o o   o
o     o     o     o     o     o     o     o     o

Aufgabe

Schreiben Sie ein vollständiges Programm oder eine Funktion, die eine positive ganze Zahl n als Eingabe verwendet und die ASCII- Grafikdarstellung des Aktivitätsmusters eines Kängurus der Stufe n ausgibt oder zurückgibt .

Es sind umgebende Whitespace- und ANSI-Escape-Codes zulässig, sofern das Muster genau wie oben dargestellt aussieht.

Wenn Sie eine Funktion auswählen, die die Ausgabe zurückgibt, muss sie eine einzelne Zeichenfolge oder ein einzelnes Zeichenarray zurückgeben, das beim Drucken die richtige Ausgabe anzeigt. Das Zurückgeben eines Arrays von Zeichenfolgen ist nicht zulässig.

Sie können statt eines beliebigen druckbaren Nicht-Leerzeichens ein beliebiges Zeichen verwenden o, sofern es innerhalb des Aktivitätsmusters und über alle Muster in Ihrer Antwort hinweg konsistent ist.

Das ist Code-Golf ; möge die kürzeste Antwort in Bytes gewinnen!

05AB1E , 12 10 Bytes

Îj¹FÐvû},À

Erläuterung:

Î              # Push zero and input
 j             # Prepend input - 1 spaces
  ¹F           # Input times do..
    Ð          #   Triplicate the string
     v }       #   Length times do..
      û        #     Palindromize
        ,      #   Pop and print with a newline
         À     #   Rotate the string on to the right

Verwendet die CP-1252- Codierung. Probieren Sie es online!

MATLAB, 92 90 86 84 Bytes

n=input('');p=eye(n)+32;A=repmat([fliplr(p),p,''],1,2^n/2);A(:,n+1:n:end)=[];disp(A)

Probieren Sie es online!

eyeErstellt eine Identitätsmatrix. Wenn wir es umdrehen und das Original verketten, erhalten [fliplr(p),p]wir (für n=3):

0 0 1 1 0 0
0 1 0 0 1 0
1 0 0 0 0 1

Mit repmat(...,1,2^n/2)wiederholen wir dies 2^(n-1)mal und bekommen

0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0
0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 ...
1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1

Hiermit löschen wir nur die unnötigen Spalten mit A(:,n+1:n:end)=[];

Holzkohle , 14 Bytes

ＮλＰ^×λoＦ⁻λ¹‖Ｏ→

Probieren Sie es online!

Erläuterung

Ｎλgibt eine ganze Zahl in ein λ. Ｐ^ist ein multidirektionaler Ausdruck (SE und SW) von ×λo(String-Multiplikation von λmit o). Dann Ｆ⁻λ¹läuft eine for-Schleife λ - 1mal, in der sich ‖Ｏ→das Ganze rechts mit Überlappung widerspiegelt.

Python 2 , 87 Bytes

n=input()
for i in range(n):print''.join(' o'[abs(j%(2*n)-n)==i]for j in range(1,n<<n))

Probieren Sie es online!

Verwendet eine Formel für die Koordinaten (i,j), die einen Kreis enthalten. Anschließend wird das Raster verbunden und gedruckt. Hier riecht es nach Golf - ''.joinzwei verschachtelte Bereiche sind forvorbei exec, daher ist mit Verbesserungen zu rechnen.

Python 2, 83-81 Bytes

n=input()
i=0
exec"s=' '*n+'o'+' '*i;i+=1;print(s[i:-1]+s[:i:-1])*2**~-n+s[i];"*n

Probieren Sie es online!

Befunge, 98 91 Bytes

Dies verwendet ein ,anstelle von o, da dies uns ermöglicht, ein paar Bytes zu sparen.

&::1>\1-:v
+\:v^*2\<_$\1-2*::!+00p*1
:-1_@v0\-g01:%g00:-1<:\p01
 ,:^ >0g10g--*!3g,:#^_$\55+

Probieren Sie es online!

Erläuterung

Ausgehend von der Stufennummer n berechnen wir zunächst die folgenden drei Parameter des Musters:

jump_count = 2 ^ (n - 1)
jump_len   = (n - 1) * 2
width      = (jump_len * jump_count) + 1

Das jump_len wird normalisiert, um zu vermeiden, dass es für ein Känguru der Stufe 1 Null ist, mit:

jump_len += !jumplen    

Wir können dann das Sprungmuster ausgeben , indem wir über die x- und y- Koordinaten des Ausgabebereichs iterieren und das entsprechende Zeichen berechnen, das für jede Position ausgegeben werden soll. Die y- Koordinate zählt von n - 1 bis 0 herunter und die x- Koordinate zählt von der Breite - 1 bis 0 herunter . Wir bestimmen, ob ein Punkt mit der folgenden Formel angezeigt werden muss:

jump_off = x % jump_len
show_dot = (jump_off == y) or (jump_off == (jump_len-y))

Der Boolesche Wert show_dot wird als Tabellenindex verwendet, um das tatsächliche Zeichen zu bestimmen, das an jeder Position ausgegeben werden soll. Um Platz zu sparen, verwenden wir den Anfang der letzten Zeile der Quelle als diese Tabelle, weshalb unser oCharakter am Ende ein ist ,.

J , 28-25 Bytes

' o'{~]_&(](|.,}.)"1)=@i.

3 Bytes gespart dank @ Conor O'Brien .

Dies basiert auf dem Palindrom-Trick von @ muddyfishs Lösung .

Probieren Sie es online!

Erläuterung

' o'{~]_&(](|.,}.)"1)=@i.  Input: integer n
                       i.  Form the range [0, 1, ..., n-1]
                     =@    Equality table with itself.
                           Creates an identity matrix of order n
      ]                    Get n
       _&(          )      Repeat n times on x = identity matrix
           (     )"1         For each row
            |.                 Make a reversed copy
               }.              Get a copy with the head removed
              ,                Append them
          ]                  Use that as the new value of x
' o'{~                     Index into the char array

Pyke, 11 Bytes

XFd*\o+Q^Vs

Probieren Sie es hier aus!

 F          -  for i in range(input)
  d*\o+     -     " "*i+"o"
       Q^   -    ^.lpad(input)
         Vs -   repeat len(^): palindromise()
X           - print(reversed(^))

Haskell , 100 Bytes

k 1="o"
k n|n<-n-1,m<-n*2=unlines[[last$' ':['o'|mod c m`elem`[m-r,r]]|c<-[0..m*2^n]]|r<-[n,n-1..0]]

Probieren Sie es online! Verbrauch: k 3.

Erläuterung:

Bei einer gegebenen Zeile rwerden eine Spalte cund m = 2(n-1)ein ogesetzt, wenn c mod mgleich roder m-r. Das äußerste Listenverständnis legt den Bereich rvon n-1bis fest 0, das nächste den Bereich cvon 0bis m*2^(n-1)und das Innerste dient als bedingte Rückgabe, 'o'wenn die obige Formel erfüllt ist und ' 'ansonsten. Dies ergibt eine Liste von Strings, die in einen einzelnen, durch Newline getrennten String umgewandelt wird unlines. Denn n=1die Funktion erzeugt einen Division-durch-Null-Fehler, so dass dieser Fall in der ersten Zeile explizit behandelt wird.

C #, 180, 173 171 Bytes

Gewinnen Sie nicht dieses und bekanntgeben für andere C # Bewerber als etwas, das sie schlagen können.

n=>{var s=new string[n];for(int a=-1,j=0,i,m=n-1,x=m;j<=m*(Math.Pow(2,n)*n+1);){i=j++%n;s[i]+=x==i?"o":"_";if(i==m&n>1){x+=a;a*=x%m==0?-1:1;}}return string.Join("\n",s);};

komplettes Programm:

using System;
public class P
{
    public static void Main()
    {
        Func<int, string> _ = n =>
        {
            var s = new string[n];
            for (int a = -1, j = 0, i, m = n - 1, x = m; j <= m * (Math.Pow(2, n) * n + 1);)
            {
                i = j++ % n;
                s[i] += x‌​ == i ? "o" : "_";
                if (i == m & n > 1)
                {
                    x += a;
                    a *= x % m == 0 ? -1 : 1;
                }
            }
            return string.Join("\n", s);
        };

        Console.Write(_(4));
        Console.ReadKey();
    }
}

edit: -7 bytes dank @KevinCruijssen

edit: -2 bytes, vereinfacht wenn

Pyth , 30 Bytes

jC.<V*]+*dtQNh*tQ^2Q*+JUQtP_J^

Ein Programm, das die Eingabe einer Ganzzahl akzeptiert und das Ergebnis ausgibt. Verwendet ein Anführungszeichen "anstelle von o.

Probieren Sie es online!

Wie es funktioniert

jC.<V*]+*dtQNh*tQ^2Q*+JUQtP_J^    Program. Input: Q
jC.<V*]+*dtQNh*tQ^2Q*+JUQtP_J^QQ  Implicit input fill
      ]                           Yield a one-element list, A
        *dtQ                      cotaining Q-1 spaces
       +    N                     appended with a quote mark.
             h*tQ^2Q              Yield 1+(Q-1)*2^Q
     *                            Repeat A that many times, giving B
                       UQ         Yield [0, 1, 2, ..., Q-1]
                      J           (Store that in J)
                     +   tP_J     Append the reverse of J, discarding the first and last
                                  elements
                    *        ^QQ  Repeat the above Q^Q times, giving C
    V                             Vectorised map. For each pair [a,b] from B and C:
  .<                               Cyclically rotate a left by b characters
 C                                Transpose
j                                 Join on newlines
                                  Implicitly print

Python 2 , 115 113 108 98 Bytes

lambda n:'\n'.join(map(''.join,zip(*[' '*abs(i)+'o'+~-n*' 'for i in range(-n+1,n-1)*2**~-n])))+'o'

Probieren Sie es online!

Verwenden Sie range(-n+1,n-1), um die absolute Anzahl der Leerzeichen zwischen dem Boden und dem ozu generierenden zu erstellen

  o
 o
o
 o

und dann weitere Kopien anhängen, alles um 90º drehen und die letzte orechts unten anhängen

J , 58 47 Bytes

' o'{&:>~[:(,.}."1)&.>/(2^<:)#<@(|.,.}."1)@=@i.

Mit der Identitätsmatrix-Idee aus der @ flawr- Lösung wurden 11 Byte gespeichert .

Probieren Sie es online!

Eine einfache Anwendung der Definition.

Erläuterung

Für n = 3erstellt die Identitätsmatrix der Ordnung n .

1 0 0
0 1 0
0 0 1

Dann spiegel es zu machen

0 0 1 0 0
0 1 0 1 0
1 0 0 0 1

Wiederholen Sie dies 2 ^{n -1} Mal und lassen Sie den Kopf jeder Reihe auf den Duplikaten fallen

0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1

Verwenden Sie diese Werte als Indizes in das char-Array, [' ', 'o']um ein 2d char-Array auszugeben

  o   o   o   o  
 o o o o o o o o 
o   o   o   o   o

JavaScript (ES6), 83 Byte

f=
n=>` `.repeat(n).replace(/ /g,"$'o$`-$`o$'-".repeat(1<<n-1)+`
`).replace(/-.?/g,``)

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

Jelly , 11 Bytes

ŒḄ¡ḶUz1Ṛa⁶Y

TryItOnline!

Wie?

Das verwendete druckbare Zeichen ist 0 .

Baut auf der Methode von Dennis 'Antwort auf seine vorherige Frage zum Thema Kängurus auf.

ŒḄ¡ḶUz1Ṛa⁶Y - Main link: n                      e.g. 3
ŒḄ          - bounce, initial implicit range(n) e.g. [1,2,3,2,1]
  ¡         - repeat n times                    e.g. [1,2,3,2,1,2,3,2,1,2,3,2,1,2,3,2,1]
                  i.e. [1,2,3,2,1] bounced to [1,2,3,2,1,2,3,2,1] bounced to [1,2,3,2,1,2,3,2,1,2,3,2,1,2,3,2,1]
   Ḷ        - lowered range (vectorises)        e.g. [[0],[0,1],[0,1,2],[0,1],[0],[0,1],[0,1,2],[0,1],[0],[0,1],[0,1,2],[0,1],[0],[0,1],[0,1,2],[0,1],[0]]
    U       - upend (vectorises)                e.g. [[0],[1,0],[2,1,0],[1,0],[0],[1,0],[2,1,0],[1,0],[0],[1,0],[2,1,0],[1,0],[0],[1,0],[2,1,0],[1,0],[0]]
     z1     - transpose with filler 1
       Ṛ    - ...and reverse                    e.g. [[1,1,0,1,1,1,0,1,1,1,0,1,1,1,0,1,1],
                                                      [1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1],
                                                      [0,1,2,1,0,1,2,1,0,1,2,1,0,1,2,1,0]]
        a⁶  - logical and with space character (all non-zeros become spaces)
          Y - join with line feeds              e.g.    0   0   0   0  
                                                       0 0 0 0 0 0 0 0 
                                                      0   0   0   0   0

MATL, 27 Bytes

XyPt3LZ)2&Pht4LZ)lGqX"h48*c

Probieren Sie es bei MATL Online aus

Python 3 , 177 Bytes

n=5;f=n-1;w=''
for i in range(n):
 s='';a=0;d='\n'
 if i==f:w='';a=-1;d=''
 for _ in range(2**f):
  s+=' '*(f-i)+'o'+' '*(2*i-1)+w+' '*(n-i-2+a)
 print(s,end=d);w='o'
print('o')

Probieren Sie es online!

Perl 6 , 104 93 88 Bytes

->\n{my @a;@a[$_;$++]="o" for [...] |(n-1,0,n-1)xx 2**n/2;say .join for @a».&{$_//" "}}

Fügt os in ein 2D-Array ein und druckt es dann aus.

05AB1E , 16 Bytes

L<¹Fû}ð×'o«.BøR»

Probieren Sie es online!

Warum und wie?

                 # Example input of n=2.
L<               # [0,1] (Push [1..a], decrement).
  ¹Fû}           # [0,1,0,1,0] (Palindromize n times).
      ð×'o«      # ['o',' o','o',' o','o'] (Push n spaces, append o's).
           .Bø   # ['o ',' o','o ',' o','o '] (Pad with spaces into 2D array, transpose).
              R» # Reverse, join and print.

Java 8, 254 Bytes

Golf gespielt:

n->{if(n==1)return"o";int k,x,y,m=n+n-2;char[][]p=new char[n][m];for(y=0;y<n;++y)for(x=0;x<m;)p[y][x++]=' ';for(k=0;k<m;++k)p[k<n?n-k-1:k-n+1][k]='o';String s="";for(y=0;y<n;++y){for(k=0;k<1<<(n-1);++k)for(x=0;x<m;)s+=p[y][x++];if(y==n-1)s+='o';s+='\n';}

Ungolfed:

import java.util.function.*;

public class LeapingKangaroos {

  public static void main(final String[] args) {
    for (int i = 1; i <= 4; ++i) {
      System.out.println(toString(n -> {
        if (n == 1) {
          return "o";
        }
        int k, x, y, m = (n + n) - 2;
        char[][] p = new char[n][m];
        for (y = 0; y < n; ++y) {
          for (x = 0; x < m;) {
            p[y][x++] = ' ';
          }
        }
        for (k = 0; k < m; ++k) {
          p[k < n ? n - k - 1 : (k - n) + 1][k] = 'o';
        }
        String s = "";
        for (y = 0; y < n; ++y) {
          for (k = 0; k < (1 << (n - 1)); ++k) {
            for (x = 0; x < m;) {
              s += p[y][x++];
            }
          }
          if (y == (n - 1)) {
            s += 'o';
          }
          s += '\n';
        }
        return s;
      } , i));
      System.out.println();
      System.out.println();
    }
  }

  private static String toString(final IntFunction<String> func, final int level) {
    return func.apply(level);
  }

}

Programmausgabe:

o

 o o
o o o


  o   o   o   o 
 o o o o o o o o
o   o   o   o   o


   o     o     o     o     o     o     o     o  
  o o   o o   o o   o o   o o   o o   o o   o o 
 o   o o   o o   o o   o o   o o   o o   o o   o
o     o     o     o     o     o     o     o     o

PHP, 157 Bytes

for($i=$n=$argv[1],$r=str_repeat;$i>0;)echo$r($r(' ',$i-1).'o'.$r(' ',2*$n-2*$i-1).($i==$n|$i==1?'':'o').$r(' ',$i-2),2**($n-1)).($i--==1&$n!=1?'o':'')."\n";

Ungolfed:

for($i=$n=$argv[1];$i>0;) {

    // Spacing from beginning of pattern to first 'o'   
    $o  = str_repeat(' ',$i-1); 

    // First 'o' for the ascent
    $o .= 'o'; 

    // Spacing between ascent and descent
    $o .= str_repeat(' ',2*$n-2*$i-1); 

    // Second 'o' for the descent, unless we are at the apex or the bottom
    $o .= ($i==$n|$i==1?'':'o'); 

    // Spacing to the end of the pattern
    $o .= str_repeat(' ',$i-2); 

    // Repeat the pattern 2^(n-1) times
    echo str_repeat($o, 2**($n-1)); 

    // Output final 'o' if we are at the bottom in the last pattern
    echo $i--==1&$n!=1?'o':''; 

    // End of line 
    echo "\n"; 

}