Llena un tazón con sopa de letras

24

Nos parece que no conseguir cansados de desafíos relacionados con el alfabeto ...


La receta

Dado

  • una cadena de letras Sy
  • dos números enteros positivos M, N,

produzca una sopa de letras con las letras de Socupar posiciones aleatorias en un recipiente rectangular de tamaño M× N, enmarcado por un carácter no alfabético y sin espacio para representar el borde del recipiente.

Las posiciones no utilizadas por las letras deben mostrarse como espacios. Vea los ejemplos a continuación .

Reglas adicionales

  • El tamaño M× se Nrefiere al interior del cuenco. El tamaño que incluye el borde es M+2× N+2.
  • Cada personaje Sdebe aparecer una vez en el tazón, en una posición diferente ; es decir, un personaje no puede sobrescribir a otro.
  • S puede contener duplicados . Por ejemplo, si Ses la cadena 'abcc', la sopa debe contener uno a, uno by dos c(todos en diferentes posiciones).
  • Las entradas estarán satisfacer las restricciones M >= 1 , N >= 1, 1 <= length(S) <= M*N.
  • El borde del cuenco puede ser cualquier carácter no alfabético, no espacial , coherente en las ejecuciones del programa y los valores de entrada.
  • Las posiciones de las letras en el bol son aleatorias, por lo que el resultado puede diferir cada vez que el programa se ejecuta con las mismas entradas.
  • Dada la entrada, cada posible conjunto de posiciones de letras debe tener una probabilidad distinta de cero . Como esto no puede verificarse desde algunas realizaciones del programa, explique cómo su código cumple con esto.
  • Se permiten espacios en blanco iniciales o finales alrededor del borde.
  • Scontendrá son solo letras mayúsculas . Si lo desea, puede elegir tomar solo letras minúsculas .
  • La entrada y la salida son flexibles como de costumbre. Por ejemplo, la salida puede ser una cadena con nuevas líneas, una matriz de caracteres 2D o una lista de líneas.
  • Se permiten programas o funciones , en cualquier lenguaje de programación . Las lagunas estándar están prohibidas.
  • El código más corto en bytes gana.

Ejemplos

Las entradas se muestran como S, [M N], donde Mes el número de filas y el Nnúmero de columnas. El personaje #se usa para el borde.

'O', [1 1]:

###
#O#
###

'HEY', [1 3]:

#####
#YHE#
#####


'HELLO', [4 11]:

#############
#  O        #
#         H #
#    LE     #
#   L       #
#############


'ADVNJSGHETILMVXERTYIOJKCVNCSF', [8 12]:

##############
#K  V  L   S #
# A   V  X H #
#T    M C    #
# I       O N#
#  YC        #
# G  I   R SE#
#   J      F #
#JT  D  V EN #
##############


'OOOOOOOOOOXXXXX', [13 31]:

#################################
#    X                          #
#                O              #
#                               #
#                  X            #
#                        O      #
#             X           O     #
#      O                        #
#         X                     #
#                        O      #
#       X                       #
#                    O          #
#  O      O      O              #
#                             O #
#################################


'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ', [11 41]

###########################################
#                                       JU#
#     Q         C M    G     R T U Y  H   #
#  KI          E   H    M   YO            #
#      V BW        I    JC                #
#     SV           D     P   B          U #
#           A     F    RF   J  KP E       #
#            E   N      TH        Z       #
#    N  BM  O     Q   I        AS N  WX   #
#   S     O  K       G L       P       Q  #
#Z     L T         R   L       A      F DD#
#      V   Y           WX   C       G XZ  #
###########################################
Luis Mendo
fuente
"Las posiciones de las letras en el bol son aleatorias, [...]" <- ¿quiere decir que puede ser aleatorio o debe ser aleatorio? ¿Y pueden todas las líneas tener el mismo número de caracteres, todo el tiempo?
Ismael Miguel
@IsmaelMiguel Must . Y cada configuración debe tener una probabilidad distinta de cero (indicada en el desafío). Eso descarta el enfoque de siempre igual
Luis Mendo
¿Puede el borde ser coherente en las ejecuciones del programa y los valores de entrada, pero usar múltiples no letras, por ejemplo, dibujar un borde de arte ASCII |+-?
Adám
@ Adám Hm voy a decir que no, eso es un cambio demasiado grande
Luis Mendo

Respuestas:

13

05AB1E , 20 18 16 15 14 bytes

*j.rS²ô2Føε8.ø

Toma tres entradas en el orden: altura, ancho, cadena. Salida como una lista 2D de caracteres.
Se usa 8como borde, pero podría ser cualquier dígito.

-1 byte gracias a @Grimy .

Pruébelo en línea o verifique todos los casos de prueba . (TIO contiene }}J»en el pie de página para imprimir el resultado; no dude en eliminarlo para ver la lista de caracteres 2D de salida real en su lugar).

Explicación:

*               # Multiply the (implicit) width and height inputs
 j              # Pad the (implicit) input-string with up to that amount of leading spaces,
                # so the total string-length is equal to that value
  .r            # Shuffle the characters in the string
    S           # Convert the string to a list of characters
                # (edge-case for the zip below with strings of size 1 with 1x1 dimensions)
     ²          # Push the width input again
      ô         # Split the list of characters into parts of that size
       2F       # Loop 2 times:
         ø      #  Zip/transpose the 2D list; swapping rows/columns
          ε     #  Inner map over each line:
           8.ø  #   And surround this line-list with a leading/trailing "8"
                # (after the loop, the result is output implicitly)
Kevin Cruijssen
fuente
1
@LuisMendo En realidad solo digo el desafío hace 3 minutos. ;) Es una implementación bastante sencilla. Trataré de jugar golf desde aquí.
Kevin Cruijssen
1
Muy bien, no lo pensé *j! Aquí hay 13 para legado , o un feo 14 para moderno (genera una matriz de caracteres 2D).
Grimmy
1
@Grimy El 13-byter parece fallar en la entrada 1,1,"O", por lo que creo que también tiene que ser el 14-byter para el legado. Gracias por -1 sin embargo.
Kevin Cruijssen
7

APL (Dyalog Unicode) , SBCS de 25 bytes

'#',∘⌽∘⍉⍣4{⍵⍴⊃¨↓∘⍺¨?⍨×/⍵}

Pruébalo en línea!

-22 gracias a @ngn, -7 gracias a @ngn y @ Adám

Explicación:

'#',∘⌽∘⍉⍣4{⍵⍴⊃¨↓∘⍺¨?⍨×/⍵}
          {            ⍵}  Function that generates the content
                            argument:  (width and height),  (string)
                     ×/    get the product
                   ?⍨      For each randomized elements
               ↓∘⍺¨        take the character in 
           ⍵⍴⊃¨            turn it back into a matrix of shape 
      4                 Then, 4 times, do these 3 things:
'#',                       - prepend a # to the axis
                          - reverse the columns
                          - swap columns and lines

APL (Dyalog Extended) , SBCS de 21 bytes

Los ángulos de la llanta son caracteres diferentes.

{⌂disp⊂⍵⍴⊃¨↓∘⍺¨?⍨×/⍵}

Pruébalo en línea!

Usando el dfn para mostrar el cuadro.

Ven
fuente
29: ¡ '#',∘⌽∘⍉⍣4⊢⍴∘(?⍨∘≢⊃¨⊂)↑⍨∘(×/) Pruébalo en línea!
Adám
28: {'#',∘⌽∘⍉⍣4⊢⍵⍴⍺\⍨(≢⍺)>?⍨×/⍵}(o en lugar de >if ⎕io=1)
ngn
en realidad, 27:'#',∘⌽∘⍉⍣4{⍵⍴⍺\⍨(≢⍺)>?⍨×/⍵}
ngn
3
25:'#',∘⌽∘⍉⍣4{⍵⍴⊃¨↓∘⍺¨?⍨×/⍵}
ngn
Sobre el 21
Adám
6

Python 3 , 110 bytes

lambda s,m,n,r=['#']:[r+(n*r+[i for i,j in{*zip(s+m*n*' ',range(m*n))}]+n*r)[k*n:-~k*n]+r for k in range(m+2)]

Pruébalo en línea!

Aleatoriza utilizando una setcomprensión y devuelve una matriz de caracteres 2D.

Jitse
fuente
Buen uso de la comprensión del conjunto para aleatorizar. +1. Pero sus códigos se basan en el nombre 'f' de la función. Por lo tanto creo que la solución lambda no es válido ...
agtoever
1
@agtoever Gracias! La función no es recursiva, por lo que puede ser anónima. ¿Te refieres a la f'{s:{m*n}}'parte? Porque esa es la sintaxis de una cadena formateada, que casualmente también comienza con un f.
Jitse
3
Este código parece violar PEP 8 de varias maneras.
Christofer Ohlsson
1
@ Christofer-Ohlsson absolutamente!
Jitse
2
@ChristoferOhlsson Bienvenido al mundo del code-golf, jaja. ;) No hay comentarios / documentos de ningún tipo; variables / métodos de un solo carácter sin espacios (innecesarios) / líneas nuevas; potencialmente cientos de advertencias del compilador que simplemente ignoramos; aumento del rendimiento de O (log (N)) a O (N ^ N); etc. Si puede guardar incluso un solo byte, todo está bien y vale la pena para jugar golf en código. ;)
Kevin Cruijssen
5

Bash + coreutils, 139 125 caracteres

r=`printf %$3s@@|tr \  @`
echo $r
printf %$[$2*$3]s $1|fold -1|shuf|tr -d \\n|fold -$3|paste -d@ <(:) - <(:)|head -$2
echo $r

Ejecución de muestra:

bash-5.0$ bash soup.sh HELLO 4 11
@@@@@@@@@@@@@
@  H        @
@      OE   @
@    L      @
@          L@
@@@@@@@@@@@@@

Pruébalo en línea!

Bash + coreutils + boxes, 97 caracteres

printf %$[$2*$3]s $1|fold -1|shuf|tr -d \\n|fold -$3|boxes -dsimple -s$[$3+2]x$[$2+2] -pa0 -itext

Ejecución de muestra:

bash-5.0$ set -- HELLO 4 11

bash-5.0$ printf %$[$2*$3]s $1|fold -1|shuf|tr -d \\n|fold -$3|boxes -dsimple -s$[$3+2]x$[$2+2] -pa0 -itext
*************
* O   L  E  *
*      H    *
*           *
*     L     *
*************

Pruébalo en línea! (Parcialmente, ya boxesque no está instalado en TIO).

hombre trabajando
fuente
5

J , 30 29 bytes

-1 byte gracias a Jonás

'#'|.@|:@,^:4[$*/@[(?~@[{{.)]

Pruébalo en línea!

Galen Ivanov
fuente
1
Porque TIO usa una semilla aleatoria fija. 9!:1]6!:9''arregla eso
Adám
2
Realmente me gusta la forma en que se usa el relleno cero {.. Ligero ajuste para 29 '#'|.@|:@,^:4[$*/@[(?~@[{{.)]: ¡ Pruébelo en línea!
Jonás
1
@ Jonás ¡Gracias!
Galen Ivanov
5

PowerShell , 163 111 93 bytes

param($w,$h,$s)'#'*$w+-join($s|% *ht($w*$h)|% t*y|sort{Random})+'#'*$w-replace".{$w}",'#$0#
'

Pruébalo en línea!

Toma la entrada como $width,$h ocho,$s tring.

Construye una cadena de #la $width apropiada , une la cadena con algunos cálculos, y luego esa misma #cadena nuevamente. El cálculo comienza con la toma de la entrada de $sTring, y haciendo un .padRig hthasta el $width por $hocho longitud (es decir, hacen una cadena de tiempo suficiente para tomar por completo el espacio rectangular. Entonces convertimos esa cadena toCharArra y, y sortse RandomLy. Eso le da nosotros la parte media mezclada. Finalmente, la dividimos -replaceen trozos de igual $width y rodeamos esos trozos con# s.

-52 gracias a la inspiración de AZTECCO
-18 bytes gracias a mazzy

AdmBorkBork
fuente
Tienes 2 veces al azar (12) mientras que JS tiene uno, agregó espacios para llenar el tamaño M * N y ordenó, después de eso todavía pagas 21 por '$' desafortunadamente
AZTECCO
1
@AZTECCO ¡Gracias por la inspiración!
AdmBorkBork
Gracias @mazzy, muy inteligente con el en -replacelugar de dividir y unir.
AdmBorkBork
4

JavaScript (ES7), 125 bytes

Devuelve una cadena. Usos 0como el carácter del marco.

(s,h,w)=>(a=[...s.padEnd(w++*h++)].sort(_=>Math.random()-.5),g=x=>y+~h?(x%w&&y%h&&a.pop())+[`
`[x-w]]+g(x<w?x+1:!++y):a)(y=0)

Pruébalo en línea!

Comentado

(s, h, w) => (               // s = string; h = height; w = width
  a =                        // build an array a[] consisting of:
    [...s.padEnd(w++ * h++)] //   all original characters in s padded with spaces for a
    .sort(_ =>               //   total length of w * h, in a random order
      Math.random() - .5     //   (this is not guaranteed to be uniform, but it is not
    ),                       //   required to be)
  g = x =>                   // g is a recursive function taking x:
    y + ~h ?                 //   if we haven't reached the end of the grid:
      ( x % w &&             //     if we're not located on a vertical border
        y % h &&             //     nor on a horizontal border,
        a.pop()              //     extract the last character from a[]
      ) +                    //     (otherwise, append '0')
      [`\n`[x - w]] +        //     if we've reached the end of the row, append a linefeed
      g(                     //     append the result of a recursive call:
        x < w ? x + 1 : !++y //       using either (x+1, y) or (0, y+1)
      )                      //     end of recursive call
    :                        //   else (end of grid):
      a                      //     a[] is now empty and can be used as an empty string
)(y = 0)                     // initial call to g with x = y = 0
Arnauld
fuente
4

APL (Dyalog Extended) , 23 bytes SBCS de

Función de infijo tácito anónimo. Toma [M,N]como argumento izquierdo y Scomo argumento derecho.

'#',∘⌽∘⍉⍣4⊣⍴×/⍛(?⍨⍤⊣⊇↑)

Pruébalo en línea!

×/⍛(...)  aplique la siguiente función entre los argumentos, reemplazando el argumento izquierdo con su producto:

 tomar M× Npersonajes deS , relleno con espacios a la derecha

 reordena eso al siguiente orden:

?⍨⍤ los índices barajados 1 a ...
 el argumento izquierdo ( M× N)

r dale forma a la siguiente forma:

 el argumento izquierdo (es decir, Mfilas yN columnas)

'#'⍣4 Aplique la siguiente función cuatro veces, cada vez con el carácter hash como argumento izquierdo:
∘⍉ transponga el argumento derecho
∘⌽ refleje el argumento derecho
,concatene una columna de hashes al lado izquierdo de ese

Adán
fuente
4

PHP 7.4, 107 99 94 caracteres

fn($s,$r,$c)=>_.chunk_split(($b=str_pad(_,$c,_)).str_shuffle(str_pad($s,$r*$c)),$c,"_
_").$b._

Gracias a:

  • Ismael Miguel por recordarme sobre las funciones de flecha de PHP 7.4 (-10 caracteres)
  • Night2 para revertir eficientemente las concatenaciones y eljoin() (-8 caracteres)
  • Night2 para mostrar cómo usar chunk_split()el $endparámetro (-5 caracteres)

Pruébalo en línea!

PHP 7.3, 117 112 108 caracteres

function s($s,$r,$c){echo _.chunk_split(($b=str_pad(_,$c,_)).str_shuffle(str_pad($s,$r*$c)),$c,"_
_").$b._;}

Gracias a:

  • Night2 para invertir eficientemente las concatenaciones y los join()(-5 caracteres)
  • Night2 para mostrar cómo usar chunk_split()el $endparámetro (-4 caracteres)

Ejecución de muestra:

php > function s($s,$r,$c){echo _.chunk_split(($b=str_pad(_,$c,_)).str_shuffle(str_pad($s,$r*$c)),$c,"_
php " _").$b._;}
php > s('HELLO', 4, 11);
_____________
_  L        _
_        L  _
_E          _
_    OH     _
_____________

Pruébalo en línea!

hombre trabajando
fuente
1
Creo que fn($s,$r,$c)=>($b=str_repeat(9,$c+2))."\n9".join("9\n9".str_split(str_shuffle(str_pad($s,$r*$c)),$c))."9\n$b";debería funcionar en PHP 7.4 ( wiki.php.net/rfc/arrow_functions_v2 ), y se lanzó un canditate de lanzamiento ( wiki.php.net/todo/php74 ), por lo que es un "compilador" disponible que vino antes de este desafío, y cualquiera puede usarlo.
Ismael Miguel
1
Doh, tienes razón. Lea sobre, pero se olvidó. (Nota para mí misma: la próxima vez se limite a leer Night2 's punta Upvote también, tal vez ayuda a recordar..)
manatwork
2
99 bytes
Noche2
1
Gracias, @ Night2. No puedo imaginar lo que estropeé ayer, mientras intentaba mover más cosas dentro join(), pero no pude reducir el tamaño. ☹
manatwork
1
Incluso tengo uno más corto usando chunk_split: 94 bytes obtuve . También eliminé el último punto y coma, ya que creo que no es necesario, ha escrito una función, por lo que el código que la asignará a una variable no debe contar.
Noche2
3

MATL , 22 19 bytes

tZ"ibpyn&Z@(TT35&Ya

Pruébalo en línea!

Gracias @LuisMendo por guardar 3 bytes, por lo que ahora tiene el mismo bytecount que la respuesta de @ flawr , pero lo suficientemente diferente como para publicar de todos modos. Descripción general del agoritmo de alto nivel:

 Z"                  % Create n x m matrix of spaces
           (         % Index into this matrix:
   i                 %  The alphabet vermicelli (explicit input)
        &Z@          %  at a random locations (randperm), which are
      yn             %   length(S) numbers, ranging
t   bp               %   from 1 to n*m
            TT35&Ya  % And finally add a border
Sanchises
fuente
Puedes cambiar Z}&Opor Z", y eso también te permite eliminar la finalc
Luis Mendo
@LuisMendo ¡Oh, eso ayuda mucho! Ahora que lo pienso, al menos debería haberlo hecho 1$O.
Sanchises
3

Ruby , 121 bytes

Crea el cuenco, consulta los índices de todos los espacios dentro del cuenco, muestrea un número de espacios igual al tamaño de la cadena y los completa. sampleNo devuelve una lista ordenada, por lo que no es necesario barajarlos. La búsqueda de índices hasta 9*m*n(que casi con seguridad se sale de rango) seguirá obteniendo todos los espacios y es 1 byte más corto que r.size.

->s,m,n{r=[t=?@*(n+2),*["@#{' '*n}@"]*m,t]*$/;i=-1;(0..9*m*n).select{|j|r[j]==' '}.sample(s.size).map{|j|r[j]=s[i+=1]};r}

Pruébalo en línea!

Tinta de valor
fuente
3

rojo , 120 116 114 112 bytes

-2 bytes gracias a @Kevin Cruijssen!

func[s m n][random pad s m * n insert/dup t: copy"00"0 n
print t loop m[print rejoin[0 take/part s n 0]]print t]

Pruébalo en línea!

Galen Ivanov
fuente
2
-2 bytes al deshacerse de + 1y usar en su to"""00"0 nlugar.
Kevin Cruijssen
1
@KevinCruijssen ¡Gracias! Lo reemplacé copypor el mismo número de bytes.
Galen Ivanov
1
¡De hecho, se ve un poco más limpio! No conozco a Red, excepto por las respuestas que he visto de ti, así que solo estaba jugando un poco. ;) ¿Sería más corto poner la tlínea como elemento inicial / final antes de hacer un bucle para guardar en los dos elementos sueltos print t? Lo dudo, pero como no sé cómo agregar elementos a una lista, no estoy seguro.
Kevin Cruijssen
3

Perl 6 , 74 67 bytes

-5 bytes gracias a Jo King

{0 X~0 x$^n,|comb($n,[~] $^s.comb[pick *,^$^m*$n]X//' '),0 x$n X~0}

Pruébalo en línea!

Explicación

{                                                                 }
                                         ^$^m*$n  # Range 0 .. M*N-1
                                  pick *,  # Shuffle
                         $^s.comb  # Split S into chars
                                 [              ]  # Pick shuffled elements
                                                 X//' '  # undef to space
                     [~]  # Join
             # Split into n-character strings
             comb($n,                                  )
            |  # Flatten
     # Add top and bottom of bowl
     0 x$^n,                                            ,0 x$n
 # Add left and right of bowl
 0 X~                                                          X~0
nwellnhof
fuente
69 bytes
Jo King
3

Perl 5 -lF , 99 97 bytes

-2 bytes cortesía de @NahuelFouilleul

%k=map{$_=>$F[$_]||$"}0..($m=<>)*($n=<>)-1;say+($p='#'x($n+1)),map"#
#"x!($i++%$n).$_,values%k,$p

Pruébalo en línea!

Xcali
fuente
($i++%$n==0)podría ser cambiado por!($i++%$n)
Nahuel Fouilleul
3

k4, 32 28 bytes

{4{|+x,'"#"}/y#a?(a:-*/y)$x}

editar: -4 gracias a Galen Ivanov!

llamado como

f["hey";3 3]

explicación:

                 (a:-*/y)    / neg product of y and assign to a 
                         $x  / left pad x so we have char vector the length of the inner area
               a?            / take `a` random drawings. if a is negative, draw with no duplicates/replacements
             y#              / reshape to y's dimensions
 4{        }/                / do {} 4 times 
   |+x,'"#"                  / append "#" along right-side of x then transpose (+) and reverse (|)
garabatear
fuente
1
Creo que puede guardar algunos bytes si solo agrega #al final de cada línea y transpone / invierte 4 veces, algo como esto .
Galen Ivanov
1
@GalenIvanov agradable, actualizado!
garabato
3

Java (JDK) , 180 178 bytes

Ni una sola importación extra:

(y,m,n)->{for(m*=n;y.length()<m;y+=" ");var s="";for(;m-->0;y=s)for(var c:y.split(s=""))s=Math.random()<.5?s+c:c+s;s="#".repeat(n);return(s+y+s).replaceAll(".{"+n+"}","\n#$0#");}

Pruébalo en línea!

Fue toda una lucha conseguir que esto se redujera. En particular, las importaciones relacionadas con los métodos Collections.shuffle () / Arrays eran demasiado para aceptar, por lo que tuve que crear mi propio algoritmo de barajado de cadenas (probablemente ni eficiente ni distribuido uniformemente). Enormes gracias a Steven por demostrar que se puede generar cualquier conjunto de posiciones partir del algoritmo.

Formateado (con explicación):

(y, m, n) ->                                                   // y = yummies in the soup,
{                                                              // m = height, n = width
    for (m *= n; y.length() < m; y += " ")                     // set m to m*n and
        ;                                                      // add spaces to y to fill up
    var s = "";                                                // the rest of the soup
    for (; m-- > 0; y = s)                                     // for m*n iterations, scramble y
        for (var c : y.split(s = ""))                          // with random appends
            s = Math.random() < .5 ? s + c : c + s;
    s = "#".repeat(n);                                         // create the top/bottom of the rim
    return (s + y + s).replaceAll(".{" + n + "}", "\n#$0#"); // add all sides of the rim
};
Avi
fuente
¡Buena respuesta! +1 de mi parte Una pequeña cosa para el golf: .replaceAll("(.{"+n+"})","\n#$1#")puede convertirse.replaceAll(".{"+n+"}","\n#$0#")
Kevin Cruijssen
@KevinCruijssen Gracias por la mejora :)
Avi
2

Carbón , 27 bytes

NθNη↖B⁺²θ⁺²η#FS«W℅KKJ‽θ‽ηPι

Pruébalo en línea!El enlace es a la versión detallada del código. Toma entrada en el orden ancho, alto, cadena. Explicación:

NθNη

Ingrese el ancho y la altura.

↖B⁺²θ⁺²η#

Enmarca el tazón.

FS«

Recorre los caracteres de la cadena.

W℅KKJ‽θ‽η

Salta a una posición aleatoria en el tazón hasta encontrar un lugar vacío.

Pι

Imprime el carácter actual sin mover el cursor.

Neil
fuente
¿Es eso Move(:UpLeft)necesario? Funciona bien sin él, pero ¿tal vez lo has agregado por una razón en la que no pienso?
Kevin Cruijssen
1
@KevinCruijssen Sin él, nunca podría escribir letras en la fila inferior o en la columna de la derecha.
Neil
Ah, eso fue todo. Eso lo explica, gracias!
Kevin Cruijssen
2

Japt -R , 21 18 bytes

úV*W ö¬òW ²Ô²û2W+2

Intentalo

úV*W ö¬òW ²Ô²û2W+2     :Implicit input of string U=S and integers V=M & W=N
úV*W                   :Right pad U with spaces to length V*W
     ö¬                :Random permutation
       òW              :Split to array of strings of length W
          ²            :Push 2
           Ô           :Reverse
            ²          :Push 2
             û2W+2     :Centre pad each element with "2" to length W+2
                       :Implicit output, joined with newlines
Lanudo
fuente
2

MATL , 29 27 19 bytes

pZ@iy~hw)1GeTT35&Ya

Pruébalo en línea!

¡Gracias @LuisMendo por -8 bytes!

Explicación: pcalcula el número de píxeles de sopa. Luego Z@produce una permutación aleatoria del tamaño del número de píxeles de sopa. Usaremos esto como índices a los iy~hcuales se encuentra la cadena de entrada con suficientes espacios agregados. w)intercambia los dos e indexa uno con el otro. Luego volvemos a dar 1Geforma a la forma en el rectángulo deseado y lo #rellenamos con TT35&Ya.

falla
fuente
2
¡Inteligente! Mi intento fue de 22 bytes
Sanchises
2
@Sanchises ¡Ve a publicarlo de todos modos!
falla
2

T-SQL 2017, 232 bytes

Probar esto en línea es una versión anterior de sql-server que cuesta otro personaje. Publiqué la versión más corta.

Golfizado:

DECLARE @ varchar(max)=''SELECT top 999 @+=substring(@i,number+1,1)FROM spt_values
WHERE type='P'and number<@a*@b
ORDER BY newid()WHILE-@b<1SELECT @=stuff(@+' ',@b*@a+1,0,'#
#'),@b-=1PRINT stuff(replicate('#',2+2*@a),2+@a,0,trim(@))

Pruébalo en línea

Sin golf:

DECLARE @ varchar(max)=''

SELECT top 999 @+=substring(@i,number+1,1)
FROM spt_values
WHERE type='P'and number<@a*@b
ORDER BY newid()

WHILE-@b<1
SELECT @=stuff(@+' ',@b*@a+1,0,'#
#'),@b-=1
PRINT stuff(replicate('#',2+2*@a),2+@a,0,trim(@))
t-clausen.dk
fuente
2

C (sonido metálico) , 169 164 162 160 bytes

i,b;f(n,m,s)char*s;{char*a,o[b=i=-~++n*(m+=3)];for(srand(time(a=o));--i;)*a++=i%m?-~i%m<3|i<m|i>m*n?35:32:10;for(*a=0;*s;*a=*a-32?*a:*s++)a=o+rand()%b;puts(o);}

Pruébalo en línea!

-2 poniendo a = o en time () call // for (srand (time (a = o)); ...

Se guardó la sugerencia de 7 @ceilingcat para usar: ~ almacenamiento variable y automático para la cadena o más muchas mejoras.

Degolf:

char*a,// pointer for set operations 
*o=malloc(b=i=(m+=3)*(n+=2));  => o[b=i=(m+=3)*-~++n]
// before allocating for the whole bowl as a char array
// increments m by 3 (2 for rims and 1 for '\n') and n by one but allocates for 2(rims)
// and assigns bowl size to i and b.
srand(time(0));// seeds rand function 
for(// loop to make empty bowl 
a=o;// using pointer as iterator
 --i ;)//  i decremented as a counter

 *a=// sets every char to..
 i%m?// if(not) over right side of bowl (m+3)
   -~i%m<3|i<m|i>m*n-m?35// if on rim '#'//-~i == (i+1)
   :32 // else ' ' 
  :10;// i%m==0

for(*a=0;// before loop terminates bowl with \0
 *s;// for every letters(exit on '\n')
 *a=*a-32?*a:*s++)
 // puts letter if bowl at a is a space and
 // go to next letter

 a=o+rand()%b; 
 // sets a to o offsetted by random

puts(o);// prints bowl 
AZTECCO
fuente
Sugerir en *a=--i;)*a++=i%m?-~i%m<3|i<m|i>m*n?35:32:10;for(;lugar de--i;)*a++=i%m?-~i%m<3|i<m|i>m*n?35:32:10;for(*a=0;
ceilingcat
@ceilingcat debería funcionar, pero por alguna razón da resultados incorrectos en los últimos 2 casos de prueba
AZTECCO
2

Icono , 136 133 131 118 bytes

procedure f(s,n,m)
s||:=repl(" ",m*n-*s)
!s:=:?s&\z
write(t:=repl(0,m+2))
write(0,s[1+(0to n)*m+:m],0)&\z
write(t)
end

Pruébalo en línea!

Galen Ivanov
fuente
1

Jalea , 16 bytes

P⁶ẋaẊs⁸ṪṾ€«”~ZƊ⁺

Un enlace diádico que acepta una lista de enteros, [M, N]a la izquierda y una lista de caracteres S, a la derecha que produce una lista de listas de caracteres, las líneas. Utiliza el carácter tilde ~, como borde.

Pruébalo en línea!

Todas las salidas posibles tienen una probabilidad distinta de cero de ser producidas ya que barajamos ( ) una lista de los caracteres Sjunto con el número apropiado de espacios.

El código Ṿ€«”~ZƊ⁺guarda el byte que imagino que se necesitaría para unirse a las nuevas líneas que los programas completos que usan un número entero como cero necesitarían emplear (por ejemplo, P⁶ẋaẊs⁸Ṫ;€0ZUƊ4¡Yo P⁶ẋaẊs⁸Ṫj@€Ø0Z$⁺Y). Tal vez hay una manera de ahorrar más ...?

Jonathan Allan
fuente