Ispirato da questa mini-sfida di chat.

Data una stringa come input (solo caratteri stampabili ASCII), genera la stringa con le lettere "piove" in basso. Ogni lettera deve essere un numero casuale di righe verso il basso (casuale tra 0e la lunghezza della stringa, ognuna con probabilità diversa da zero) e solo un carattere per colonna. Tutte le uscite possibili devono avere di nuovo una probabilità diversa da zero.

Questo è forse un po 'confuso, quindi ecco un esempio (tratto da quella CMC):

Hello World

          d
H
       o
  llo

         l
      W
 e
        r

Nota come Hè uno spazio in basso, lo dzero è in basso e llotutto accade per allinearsi. Il rè il più lontano verso il basso, a 9, ma è ancora inferiore alla lunghezza della corda dall'alto. Questo è solo un esempio, ci sono dozzine di altre possibilità per l'input Hello World.

Altri esempi potrebbero essere:

test

t
 e
  s
   t


PP&CG

  & G
 P

P  C

• Input e output possono essere forniti con qualsiasi metodo conveniente .
• L'input è garantito non vuoto (ovvero, non riceverai mai ""come input).
• È possibile stamparlo su STDOUT o restituirlo come risultato di una funzione.
• È accettabile un programma completo o una funzione.
• È accettabile qualsiasi quantità di spazio bianco estraneo, purché i caratteri siano allineati in modo appropriato (ad esempio, sentiti libero di riempire come un rettangolo).
• Sono vietate le scappatoie standard .
• Si tratta di code-golf, quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

R , 104 byte

function(s){m=matrix(" ",l<-nchar(s),l)
m[cbind(1:l,sample(l,l,T))]=el(strsplit(s,""))
write(m,1,l,,"")}

Provalo online!

Input come stringa; scrive su stdout.

JavaScript (ES6), 72 byte

Accetta input come un elenco di caratteri. Restituisce una matrice di caratteri.

a=>a.map((_,y)=>a.map((c,x)=>Math.random()<.5|!a[y+1]?(a[x]=' ',c):' '))

Provalo online!

Pyth - 9 byte

Elenco di righe di output.

.tm+*;OlQ

 .t                       Transpose, padding with spaces
  m      (Q implicit)     Map over input
   +    (d implicit)      Concatenate to loop var
    *                     String repeat
     ;                    This refers to the var replaced by loop var, which is d=" "
     O                    Random number less than
      lQ                  Length of input

Provalo online .

J , 30 19 byte

|:@,.]{.~"+_2-#?@##

Provalo online!

Japt , 8 byte

-1 byte da @Shaggy

y_iUÊö ç

y_iUÊö ç        Full Program. Implicit input U
y_              transpose and map each row in U (Call it X)
  i             Insert at the beginning of X:
       ç        " " repeated ↓ many times
   UÊö          random integer in [0, length of U] 
                implicit transpose back and output

Provalo online!

APL (Dyalog Unicode) , 16 byte ^SBCS

Funzione prefisso tacito anonimo

⍉∘↑⊢↑¨⍨∘-∘?≢⍴1+≢

≢ lunghezza della stringa

1+ uno aggiunto a quello

≢⍴ "lunghezza" copie di quello

∘? numeri interi casuali nell'intervallo 1 ... quelli e poi ...

∘- negare, e poi ...

⊢↑¨⍨ prendi più di molti elementi da ciascun personaggio, riempiendo a sinistra gli spazi

∘↑ mescola elenco di stringhe in matrice, imbottitura con spazi a destra

⍉ trasporre

Provalo online!

Japt , 8 byte

yÈùUÊö Ä

Provalo

yÈùUÊö Ä     :Implicit input of string U
y            :Transpose
 È           :Pass each column through the following function and transpose back
  ù          :  Left pad with spaces to length
   UÊ        :    Length of U
     ö       :    Random number in the range [0,UÊ)
       Ä     :    Plus 1

Gelatina , 10 byte

³LŻX⁶x;)z⁶

Provalo online!

      )    | For each input character
³L         | Length of original input
  Ż        | 0..length
   X       | Random number from that list
    ⁶x     | That number of spaces
       ;   | Concatenate to the character
        z⁶ | Finally transpose with space as filler

Rubino , 59 57 55 byte

->a{a.map{|c|s=[' ']*z=a.size;s[rand z]=c;s}.transpose}

Provalo online!

Input 1D, output array 2D di caratteri.

PHP , 88 byte

for($o='';$i<$l=strlen($argn);$o[$i+$l*rand(0,$l)]=$argn[$i++]);echo chunk_split($o,$l);

Provalo online!

O 94 byte usando la funzione di numeri interi casuali crittografici di PHP .

for($o='';$i<$l=strlen($argn);$o[$i+$l*random_int(0,$l)]=$argn[$i++]);echo chunk_split($o,$l);

Provalo online!

Ingresso da STDIN, uscita a STDOUT. Correre come:

$ echo Hello World|php -nF rain.php
   l  W    
  l        

 e      r d

H      o   

         l 


    o 

-1 byte (stringa vuota anziché spazio) e +1 byte (err sul lato delle regole) grazie solo a @ ASCII!

Carbone , 10 9 byte

↑Ｅθ◧ι⊕‽Ｌθ

Provalo online! Il collegamento è alla versione dettagliata del codice. Modifica: 1 byte salvato grazie solo a @ ASCII. Spiegazione:

  θ         Input string
 Ｅ          Map over characters
        θ   Input string
       Ｌ    Length
      ‽     Random value
     ⊕      Incremented
    ι       Current character
   ◧        Padded to length
↑           Print rotated

Come sottolinea solo ASCII, è possibile spostare le lettere in modo casuale verso l'alto anziché verso il basso per lo stesso effetto (tranne per il fatto che potrebbe esserci spazio bianco in più nella parte inferiore anziché nella parte superiore). Stampare una serie di caratteri verso l'alto equivale a stampare normalmente una stringa, quindi il riempimento sfalsa ogni carattere verticalmente di un numero casuale.

05AB1E (legacy) , 9 byte

εIgÝΩú}ζ»

Immettere come stringa o elenco di caratteri (o va bene).

Provalo online.

Alternativa a 9 byte molto più lenta:

gDÝsãΩúζ»

Inserisci come un elenco di caratteri.

Provalo online.

Entrambi usano la versione legacy di 05AB1E, poiché la nuova versione richiede un esplicito €Sprima diζ ..

Spiegazione:

ε       # Map each character in the (implicit) input to:
 Ig     #  Take the length of the input
   Ý    #  Create a list in the range [0, input-length]
    Ω   #  Pop and push a random integer from this list
     ú  #  Pad the current character with that many leading spaces
}ζ      # After the map: zip/transpose; swapping rows/columns (with space as default filler)
  »     # Then join all strings by newlines (and it output implicitly as result)

g          # Get the length of the (implicit) input-list
 D         # Duplicate this length
  Ý        # Create a list in the range [0, input-length]
   sã      # Take the cartesian product of this list that many times
     Ω     # Pop and push a random list from this list of lists of integers
      ú    # Pad the characters in the (implicit) input-list with that many spaces
       ζ   # Zip/transpose; swapping rows/columns (with space as default filler)
        »  # Then join all strings by newlines (and it output implicitly as result)

C (gcc) , 131 byte

f(char*s){int l=strlen(s),R[l],i=l,j;for(srand(time(0));i--;)R[i]=rand()%l;for(;++i<l*l;printf("\n%c"+!!j,i/l^R[j]?32:s[j]))j=i%l;}

Provalo online!

Julia, 69 byte

f(s)=(n=length(s);z=fill(' ',n,n);for i=1:n z[rand(1:n),i]=s[i]end;z)

Questo definisce una funzione fche accetta a Stringo Vector{Char}e restituisce aMatrix{Char} .

Ungolfed:

function f(s)
    n = length(s)
    z = fill(' ', n, n)  # an n×n matrix of spaces
    for i = 1:n
        # set a random entry in the ith column to the ith character in s
        z[rand(1:n),i] = s[i] 
    end
    z
end

Esempio:

julia> f("test")
4×4 Array{Char,2}:
 't'  ' '  ' '  ' '
 ' '  ' '  ' '  ' '
 ' '  'e'  ' '  't'
 ' '  ' '  's'  ' '

Questo potrebbe sicuramente essere migliore; le mie abilità nel golf sono piuttosto arrugginite.

Provalo online!

Perl 5 -F , 50 49 byte

-1 di @DomHastings

map$;[rand@F][$i++]=$_,@F;say map$_||' ',@$_ for@

Provalo online!

PowerShell , 108 102 98 byte

^{-4 byte grazie a mazzy}

$a=1..($z=($y=$args|% t*y).count)|%{random $z}
1..$z|%{-join($y|%{" $_"[$a[$i++%$z]-eq+$r]});$r++}

Provalo online!

Fondamentalmente itera 1..lengthdue volte la stringa, una volta per ottenere posizioni di riga casuali per ciascun personaggio, e una seconda volta per costruire effettivamente ogni riga usando quegli indici. Capire come farlo in un colpo solo è dove si trovano i grandi risparmi di byte.

SmileBASIC 3, 62 byte

LINPUT T$L=LEN(T$)CLS
FOR I=0TO L-1LOCATE,RND(L+1)?T$[I];
NEXT

Rosso , 84 byte

func[s][foreach n random collect[repeat n length? s[keep n]][print pad/left s/:n n]]

Provalo online!

Python - 92 byte

import random
lambda s:map(None,*[(random.randrange(len(s))*' '+c).ljust(len(s))for c in s])

K (oK) , 20 byte

Soluzione:

+c$(-1-c?c:#x)$++x:

Provalo online!

Spiegazione:

+c$(-1-c?c:#x)$++x: / the solution
                 x: / store input as x
                +   / flip (enlist)
               +    / flip again (break into chars)
              $     / pad (each) character
   (         )      / do this together
           #x       / length of x
         c:         / save as c
      -c?           / choose (?) c times from c
    -1              / subtract from -1
 c$                 / pad to length of x
+                   / flip

Python 3 , 140 131 byte

from random import*
def f(s):
	e=range(len(s))
	p=[choice(e)for t in s]
	for r in e:print(''.join((r-p[i]and' 'or s[i]for i in e)))

Provalo online!

Python 3, 208 byte

import random as r;x=input();R=range(len(x));c=[r.choice(R) for i in R];y=[' '*c[i]+x[i]+' '*(len(x)-c[i]) for i in R];R=range(len(y));print('\n'.join([''.join(r) for r in [[y[i][j] for i in R] for j in R]]))

Crea un elenco di scelte casuali, quindi crea un elenco di colonne con spazi vuoti ovunque tranne che nell'indice specificato da ciascuna scelta casuale. Le colonne vengono trasposte in righe e stampate con nuove righe tra di loro.

Provalo online!