introduction

Pour ceux qui n'ont jamais entendu parler de ce jeu auparavant. Vous jouez une balle qui doit survivre le plus longtemps possible. Cela se fait en se déplaçant vers la gauche ou la droite, en allant dans les trous. Puisque la carte se déplace vers le haut, vous devez descendre pour survivre plus longtemps. Si vous recherchez des images, vous savez probablement de quel jeu je parle.

La tâche

Étant donné un entier positif n , produire une carte de boule tombante de n couches. Entre les couches, il y a 4 nouvelles lignes. La largeur de la couche est composée de 25 caractères de soulignement, avec un trou de longueur 5. Cela signifie que la largeur totale est égale à 30. Ceci est décalé de manière aléatoire après chaque couche. Un exemple de couche valide est:

_______________     __________

Le trou peut également être sur les bords, comme si la couche était comme un cylindre:

  _________________________   

Notez qu'il y a 2 espaces de début et 3 espaces de fin. Faire un seul trou de largeur 5.

Cas de test

Pour n = 4, il s'agit d'une sortie valide:

_______________     __________





______     ___________________





_______________________     __





  _________________________

Remarque: les trous doivent être uniformément répartis. Les sauts de ligne de fin et / ou de début sont autorisés.

C'est du code-golf , donc la soumission avec le moins d'octets gagne!

Pyth, 19 octets

VQ.>+*\_25*d5O30*b4

Essayez-le ici!

Explication

VQ.> + * \ _ 25 * d5O30 * b4 # Q = entrée

VQ # Répéter Q fois
     * \ _ 25 # 25 souligne
          * d5 # 5 espaces
    + # concatère les soulignements et les espaces
  .> O25 # faire pivoter cette chaîne de 0 à 29 fois
                * b4 # imprimer les nouvelles lignes séparées

Rubis, 74 71 59

Merci à Alex A. de m'avoir rappelé qu'être fondamentalement une ligne signifie que je peux utiliser le stabby lambda

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

Julia, 72 octets

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

Il s'agit d'une fonction anonyme qui accepte un entier et renvoie une chaîne. Pour l'appeler, affectez-le à une variable.

Nous construisons une chaîne de 25 traits de soulignement suivis de 5 espaces, puis répartissons cela en un tableau de caractères. Nous le déplaçons circulairement un nombre aléatoire de fois (entre 1 et 30), le rejoignons en une chaîne et clouons sur 5 nouvelles lignes. Ce processus est répété n fois, où n est l'entrée. Le tableau résultant est joint et renvoyé.

Essayez-le ici

PowerShell 65 octets

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

Exécutez une boucle pour n itérations. Obtenez un nombre aléatoire et créez une chaîne de soulignement avec 5 espaces à la fin. Indexez la chaîne sous forme de tableau à extraire à partir d'un emplacement aléatoire. L'indexation négative se termine à la fin. Rejoignez cette sauvegarde à nouveau et ajoutez 5 nouvelles lignes.

Edit: je ne sais pas pourquoi j'ai pensé que j'avais besoin du paramètre -Maximumcar il est positionnel. Grâce à TimmyD, j'ai rasé quelques octets et j'ai oublié d'obtenir des données, ce qui m'a ramené à 65.

Pyth, 19 octets

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

Essayez-le ici

Merci à FryAmTheEggman d'avoir attrapé un bug.

SpecBAS - 93 octets

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

Donne une chaîne de 25 traits de soulignement + 5 espaces, choisit un point de départ aléatoire et épissure la chaîne à cette position et colle le début de la chaîne à la fin.

L'apostrophe force une nouvelle ligne, donc 1 à la fin de la chaîne et 4 lignes vides.

MATL , 23 octets

:"95l25X"5Z"h30YrYS10ct

Essayez-le en ligne!

Explication

:"           % 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 octets

-1 octet à Blue pour déplacer l'i ++

-2 octets pour moi, laissant un espace vide de sens dans l'original

-34 octets à Blue pour avoir réalisé que je n'avais pas du tout besoin du caractère []

Parce que, tu sais, 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;}

Légèrement non golfé:

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

Comme Java n'a pas de rotation de chaîne, j'ai dû adopter une approche différente. J'ai généré un int aléatoire 0-29 qui représente l'indice de départ du trou (OBO car >est plus court que >=). Chaque caractère individuel est alors décidé par la logique

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

Cela gère la nature "enveloppante" de l'ensemble.

Python 3,5 - 109 113 octets (+4 pour imprimer 4 nouvelles lignes entre chaque résultat):

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)

Forme non golfée:

# 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

Fondamentalement, ce qui se passe, c'est qu'une chaîne «j», composée de 25 traits de soulignement suivis de 5 espaces, est donnée comme argument à la fonction «g». Ensuite, le module aléatoire est importé et, autant de fois que spécifié par l'utilisateur, un nombre aléatoire est choisi dans la plage 0 => 29et la chaîne "j" est décalée vers la droite autant de fois. Le résultat est ensuite imprimé après chaque itération, avec 4 nouvelles lignes entre chaque résultat.

Python, 119 103 octets

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