História de fundo

^{Isenção de responsabilidade: Pode conter informações inventadas sobre cangurus.}

Os cangurus atravessam vários estágios de desenvolvimento. À medida que envelhecem e são mais fortes, eles podem pular mais e mais e pular mais vezes antes de ficarem com fome.

No estágio 1 , o canguru é muito pequeno e não pode pular. Apesar disso, é constantemente requer nutrição. Podemos representar um padrão de atividade de um canguru no estágio 1 como este.

o

No estágio 2 , o canguru pode fazer pequenos saltos, mas não mais do que 2 antes de ficar com fome. Podemos representar o padrão de atividade de um canguru no estágio 2 como este.

 o o
o o o

Após o estágio 2, o canguru melhora rapidamente. Em cada estágio subsequente, o canguru pode pular um pouco mais alto (1 unidade na representação gráfica) e duas vezes mais. Por exemplo, o padrão de atividade de um canguru do estágio 3 se parece com isso.

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

Para o estágio n , o padrão de atividade consiste em 2 saltos em forma de V ^n-1 de altura n .

Por exemplo, para o estágio 4 , existem 8 saltos de altura 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

Tarefa

Escrever um programa completo ou uma função que leva um número inteiro positivo n como entrada e devolve a impressão ou representação ASCII arte de uma fase n padrão de actividade de canguru.

O espaço em branco circundante e os códigos de escape ANSI são permitidos, desde que o padrão pareça exatamente como representado acima.

Se você escolher uma função que retorne a saída, ela deverá retornar uma única sequência de caracteres ou matriz de caracteres que exiba a saída adequada quando impressa. Retornar uma matriz de seqüências de caracteres não é permitido.

Você pode usar qualquer caractere que não seja espaço em branco imprimível em vez de o, desde que seja consistente no padrão de atividade e em todos os padrões da sua resposta.

Isso é código-golfe ; que a resposta mais curta em bytes ganhe!

05AB1E , 12 10 bytes

Îj¹FÐvû},À

Explicação:

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

Usa a codificação CP-1252 . Experimente 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)

Experimente online!

eyecria uma matriz de identidade. Se virarmos e concatenarmos o original, ou seja [fliplr(p),p], obtemos (para n=3):

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

Com repmat(...,1,2^n/2)repetimos esse 2^(n-1)tempo e obtemos

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

A partir disso, apenas excluímos as colunas desnecessárias, com A(:,n+1:n:end)=[];

Carvão , 14 bytes

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

Experimente online!

Explicação

Ｎλinsere um número inteiro em λ. Ｐ^é uma impressão multidirecional (SE e SW) de ×λo(multiplicação de cadeia de caracteres λcom o). Em seguida, Ｆ⁻λ¹executa um loop for for λ - 1, no qual ‖Ｏ→reflete a coisa toda à direita com sobreposição.

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

Experimente online!

Usa uma fórmula para as coordenadas (i,j)que contêm um círculo, depois se junta e imprime a grade. Há muito cheiro de golfe aqui - ''.join, duas faixas aninhadas, formais exec, portanto é provável que haja melhorias.

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

Experimente online!

Befunge, 98 91 bytes

Isso usa um ,no lugar do o, pois isso nos permite salvar alguns bytes.

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

Experimente online!

Explicação

Dado o número do estágio, n , começamos calculando os três parâmetros a seguir do padrão:

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

O jump_len é normalizado para evitar zero em um canguru de estágio 1 com:

jump_len += !jumplen    

Podemos, então, a saída do padrão de salto por iteração sobre o x e y coordenadas da área de saída, e cálculo do charater apropriado para a saída para cada local. A coordenada y é decrescente de n - 1 a 0, e a coordenada x faz uma contagem regressiva da largura - 1 a 0. Determinamos se um ponto precisa ser mostrado com a seguinte fórmula:

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

O show_dot boolean é usado como um índice de tabela para determinar o caractere real a ser produzido em cada local. Para economizar espaço, usamos o início da última linha de origem como essa tabela, e é por isso que nosso opersonagem acaba sendo a ,.

J , 28 25 bytes

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

Economizou 3 bytes graças a @ Conor O'Brien .

Isso é baseado no truque palíndromo da solução da @ muddyfish .

Experimente online!

Explicação

' 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

Experimente aqui!

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

Experimente online! Uso: k 3.

Explicação:

Dada uma linha r, uma coluna ce m = 2(n-1)um osão definidos se forem c mod miguais rou m-r. A compreensão da lista mais externa define a gama de rpartir n-1para 0os próximos um conjuntos a gama de cpartir 0para m*2^(n-1)ea mais interna atua como condicional retornar 'o'se a fórmula acima é cumprido e ' 'de outra forma. Isso gera uma lista de seqüências de caracteres que é transformada em uma única nova linha separada por unlines. Como n=1a função produz um erro de divisão por zero, esse caso é tratado explicitamente na primeira linha.

C #, 180, 173 171 bytes

Não vai ganhar isso, postando para outros competidores em C # como algo que eles podem vencer.

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

programa completo:

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 graças a @KevinCruijssen

editar: -2 bytes, simplificado se

Pitão , 30 bytes

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

Um programa que recebe a entrada de um número inteiro e imprime o resultado. Usa aspas em "vez de o.

Experimente online!

Como funciona

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'

Experimente online!

Usando range(-n+1,n-1)para criar o número absoluto de espaços entre a parte inferior e a opara gerar

  o
 o
o
 o

e depois anexando mais cópias, girando 90º tudo e acrescentando a última ono canto inferior direito

J , 58 47 bytes

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

Economizou 11 bytes usando a idéia da matriz de identidade da solução da @ flawr .

Experimente online!

Uma aplicação direta da definição.

Explicação

Para n = 3, cria a matriz de identidade da ordem n .

1 0 0
0 1 0
0 0 1

Então espelhe para fazer

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

Repita isso 2 ^{n -1} vezes e solte a cabeça de cada linha nas duplicatas

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 esses valores como índices na matriz de caracteres [' ', 'o']para gerar uma matriz de caracteres 2D

  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>

Gelatina , 11 bytes

ŒḄ¡ḶUz1Ṛa⁶Y

TryItOnline!

Quão?

O caractere imprimível usado é 0.

Baseia-se no método da resposta de Dennis à sua pergunta anterior sobre o assunto de cangurus.

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

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

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

Insere oem uma matriz 2D e depois imprime.

05AB1E , 16 bytes

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

Experimente online!

Porquê e como?

                 # 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

Golfe:

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

}

Saída do programa:

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

}