introduzione

Per quelli che non hanno mai sentito parlare di questo gioco prima d'ora. Stai giocando una palla che deve sopravvivere il più a lungo possibile. Questo viene fatto spostandosi a sinistra o a destra, andando nei fori. Poiché la mappa si sposta verso l'alto, devi sopravvivere verso il basso per sopravvivere più a lungo. Se cerchi immagini, probabilmente sai quale gioco intendo.

L'obiettivo

Dato un numero intero positivo n , emette una mappa a sfera che cade di n strati. Tra i livelli, ci sono 4 nuove righe. La larghezza del layer è composta da 25 caratteri di sottolineatura, con un foro di lunghezza 5. Ciò significa che la larghezza totale è uguale a 30. Questo viene spostato casualmente dopo ogni layer. Un esempio di un livello valido è:

_______________     __________

Il foro può anche essere ai bordi, come se lo strato fosse come un cilindro:

  _________________________   

Si noti che ci sono 2 spazi iniziali e 3 spazi finali. Esecuzione di un singolo foro di larghezza 5.

Casi test

Per n = 4, questo è un output valido:

_______________     __________





______     ___________________





_______________________     __





  _________________________

Nota: i fori devono essere distribuiti uniformemente . Sono consentiti il ​​trascinamento e / o le nuove linee principali.

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Pyth, 19 byte

VQ.>+*\_25*d5O30*b4

Provalo qui!

Spiegazione

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

VQ # Ripeti Q volte
     * \ _ 25 # 25 sottolinea
          * d5 # 5 spazi
    + # concatena i trattini bassi e gli spazi
  .> O25 # ruota questa stringa da 0 a 29 volte
                * b4 # stampa le nuove righe separate

Ruby, 74 71 59

Grazie ad Alex A. per avermi ricordato che essere sostanzialmente una riga significa che posso usare lo stabby lambda

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

Julia, 72 byte

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

Questa è una funzione anonima che accetta un numero intero e restituisce una stringa. Per chiamarlo, assegnarlo a una variabile.

Costruiamo una stringa di 25 caratteri di sottolineatura seguita da 5 spazi, quindi dividiamola in una matrice di caratteri. Lo spostiamo in modo circolare un numero casuale di volte (tra 1 e 30), lo ricolleghiamo in una stringa e viriamo su 5 nuove linee. Questo processo si ripete n volte, dove n è l'input. L'array risultante viene unito e restituito.

Provalo qui

PowerShell 65 byte

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

Esegui un ciclo per n iterazioni. Ottieni un numero casuale e crea una stringa di sottolineatura con 5 spazi alla fine. Indicizza nella stringa come un array per estrarre a partire da una posizione casuale. L'indicizzazione negativa termina dalla fine. Unisciti nuovamente al backup e aggiungi 5 nuove righe.

Modifica: non so perché pensassi di aver bisogno del parametro -Maximumperché è posizionale. Grazie a TimmyD ho rasato alcuni byte e ho dimenticato di ricevere l'input in modo da riportarmi a 65.

Pyth, 19 byte

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

Provalo qui

Grazie a FryAmTheEggman per aver scoperto un bug.

SpecBAS - 93 byte

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

Crea una stringa di 25 caratteri di sottolineatura + 5 spazi, seleziona un punto iniziale casuale e giunge la stringa in quella posizione e adatta l'inizio della stringa alla fine.

L'apostrofo forza una nuova riga, quindi 1 alla fine della stringa e 4 righe vuote.

MATL , 23 byte

:"95l25X"5Z"h30YrYS10ct

Provalo online!

Spiegazione

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

-1 byte su blu spostando i ++

-2 byte per me lasciando spazi vuoti insignificanti nell'originale

-34 byte a Blue per aver realizzato che non mi serviva affatto il carattere []

Perché, sai, 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;}

Leggermente non golfato:

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

Dato che Java non ha una stringa "ruota", ho dovuto adottare un approccio diverso. Ho generato un int casuale 0-29 che rappresenta l'indice iniziale del foro (OBO perché >è più corto di >=). Ogni singolo personaggio viene quindi deciso dalla logica

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

Questo gestisce la natura "avvolgente" dell'insieme.

Python 3.5 - 109 113 byte (+4 per la stampa di 4 nuove righe tra ogni risultato):

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 non golfata:

# 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

Fondamentalmente quello che sta succedendo è che una stringa 'j', composta da 25 trattini bassi seguiti da 5 spazi, viene data come argomento alla funzione "g". Quindi, il modulo casuale viene importato e, quante volte specificato dall'utente, viene scelto un numero casuale nell'intervallo 0 => 29e la stringa "j" viene spostata a destra più volte. Il risultato viene quindi stampato dopo ogni iterazione, con 4 nuove righe tra ogni risultato.

Python, 119 103 byte

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