Inspirado en este mini desafío de chat.

Dada una cadena como entrada (solo caracteres imprimibles ASCII), genera la cadena con las letras "lloviendo" hacia abajo. Cada letra debe ser un número aleatorio de líneas hacia abajo (aleatorio entre 0y la longitud de la cadena, cada una con una probabilidad distinta de cero), y solo un carácter por columna. Todas las salidas posibles deben tener nuevamente una probabilidad distinta de cero.

Tal vez sea un poco confuso, así que aquí hay un ejemplo (tomado de ese CMC):

Hello World

          d
H
       o
  llo

         l
      W
 e
        r

Tenga en cuenta cómo Hes un espacio hacia abajo, el dcero es hacia abajo, y llotodo sucede para alinearse. El res el más alejado, en 9, pero aún es menor que la longitud de la cuerda desde la parte superior. Este es solo un ejemplo, hay docenas de otras posibilidades de entrada Hello World.

Otros ejemplos podrían ser:

test

t
 e
  s
   t


PP&CG

  & G
 P

P  C

• La entrada y salida se pueden dar por cualquier método conveniente .
• La entrada está garantizada como no vacía (es decir, nunca recibirá ""como entrada).
• Puede imprimirlo en STDOUT o devolverlo como resultado de una función.
• Un programa completo o una función son aceptables.
• Cualquier cantidad de espacio en blanco extraño es aceptable, siempre y cuando los caracteres se alineen apropiadamente (por ejemplo, siéntase libre de rellenar como un rectángulo).
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

R , 104 bytes

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

Pruébalo en línea!

Entrada como una cadena; escribe a stdout.

JavaScript (ES6), 72 bytes

Toma la entrada como una lista de caracteres. Devuelve una matriz de caracteres.

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

Pruébalo en línea!

Pyth - 9 bytes

Lista de salidas de líneas.

.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

Pruébalo en línea .

J , 30 19 bytes

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

Pruébalo en línea!

Japt , 8 bytes

-1 byte de @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

Pruébalo en línea!

APL (Dyalog Unicode) , ^{SBCS de} 16 bytes

Función de prefijo tácito anónimo

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

≢ longitud de la cuerda

1+ uno agregado a eso

≢⍴ copias de "longitud" de ese

∘? enteros aleatorios en el rango 1 ... esos, y luego ...

∘- negar, y luego ...

⊢↑¨⍨ tomar muchos elementos de cada personaje, rellenando a la izquierda con espacios

∘↑ Mezcle la lista de cadenas en la matriz, rellenando con espacios a la derecha

⍉ transponer

Pruébalo en línea!

Japt , 8 bytes

yÈùUÊö Ä

Intentalo

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

Jalea , 10 bytes

³LŻX⁶x;)z⁶

Pruébalo en línea!

      )    | 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

Ruby , 59 57 55 bytes

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

Pruébalo en línea!

Entradas 1D, salidas de matriz 2D de caracteres.

PHP , 88 bytes

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

Pruébalo en línea!

O 94 bytes usando la función de enteros aleatorios criptográficos de PHP .

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

Pruébalo en línea!

Entrada de STDIN, salida a STDOUT. Correr como:

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

 e      r d

H      o   

         l 


    o 

-1 byte (cadena vacía en lugar de espacio) y +1 byte (error en el lado de las reglas) gracias a @ ASCII-only!

Carbón , 10 9 bytes

↑Ｅθ◧ι⊕‽Ｌθ

Pruébalo en línea! El enlace es a la versión detallada del código. Editar: guardado 1 byte gracias a @ ASCII-only. Explicación:

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

Como señala ASCII-only, puede mover las letras aleatoriamente hacia arriba en lugar de hacia abajo para obtener el mismo efecto (excepto que puede haber espacio en blanco adicional en la parte inferior en lugar de en la parte superior). Imprimir una matriz de caracteres hacia arriba es equivalente a imprimir una cadena normalmente, por lo que el relleno simplemente compensa cada carácter verticalmente en una cantidad aleatoria.

05AB1E (heredado) , 9 bytes

εIgÝΩú}ζ»

Ingrese como una cadena o lista de caracteres (cualquiera está bien).

Pruébalo en línea.

Alternativa de 9 bytes mucho más lenta:

gDÝsãΩúζ»

Entrada como una lista de caracteres.

Pruébalo en línea.

Ambos utilizan la versión heredada de 05AB1E, ya que la nueva versión requiere un explícito €Santes de la ζ..

Explicación:

ε       # 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 bytes

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

Pruébalo en línea!

Julia, 69 bytes

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

Esto define una función fque acepta un Stringo Vector{Char}y devuelve una Matrix{Char}.

Sin golf:

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

Ejemplo:

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

Esto seguramente podría ser mejor; Mis habilidades de golf son bastante oxidadas.

Pruébalo en línea!

Perl 5 -F , 50 49 bytes

-1 por @DomHastings

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

Pruébalo en línea!

PowerShell , 108 102 98 bytes

^{-4 bytes gracias a mazzy}

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

Pruébalo en línea!

Básicamente itera 1..lengthla cadena dos veces, una para obtener ubicaciones de línea aleatorias para cada carácter y una segunda vez para construir cada línea usando esos índices. Descubrir cómo hacerlo en un barrido es donde están los grandes ahorros de bytes.

SmileBASIC 3, 62 bytes

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

Rojo , 84 bytes

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

Pruébalo en línea!

Python - 92 bytes

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

K (oK) , 20 bytes

Solución:

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

Pruébalo en línea!

Explicación:

+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 bytes

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)))

Pruébalo en línea!

Python 3, 208 bytes

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 una lista de opciones aleatorias, luego hace una lista de columnas con espacio en blanco en todas partes excepto en el índice especificado por cada opción aleatoria. Las columnas se transponen en filas y se imprimen con nuevas líneas entre ellas.

Pruébalo en línea!