Introdução

Para quem nunca ouviu falar desse jogo antes. Você está jogando uma bola que precisa sobreviver o maior tempo possível. Isso é feito movendo-se para a esquerda ou direita, indo para os orifícios. Como o mapa se move para cima, você precisa descer para sobreviver por mais tempo. Se você procurar imagens, provavelmente sabe qual jogo quero dizer.

A tarefa

Dado um número inteiro positivo n , produza um mapa de bola em queda de n camadas. Entre as camadas, existem 4 novas linhas. A largura da camada é composta por 25 caracteres sublinhados, com um orifício de comprimento 5. Isso significa que a largura total é igual a 30. Isso é alterado aleatoriamente após cada camada. Um exemplo de uma camada válida é:

_______________     __________

O furo também pode estar nas bordas, como se a camada fosse como um cilindro:

  _________________________   

Observe que existem 2 espaços à esquerda e 3 à direita. Fazendo um único orifício de largura 5.

Casos de teste

Para n = 4, esta é uma saída válida:

_______________     __________





______     ___________________





_______________________     __





  _________________________

Nota: os orifícios devem ser uniformemente distribuídos. Trailing e / ou linhas de liderança são permitidas.

Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

Pitão, 19 bytes

VQ.>+*\_25*d5O30*b4

Experimente aqui!

Explicação

VQ.> + * \ _ 25 * d5O30 * b4 # Q = entrada

VQ # Repetir Q vezes
     * \ _ 25 # 25 sublinhados
          * d5 # 5 espaços
    + # concat os sublinhados e espaços
  .> O25 # gire esta sequência de 0 a 29 vezes
                * b4 # imprime as novas linhas separadas

Ruby, 74 71 59

Agradeço a Alex A. por me lembrar que ser basicamente uma linha significa que posso usar o lambda stabby

f=->n{n.times{puts (('_'*25+' '*5)*2)[rand(30),30]+"\n"*5}}

Julia, 72 bytes

n->join([join(circshift(["_"^25*" "^5...],rand(1:30)))"\n"^5 for i=1:n])

Esta é uma função anônima que aceita um número inteiro e retorna uma string. Para chamá-lo, atribua-o a uma variável.

Construímos uma sequência de 25 sublinhados, seguida de 5 espaços, e depois dividimos isso em uma matriz de caracteres. Nós o deslocamos circularmente um número aleatório de vezes (entre 1 e 30), juntamos novamente em uma sequência e aderimos a 5 novas linhas. Este processo é repetido n vezes, em que n é a entrada. A matriz resultante é unida e retornada.

Experimente aqui

PowerShell 65 bytes

0..$args[0]|%{-join("_"*25+" "*5)[($r=Random 25)..($r-29)];,""*5}

Execute um loop para n iterações. Obtenha um número aleatório e faça uma sequência de sublinhado com 5 espaços no final. Índice na cadeia como uma matriz para puxar a partir de um local aleatório. A indexação negativa termina do final. Faça o backup novamente e acrescente 5 novas linhas.

Edit: Não sei por que pensei que precisava do parâmetro -Maximum, pois é posicional. Graças ao TimmyD , raspei alguns bytes e esqueci de obter informações, o que me levou de volta a 65.

Pitão, 19 bytes

VQ.>r"5 25_"9O30*4b

Experimente aqui

Obrigado a FryAmTheEggman por detectar um bug.

SpecBAS - 93 bytes

1 a$="_"*25+" "*5: INPUT n: FOR i=1 TO n: r=1+INT(RND*30): ?a$(r TO)+a$( TO r-1)''''': NEXT i

Cria uma sequência de 25 caracteres sublinhados + 5 espaços, escolhe um ponto de início aleatório e une a sequência nessa posição e alinha o início da sequência até o final.

O apóstrofo força uma nova linha, então 1 no final da sequência e 4 linhas vazias.

MATL , 23 bytes

:"95l25X"5Z"h30YrYS10ct

Experimente online!

Explicação

:"           % take input n implicitly. Repeat loop n times
  95l25X"    %   row vector with number 95 ('_') repeated 25 times
  5Z"        %   row vector of 5 blank spaces
  h          %   concatenate vertically
  30Yr       %   random number uniformly distributed on [1,2,...,30]
  YS         %   circularly shift
  10c        %   newline character. Includes another newline when printed
  t          %   duplicate
             % implicitly end loop and display stack contents

Java, 177 140 bytes

-1 byte para Blue movendo o i ++

-2 bytes para mim, deixando espaço em branco sem sentido no original

-34 bytes para Blue para perceber que eu não precisava do char []

Porque, você sabe, Java.

n->{String s="";for(;n-->0;){int r=(int)(Math.random()*30);for(int i=0;i<30;){s+=i>r&i<r+6|r>24&i++<=r%25?" ":"_";}s+="\n\n\n\n";}return s;}

Ligeiramente não destruído:

Function<Integer, String> fallingBall = n -> {
    String s = "";
    for (;n-->0;) {
        int r = (int)(Math.random()*30);
        for (int i=0; i<30; i++) {
            s += i>r&i<r+6|r>24&i<=r%25?" ":"_";
        }
        s += "\n\n\n\n";
    }
    return s;
}

Como o Java não possui uma String 'rotate', tive que adotar uma abordagem diferente. Gerei um int aleatório 0-29 que representa o índice inicial do furo (OBO porque >é menor que >=). Cada caractere individual é então decidido pela lógica

l[index] = (index>random && index<random+6) || (random>24 && index<=random%25) ? ' ' : '_';

Isso lida com a natureza de "quebra automática" do todo.

Python 3,5 - 109 113 bytes (+4 para imprimir 4 novas linhas entre cada resultado):

def g(a,j='_'*25+' '*5):
 for l in range(a):import random;n=random.randrange(len(j)+1);print(j[-n:]+j[:-n]+'\r'*4)

Forma Não Goleada:

# j is the starting string with the 25 underscores and then 5 spaces at the end
def g(a,j='_'*25+' '*5):
    import random #Import the random module
    for l in range(a): # Do the following as many times as provided by the user
        n=random.randrange(len(j)+1) Get a random number in the range 0-29
        print(j[-n:]+j[:-n]+'\r'*4) #Shift the string characters right "n" times and print out the results with 4 new lines in between

Basicamente, o que está acontecendo é que uma string 'j', consistindo em 25 sublinhado seguido por 5 espaços, é fornecida como argumento para a função "g". Em seguida, o módulo aleatório é importado e, quantas vezes for especificado pelo usuário, um número aleatório é escolhido no intervalo 0 => 29e a sequência "j" é deslocada para a direita várias vezes. O resultado é impresso após cada iteração, com 4 novas linhas entre cada resultado.

Python, 119 103 bytes

import random
s='_'*20+' '*5
def f(n,a=random.randint(0,25)):[print(s[a:]+s[:a]+3*'\n')for _ in' '*n]