Création d'une carte de balle qui tombe

16

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 , donc la soumission avec le moins d'octets gagne!

Adnan
la source
1
@DonMuesli Haha, cela peut arriver à n'importe qui: p
Adnan

Réponses:

7

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
Denker
la source
4

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}}
Encre de valeur
la source
putsajoute une nouvelle ligne à la fin ( printcontrairement à Ruby ), elle a donc été mise à jour vers les 5nouvelles lignes.
Value Ink
Tous saluent la timesfonction pour me sauver 3 octets sur la forboucle: D
Value Ink
1
57 octets: ->n{n.times{puts (('_'*25+' '*5)*2)[rand(30),30]+"\n"*5}} Essayez ici
Alex A.
Vous n'avez pas besoin d'attribuer le lambda dans le cadre de la soumission, car nous n'avons pas besoin que les fonctions soient nommées.
Alex A.
1
Vous pouvez faire (->n{n.times{puts (('_'*25+' '*5)*2)[rand(30),30]+"\n"*5}})[input]ou simplement spécifier que vous devez l'attribuer pour l'appeler. C'est assez courant sur le site.
Alex A.
3

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

Alex A.
la source
3

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.

Mat
la source
@TimmyD Je serais surpris si quelqu'un avait encore 1.0. Il n'était disponible qu'en téléchargement et n'était livré avec aucun système d'exploitation. 2.0 devrait être considéré comme la norme.
Matt
@TimmyD Je suis d'accord avec ce point, mais pas avec PowerShell 1.0 . Si quelqu'un sur ce site utilise ça, cela me surprendrait. Si j'utilisais une fonctionnalité 3.0 ou supérieure, je le soulignerais à coup sûr.
Matt
3

Pyth, 19 octets

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

Essayez-le ici

Merci à FryAmTheEggman d'avoir attrapé un bug.

Mike Bufardeci
la source
@AandN FryAmTheEggman a raison, je l'ai changé pour qu'il soit décalé de 0 à 29 caractères au lieu de 0 à 25.
Mike Bufardeci
2

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.

Brian
la source
2

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
Luis Mendo
la source
2

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.

CAD97
la source
En mettant i ++ le dernier emplacement utilisé, vous pouvez enregistrer un octet.
Blue
Intelligent. Hacky, mais intelligent. Plus intelligent encore, je laisse en quelque sorte un espace vide de sens au début de mon extrait de code ( s = ""). Les deux sont corrigés maintenant.
CAD97
Vous pouvez également économiser beaucoup plus en vous débarrassant du tableau char, changer les littéraux char en littéraux chaîne et utiliser s + = à l'intérieur pour la boucle. Je viens de le tester
Blue
Btw grande réponse
Blue
C'est ce que j'obtiens en me concentrant sur une façon de le faire. -34 (!) Octets.
CAD97
1

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.

R. Kap
la source
Est-ce que cela imprime également les nouvelles lignes entre les deux?
Adnan
@AandN Maintenant c'est le cas. :)
R. Kap
Vous devez en fait imprimer 4 nouvelles lignes: p. Donc, changer '\r'pour '\r'*4devrait probablement fonctionner. De plus, je pense que vous pouvez changer range(a+1)pour range(a).
Adnan
@AandN En fait, l'utilisation range(a)imprime réellement le a-1nombre de lignes, c'est donc range(a+1)le meilleur moyen d'imprimer le nombre exact de lignes fournies par l'utilisateur. De plus, il imprime désormais 4 nouvelles lignes entre chaque résultat.
R. Kap
Hmmm, c'est bizarre, parce que j'ai testé cela avec g(5)et il imprime 6 chaînes au lieu de cinq, donc changer a+1pour acorrigerait probablement ça.
Adnan
1

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]
DaveBensonPhillips
la source
Votre dernière mise à jour ne fonctionne pas car vous avez placé l'aléatoire dans un argument par défaut, donc la fonction affichera toujours les mêmes ntemps de ligne
Sp3000