Il semble que nous ne nous lassions jamais des défis liés à l'alphabet ...

La recette

Donné

• une chaîne de lettres S, et
• deux entiers positifs M, N,

produire une soupe alphabétique avec les lettres d' Soccuper des positions aléatoires dans un bol rectangulaire de taille M× N, encadrée par un caractère non alphabétique et non spatial pour représenter le bord du bol.

Les positions non utilisées par les lettres doivent être affichées sous forme d'espaces. Voir les exemples ci-dessous .

Règles supplémentaires

• La taille M× Nfait référence à l' intérieur du bol. La taille incluant la jante est M+2× N+2.
• Chaque personnage de Sdevrait apparaître une fois dans le bol, dans une position différente ; c'est-à-dire qu'un caractère ne peut pas en écraser un autre.
• S peut contenir des doublons . Par exemple, si Sest la chaîne 'abcc', la soupe doit contenir un a, un bet deux c(tous dans des positions différentes).
• Les entrées satisferont les restrictions M >= 1 , N >= 1, 1 <= length(S) <= M*N.
• Le bord du bol peut être n'importe quel caractère non alphabétique, sans espace , cohérent entre les exécutions de programme et les valeurs d'entrée.
• Les positions des lettres dans le bol sont aléatoires, le résultat peut donc différer à chaque exécution du programme avec les mêmes entrées.
• Compte tenu de l'entrée, chaque ensemble possible de positions de lettres doit avoir une probabilité non nulle . Comme cela ne peut pas être vérifié à partir de quelques réalisations du programme, veuillez expliquer comment votre code remplit cela.
• Les espaces blancs avant ou arrière autour de la jante sont autorisés.
• Sne contiendra que des lettres majuscules . Si vous le souhaitez, vous pouvez choisir de ne prendre que des lettres minuscules .
• L'entrée et la sortie sont flexibles comme d'habitude. Par exemple, la sortie peut être une chaîne avec des retours à la ligne, un tableau de caractères 2D ou une liste de lignes.
• Les programmes ou fonctions sont autorisés, dans n'importe quel langage de programmation . Les failles standard sont interdites.
• Le code le plus court en octets gagne.

Exemples

Les entrées sont représentées par S, [M N], où Mest le nombre de lignes et le Nnombre de colonnes. Le caractère #est utilisé pour la jante.

'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  #
###########################################

05AB1E , 20 18 16 15 14 octets

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

Prend trois entrées dans l'ordre: hauteur, largeur, chaîne. Sortie sous forme de liste 2D de caractères.
Utilise 8comme bordure, mais peut être n'importe quel chiffre.

-1 octet grâce à @Grimy .

Essayez-le en ligne ou vérifiez tous les cas de test . (TIO contient }}J»dans le pied de page pour imprimer le résultat; n'hésitez pas à le supprimer pour voir la liste 2D réelle des caractères à la place.)

Explication:

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

APL (Dyalog Unicode) , 25 octets ^SBCS

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

Essayez-le en ligne!

-22 grâce à @ngn, -7 grâce à @ngn et @ Adám

Explication:

'#',∘⌽∘⍉⍣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) , 21 octets ^SBCS

Les angles de la jante sont des caractères différents

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

Essayez-le en ligne!

Utilisation du dfn pour afficher la boîte.

Python 3 , 110 octets

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

Essayez-le en ligne!

Randomise en utilisant une setcompréhension et renvoie un tableau de caractères 2D.

Bash + coreutils, 139 125 caractères

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

Exemple d'exécution:

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

Essayez-le en ligne!

Bash + coreutils + boxes, 97 caractères

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

Exemple d'exécution:

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

Essayez-le en ligne! (En partie, car il boxesn'est pas installé sur TIO.)

J , 30 29 octets

-1 octet grâce à Jonah

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

Essayez-le en ligne!

PowerShell , 163 111 93 octets

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

Essayez-le en ligne!

Prend l'entrée comme $width, $hhuit, $string.

Construit une chaîne de #l' $width approprié , chaîne-joint cela avec du calcul, puis à nouveau cette même #chaîne. Le calcul commence par prendre le $string d' entrée , et faire un .padRig htjusqu'à l' $width de $hhuit longueurs (c'est-à-dire, faire une chaîne assez longue pour occuper complètement l'espace rectangulaire. Nous convertissons ensuite cette chaîne toCharArra y, et sortelle Randomly. Cela donne nous la partie médiane mélangée. Enfin, nous la -replacedivisons en morceaux d'égale $width, et entourons ces morceaux de #s.

-52 grâce à l'inspiration d'AZTECCO
-18 octets grâce à mazzy

JavaScript (ES7), 125 octets

Renvoie une chaîne. Utilise 0comme caractère de trame.

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

Essayez-le en ligne!

Commenté

(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

APL (Dyalog Extended) , 23 octets ^SBCS

Fonction infixe tacite anonyme. Prend [M,N]comme argument de gauche et Scomme argument de droite.

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

Essayez-le en ligne!

×/⍛(… ) Appliquer la fonction suivante entre les arguments, en remplaçant l'argument gauche par son produit:

 ↑ prendre M× Ncaractères de S, remplissage avec des espaces à droite

 ⊇ réorganiser cela dans l'ordre suivant:

 ?⍨⍤ les indices mélangés de 1 à…
 ⊣ l'argument de gauche ( M× N)

⍴ r Eshape que de la forme suivante:

⊣ l'argument de gauche (c'est-à-dire les Mlignes et les Ncolonnes)

'#'… ⍣4 Appliquer la fonction suivante quatre fois, chaque fois avec le caractère de hachage comme argument de gauche:
 ∘⍉ transposer l'argument de droite
 ∘⌽ refléter l'argument de droite
 ,concaténer une colonne de hachages sur le côté gauche de celui-ci

PHP 7.4, 107 99 94 caractères

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

Grâce à:

• Ismael Miguel pour m'avoir rappelé les fonctions flèches de PHP 7.4 (-10 caractères)
• Night2 pour inverser efficacement les concaténations et les join()(-8 caractères)
• Night2 pour montrer comment utiliser chunk_split()le $endparamètre de (-5 caractères)

Essayez-le en ligne!

PHP 7.3, 117 112 108 caractères

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

Grâce à:

• Night2 pour inverser efficacement les concaténations et les join()(-5 caractères)
• Night2 pour montrer comment utiliser chunk_split()le $endparamètre de (-4 caractères)

Exemple d'exécution:

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     _
_____________

Essayez-le en ligne!

MATL , 22 19 octets

tZ"ibpyn&Z@(TT35&Ya

Essayez-le en ligne!

Merci à @LuisMendo d'avoir économisé 3 octets, alors maintenant, il a le même octet que la réponse de @ flawr , mais suffisamment différent pour publier quand même. Présentation de l'agorithme de haut niveau:

 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

Rubis , 121 octets

Crée le bol, interroge les index de tous les espaces du bol, échantillonne un nombre d'espaces égal à la taille de la chaîne et les remplit. sampleNe renvoie pas de liste triée, il n'est donc pas nécessaire de mélanger. La recherche d'indices jusqu'à 9*m*n(qui va presque certainement hors de portée) obtiendra toujours tous les espaces et est 1 octet plus courte 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}

Essayez-le en ligne!

Rouge , 120 116 114 112 octets

-2 octets grâce à @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]

Essayez-le en ligne!

Perl 6 , 74 67 octets

-5 octets grâce à Jo King

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

Essayez-le en ligne!

Explication

{                                                                 }
                                         ^$^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

Perl 5 -lF , 99 97 octets

-2 octets avec l'aimable autorisation de @NahuelFouilleul

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

Essayez-le en ligne!

k4, 32 28 octets

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

edit: -4 grâce à Galen Ivanov!

appelé comme

f["hey";3 3]

explication:

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

Java (JDK) , 180 178 octets

Pas une seule importation supplémentaire:

(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#");}

Essayez-le en ligne!

Ce fut toute la lutte pour obtenir ce golf. En particulier, les importations impliquées avec les méthodes Collections.shuffle () / Arrays étaient trop à accepter, j'ai donc dû créer mon propre algorithme de réarrangement de chaîne (probablement ni efficace ni uniformément distribué). Un grand merci à Steven pour prouvé que n'importe quel ensemble de positions peut être généré à partir de l'algorithme.

Formaté (avec explication):

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

Fusain , 27 octets

ＮθＮη↖Ｂ⁺²θ⁺²η#ＦＳ«Ｗ℅ＫＫＪ‽θ‽ηＰι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend la saisie dans l'ordre largeur, hauteur, chaîne. Explication:

ＮθＮη

Saisissez la largeur et la hauteur.

↖Ｂ⁺²θ⁺²η#

Cadrez le bol.

ＦＳ«

Faites une boucle sur les caractères de la chaîne.

Ｗ℅ＫＫＪ‽θ‽η

Sautez à une position aléatoire dans le bol jusqu'à ce qu'un endroit vide soit trouvé.

Ｐι

Imprimez le caractère actuel sans déplacer le curseur.

Japt -R , 21 18 octets

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

Essayez-le

ú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

MATL , 29 27 19 octets

pZ@iy~hw)1GeTT35&Ya

Essayez-le en ligne!

Merci @LuisMendo pour -8 octets!

Explication: pcalcule le nombre de pixels de soupe. Z@Produit ensuite une permutation aléatoire de la taille du nombre de pixels de la soupe. Nous l'utiliserons comme des indices iy~hauxquels est la chaîne d'entrée avec suffisamment d'espaces ajoutés. w)échange les deux et indexe l'un avec l'autre. Nous remodelons ensuite 1Gela forme dans le rectangle souhaité et la #remplissons à l'aide de TT35&Ya.

T-SQL 2017, 232 octets

Le test en ligne est une ancienne version de sql-server qui coûte un autre personnage. J'ai posté la version courte.

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<1SELECT @=stuff(@+' ',@b*@a+1,0,'#
#'),@b-=1PRINT stuff(replicate('#',2+2*@a),2+@a,0,trim(@))

Essayez-le en ligne

Non 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(@))

C (clang) , 169 164 162 160 octets

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

Essayez-le en ligne!

-2 mettre a = o dans time () appeler // for (srand (time (a = o)); ...

7 suggestions @ceilingcat enregistrées pour utiliser - ~ variable et stockage automatique pour la chaîne o ainsi que de nombreuses améliorations.

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 

Icon , 136 133 131 118 octets

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

Essayez-le en ligne!

Gelée , 16 octets

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

Un lien dyadique acceptant une liste d'entiers, [M, N] à gauche et une liste de caractères S, à droite qui donne une liste de listes de caractères, les lignes. Utilise le caractère tilde,, ~comme bordure.

Essayez-le en ligne!

Toutes les sorties possibles ont une chance non nulle d'être cédées puisque nous mélangeons (Ẋ ) une liste des caractères deS ainsi que le nombre approprié d'espaces.

Le code Ṿ€«”~ZƊ⁺enregistre l'octet qui, j'imagine, serait nécessaire pour rejoindre les sauts de ligne que les programmes complets utilisant un entier tel que zéro devraient utiliser (par exemple P⁶ẋaẊs⁸Ṫ;€0ZUƊ4¡You P⁶ẋaẊs⁸Ṫj@€Ø0Z$⁺Y). Peut-être qu'il existe un moyen d'économiser plus ...?