backstory

^{Disclaimer: può contenere informazioni inventate sui canguri.}

I canguri attraversano diverse fasi di sviluppo. Man mano che invecchiano e diventano più forti, possono saltare sempre più in alto e possono saltare più volte prima di avere fame.

Nella fase 1 , il canguro è molto piccolo e non può saltare affatto. Nonostante ciò, è costantemente necessario nutrimento. Possiamo rappresentare un modello di attività del canguro di livello 1 come questo.

o

Nella fase 2 , il canguro può fare piccoli salti, ma non più di 2 prima di avere fame. Possiamo rappresentare un modello di attività del canguro di livello 2 come questo.

 o o
o o o

Dopo la fase 2 il canguro migliora rapidamente. In ogni fase successiva, il canguro può saltare un po 'più in alto (1 unità nella rappresentazione grafica) e due volte più volte. Ad esempio, il modello di attività di un canguro di livello 3 è simile al seguente.

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

Per la fase n , il modello di attività consiste in 2 ^n-1 salti a forma di V di altezza n .

Ad esempio, per la fase 4 , ci sono 8 salti di altezza 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

Compito

Scrivi un programma completo o una funzione che accetta un numero intero positivo n come input e stampa o restituisce la rappresentazione artistica ASCII del modello di attività di un canguro stage n .

Sono consentiti spazi bianchi circostanti e codici di escape ANSI, purché il motivo appaia esattamente come mostrato sopra.

Se si sceglie una funzione che restituisce l'output, deve restituire una singola stringa o matrice di caratteri che visualizza l'output corretto durante la stampa. La restituzione di una matrice di stringhe non è consentita.

È possibile utilizzare qualsiasi carattere stampabile, non di spazi bianchi anziché o, purché sia ​​coerente all'interno del modello di attività e in tutti i modelli nella risposta.

Questo è code-golf ; che vinca la risposta più breve in byte!

05AB1E , 12 10 byte

Îj¹FÐvû},À

Spiegazione:

Î              # 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

Utilizza la codifica CP-1252 . Provalo online!

MATLAB, 92 90 86 84 byte

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

Provalo online!

eyecrea una matrice di identità. Se lo capovolgiamo e concateniamo l'originale, ovvero [fliplr(p),p]otteniamo (per n=3):

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

Con repmat(...,1,2^n/2)ripetiamo questo 2^(n-1)tempo e otteniamo

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

Da questo eliminiamo solo le colonne non necessarie, con A(:,n+1:n:end)=[];

Carbone , 14 byte

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

Provalo online!

Spiegazione

Ｎλinserisce un numero intero in λ. Ｐ^è una stampa multidirezionale (SE e SW) di ×λo(moltiplicazione di stringhe di λcon o). Quindi Ｆ⁻λ¹esegue un ciclo per i λ - 1tempi, in cui ‖Ｏ→riflette il tutto a destra con sovrapposizione.

Python 2 , 87 byte

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

Provalo online!

Utilizza una formula per le coordinate (i,j)che contengono un cerchio, quindi unisce e stampa la griglia. C'è un sacco di odore di golf qui - ''.join, due gamme nidificate, foroltre exec, quindi probabilmente ci saranno miglioramenti.

Python 2, 83 81 byte

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

Provalo online!

Befunge, 98 91 byte

Questo utilizza un ,al posto di o, poiché ci consente di salvare un paio di byte.

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

Provalo online!

Spiegazione

Dato il numero di tappa, n , iniziamo calcolando i seguenti tre parametri del modello:

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

Il jump_len è normalizzato per evitare che sia zero per un canguro di livello 1 con:

jump_len += !jumplen    

Possiamo quindi emessi modello salto iterando il x ed y coordinate della zona di uscita, e calcolando il charater opportuno uscita per ogni posizione. La coordinata y conta alla rovescia da n - 1 a 0 e la coordinata x conta alla rovescia da larghezza - 1 a 0. Determiniamo se un punto deve essere mostrato con la seguente formula:

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

Il booleano show_dot viene utilizzato come indice di tabella per determinare il carattere effettivo da emettere in ciascuna posizione. Per risparmiare spazio, usiamo l'inizio dell'ultima riga del sorgente come quella tabella, motivo per cui il nostro opersonaggio finisce per essere a ,.

J , 28 25 byte

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

Salvato 3 byte grazie a @ Conor O'Brien .

Questo si basa sul trucco palindromo della soluzione di @ muddyfish .

Provalo online!

Spiegazione

' 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

Try it here!

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

Try it online! Usage: k 3.

Explanation:

Given a row r, a column c and m = 2(n-1) an o is set if c mod m equals r or m-r. The outermost list comprehension sets the range of r from n-1 to 0, the next one sets the range of c from 0 to m*2^(n-1) and the innermost acts as conditional returning 'o' if the above formula is fulfilled and ' ' otherwise. This yields a list of strings which is turned into a single newline separated string by unlines. For n=1 the function produces a division-by-zero error, so this case is handled explicitly in the first line.

C#, 180, 173 171 bytes

Wont win this, posting for other C# contestants as something they can beat.

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

complete program:

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 thanks to @KevinCruijssen

edit: -2 bytes, simplified if

Pyth, 30 bytes

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

A program that takes input of an integer and prints the result. Uses a quote mark " instead of o.

Try it online!

How it works

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'

Try it online!

Using range(-n+1,n-1) to create the absolute number of spaces between the bottom and the o to generate

  o
 o
o
 o

and then appending more copies, rotating 90º everything and appending the last o at bottom right

J, 58 47 bytes

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

Saved 11 bytes using the identity matrix idea from @flawr's solution.

Try it online!

A straightforward application of the definition.

Explanation

For n = 3, creates the identity matrix of order n.

1 0 0
0 1 0
0 0 1

Then mirror it to make

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

Repeat that 2^n-1 times and drop the head of each row on the duplicates

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

Use those values as indices into the char array [' ', 'o'] to output a 2d char array

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

JavaScript (ES6), 83 bytes

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!

How?

The printable character used is 0.

Builds upon the method of Dennis's answer to his previous question on the subject of kangaroos.

ŒḄ¡Ḷ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

Try it out at MATL Online

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

Provalo 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».&{$_//" "}}

Inserisce quello oin un array 2D, quindi lo stampa.

05AB1E , 16 byte

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

Provalo online!

Perché e come?

                 # 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 byte

golfed:

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

}

Uscita del programma:

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 byte

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"; 

}