Historia de fondo

^{Descargo de responsabilidad: puede contener información inventada sobre canguros.}

Los canguros atraviesan varias etapas de desarrollo. A medida que crecen y se fortalecen, pueden saltar más alto y más, y pueden saltar más veces antes de tener hambre.

En la etapa 1 , el canguro es muy pequeño y no puede saltar en absoluto. A pesar de esto, constantemente requiere alimentación. Podemos representar un patrón de actividad de canguro de etapa 1 como este.

o

En la etapa 2 , el canguro puede hacer pequeños saltos, pero no más de 2 antes de que tenga hambre. Podemos representar un patrón de actividad de canguro de etapa 2 como este.

 o o
o o o

Después de la etapa 2, el canguro mejora rápidamente. En cada etapa posterior, el canguro puede saltar un poco más alto (1 unidad en la representación gráfica) y el doble de veces. Por ejemplo, el patrón de actividad de un canguro en etapa 3 se ve así.

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

Para la etapa n , el patrón de actividad consiste en 2 ^n-1 saltos en forma de V de altura n .

Por ejemplo, para la etapa 4 , hay 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

Tarea

Escriba un programa completo o una función que tome un entero positivo n como entrada e imprima o devuelva la representación artística ASCII de una etapa n patrón de actividad de canguro de .

Los espacios en blanco circundantes y los códigos de escape ANSI están permitidos, siempre que el patrón se vea exactamente como se muestra arriba.

Si elige una función que devuelve la salida, debe devolver una sola cadena o matriz de caracteres que muestre la salida correcta cuando se imprima. No está permitido devolver una serie de cadenas.

Puede usar cualquier carácter imprimible que no sea un espacio en blanco en lugar de o , siempre que sea coherente dentro del patrón de actividad y en todos los patrones en su respuesta.

Este es el código de golf ; ¡que gane la respuesta más corta en bytes!

05AB1E , 12 10 bytes

Îj¹FÐvû},À

Explicación:

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

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)

Pruébalo en línea!

eyecrea una matriz de identidad. Si lo volteamos y concatenamos el original, es decir [fliplr(p),p], obtenemos (para 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)repetimos estos 2^(n-1)tiempos y obtenemos

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

De esto simplemente eliminamos las columnas innecesarias, con A(:,n+1:n:end)=[];

Carbón , 14 bytes

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

Pruébalo en línea!

Explicación

Ｎλintroduce un número entero en λ. Ｐ^es una impresión multidireccional (SE y SW) de ×λo(multiplicación de cadenas de λcon o). Luego Ｆ⁻λ¹ejecuta un tiempo de bucle for λ - 1, en el que se ‖Ｏ→refleja todo a la derecha con superposición.

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

Pruébalo en línea!

Utiliza una fórmula para las coordenadas (i,j)que contienen un círculo, luego une e imprime la cuadrícula. Hay mucho olor a golf aquí ''.join, dos rangos anidados, forpor execlo que es probable que haya mejoras.

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

Pruébalo en línea!

Befunge, 98 91 bytes

Esto utiliza un ,en lugar de o, ya que nos permite guardar un par de bytes.

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

Pruébalo en línea!

Explicación

Dado el número de etapa, n , comenzamos calculando los siguientes tres parámetros del patrón:

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

El jump_len se normaliza para evitar que sea cero para un canguro etapa 1 con:

jump_len += !jumplen    

Luego podemos generar el patrón de salto iterando sobre las coordenadas x e y del área de salida, y calculando el carácter apropiado para la salida de cada ubicación. La coordenada y cuenta regresiva de n - 1 a 0, y la coordenada x cuenta regresiva de ancho - 1 a 0. Determinamos si es necesario mostrar un punto con la siguiente fórmula:

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

El booleano show_dot se utiliza como índice de tabla para determinar el carácter real que se generará en cada ubicación. Para ahorrar espacio, usamos el comienzo de la última línea de origen como esa tabla, por lo que nuestro opersonaje termina siendo a ,.

J , 28 25 bytes

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

Guardado 3 bytes gracias a @ Conor O'Brien .

Esto se basa en el truco del palíndromo de la solución de @ muddyfish .

Pruébalo en línea!

Explicación

' 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

Pruébalo aquí!

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

Pruébalo en línea! Uso: k 3.

Explicación:

Dada una fila r, se establece una columna cy m = 2(n-1)una osi c mod mes igual ro m-r. La comprensión de la lista más externa establece el rango de rde n-1a 0, la siguiente establece el rango de cde 0a m*2^(n-1)y el más interno actúa como retorno condicional 'o'si se cumple la fórmula anterior y de lo ' 'contrario. Esto produce una lista de cadenas que se convierte en una sola cadena separada por una nueva línea unlines. Para n=1la función produce un error de división por cero, por lo que este caso se maneja explícitamente en la primera línea.

C #, 180, 173 171 bytes

No ganará esto, publicando para otros concursantes de C # como algo que pueden 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();
    }
}

editar: -7 bytes gracias a @KevinCruijssen

editar: -2 bytes, simplificado si

Pyth , 30 bytes

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

Un programa que toma la entrada de un número entero e imprime el resultado. Utiliza una comilla en "lugar de o.

Pruébalo en línea!

Cómo 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'

Pruébalo en línea!

Utilizando range(-n+1,n-1)para crear el número absoluto de espacios entre el fondo y el opara generar

  o
 o
o
 o

y luego agregando más copias, girando 90º todo y agregando la última oen la parte inferior derecha

J , 58 47 bytes

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

Se guardaron 11 bytes usando la idea de matriz de identidad de la solución de @ flawr .

Pruébalo en línea!

Una aplicación directa de la definición.

Explicación

Para n = 3, crea la matriz de identidad de orden n .

1 0 0
0 1 0
0 0 1

Luego espejo para hacer

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

Repita eso 2 ^{n -1} veces y suelte el encabezado de cada fila en los duplicados

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

Utilice esos valores como índices en la matriz de caracteres [' ', 'o']para generar una 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>

Jalea , 11 bytes

ŒḄ¡ḶUz1Ṛa⁶Y

TryItOnline!

¿Cómo?

El carácter imprimible utilizado es 0.

Se basa en el método de la respuesta de Dennis a su pregunta anterior sobre el tema de los canguros.

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

Pruébelo en 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')

Pruébalo en línea!

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

Inserta ouna matriz 2D y luego la imprime.

05AB1E , 16 bytes

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

Pruébalo en línea!

¿Porque y 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

Golfizado:

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

Sin golf:

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

}

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

Sin golf:

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

}