Wir scheinen nie zu bekommen müde Alphabet bezogenen Herausforderungen ...

Das Rezept

Gegeben

• eine Folge von Buchstaben Sund
• zwei positive ganze Zahlen M, N,

Produziere eine Buchstabensuppe mit den Buchstaben S, die zufällige Positionen in einer rechteckigen Schüssel der Größe M× einnehmen N, umrahmt von einem nicht-alphabetischen Zeichen, das kein Leerzeichen ist, um den Rand der Schüssel darzustellen.

Positionen, die nicht von Buchstaben verwendet werden, sollten als Leerzeichen angezeigt werden. Siehe die folgenden Beispiele .

Zusätzliche Regeln

• Die Größe M× Nbezieht sich auf das Innere der Schüssel. Die Größe inklusive Rand beträgt M+2× N+2.
• Jedes Zeichen von Ssollte einmal in der Schüssel in einer anderen Position erscheinen . Das heißt, ein Zeichen kann kein anderes überschreiben.
• S kann Duplikate enthalten . Wenn es sich beispielsweise Sum die Zeichenfolge handelt 'abcc', muss die Suppe eine a, eine bund zwei enthalten c(alle an verschiedenen Positionen).
• Die Eingänge werden die erfüllen Einschränkungen M >= 1 , N >= 1, 1 <= length(S) <= M*N.
• Der Rand der Schüssel kann ein beliebiges nicht alphabetisches Zeichen ohne Leerzeichen sein , das für alle Programmläufe und Eingabewerte gleich ist.
• Die Buchstabenpositionen in der Schüssel sind zufällig, daher kann das Ergebnis bei jedem Ausführen des Programms mit denselben Eingaben abweichen.
• In Anbetracht der Eingabe sollte jeder mögliche Satz von Buchstabenpositionen eine Wahrscheinlichkeit ungleich Null haben . Da dies anhand einiger Programmrealisierungen nicht überprüft werden kann, erläutern Sie bitte, wie Ihr Code dies erfüllt.
• Führende oder nachfolgende Leerzeichen am Rand sind zulässig.
• Swird nur Großbuchstaben enthalten . Wenn Sie möchten, können Sie nur Kleinbuchstaben verwenden .
• Ein- und Ausgabe sind wie gewohnt flexibel . Beispielsweise kann die Ausgabe eine Zeichenfolge mit Zeilenumbrüchen, ein 2D-Zeichenarray oder eine Liste von Zeilen sein.
• Programme oder Funktionen sind in jeder Programmiersprache zulässig . Standardlücken sind verboten.
• Der kürzeste Code in Bytes gewinnt.

Beispiele

Eingaben werden angezeigt als S, [M N], wobei Mdie Anzahl der Zeilen und Ndie Anzahl der Spalten ist. Das Zeichen #wird für den Rand verwendet.

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

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

Nimmt drei Eingaben in der Reihenfolge auf: Höhe, Breite, Zeichenfolge. Ausgabe als 2D-Liste von Zeichen.
Verwendet 8als Grenze, könnte aber eine beliebige Ziffer sein.

-1 Byte dank @Grimy .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle . (TIO enthält }}J»in der Fußzeile einen hübschen Ausdruck des Ergebnisses. Sie können ihn auch entfernen, um stattdessen die tatsächliche 2D-Liste der ausgegebenen Zeichen anzuzeigen.)

Erläuterung:

*               # 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 Byte ^SBCS

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

Probieren Sie es online!

-22 danke an @ngn, -7 danke an @ngn und @ Adám

Erläuterung:

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

Die Winkel der Felge sind unterschiedliche Charaktere

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

Probieren Sie es online!

Verwenden Sie die DFN, um die Box anzuzeigen.

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

Probieren Sie es online!

Randomisiert mithilfe eines setVerständnisses und gibt ein 2D-Zeichenfeld zurück.

Bash + Coreutils, 139 125 Zeichen

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

Probelauf:

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

Probieren Sie es online!

Bash + Coreutils + Boxen, 97 Zeichen

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

Probelauf:

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

Probieren Sie es online! (Teilweise, da boxesnicht auf TIO installiert.)

J , 30 29 Bytes

-1 Byte danke an Jonah

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

Probieren Sie es online!

PowerShell , 163 111 93 Byte

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

Probieren Sie es online!

$wÜbernimmt die Eingabe als idth, $height, $string.

Erstellt eine Zeichenfolge mit #der entsprechenden $wID, verknüpft diese mit einer gewissen Berechnung und anschließend #erneut mit derselben Zeichenfolge. Die Berechnung beginnt mit der Eingabe von $string und dem Ausführen eines .padRig htbis zur $wLänge von idth x $h8 (dh, eine Zeichenfolge muss lang genug sein, um den rechteckigen Raum vollständig zu tbelegen) . Wir konvertieren dann die Zeichenfolge oCharArra yund sortes Randomergibt sich uns den durcheinandergebrachten Mittelteil, zum Schluss teilen wir -replaceihn in gleich große $wStücke und umgeben diese Stücke mit #s.

-52 dank der Inspiration von AZTECCO
-18 bytes dank mazzy

JavaScript (ES7), 125 Byte

Gibt eine Zeichenfolge zurück. Verwendet 0als Rahmenzeichen.

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

Probieren Sie es online!

Kommentiert

(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 Byte ^SBCS

Anonyme stillschweigende Infix-Funktion. Nimmt [M,N]als linkes Argument undS als rechtes Argument.

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

Probieren Sie es online!

×/⍛(…)  wende die folgende Funktion zwischen den Argumenten an und ersetze das linke Argument durch sein Produkt:

 ↑ nimm M× NZeichen vonS und fülle sie mit Leerzeichen auf der rechten Seite auf

 ⊇ ordne das in der folgenden Reihenfolge:

 ?⍨⍤ die gemischten Indizes 1 bis ...
 ⊣ das linke Argument ( M×N )

⍴ r eshape, die der folgenden Form:

⊣ das linke Argument (dh M Zeilen und NSpalten)

'#'… ⍣4 Wenden Sie die folgende Funktion viermal an, jeweils mit dem Rautezeichen als linkes Argument:
 ∘⍉ transponieren Sie das rechte Argument,
 ∘⌽ spiegeln Sie das rechte Argument und
 ,verketten Sie eine Spalte mit Rautezeichen auf der linken Seite

PHP 7.4, 107 99 94 Zeichen

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

Dank an:

• Ismael Miguel , der mich an die Pfeilfunktionen von PHP 7.4 erinnert hat (-10 Zeichen)
• Night2 zum effizienten Umkehren der Verkettungen und derjoin() (-8 Zeichen)
• Night2 zur Veranschaulichung der Verwendung chunk_split()des $endParameters (-5 Zeichen)

Probieren Sie es online!

PHP 7.3, 117 112 108 Zeichen

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

Dank an:

• Night2 zum effizienten Umkehren der Verkettungen und der join()(-5 Zeichen)
• Night2 zur Veranschaulichung der Verwendung chunk_split()des $endParameters (-4 Zeichen)

Probelauf:

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

Probieren Sie es online!

MATL , 22 19 Bytes

tZ"ibpyn&Z@(TT35&Ya

Probieren Sie es online!

Vielen Dank an @LuisMendo für das Speichern von 3 Bytes. Jetzt hat es den gleichen Bytecount wie die Antwort von @ flawr , aber ausreichend verschieden, um trotzdem zu posten. Überblick über den Agorithmus auf hoher Ebene:

 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

Ruby , 121 Bytes

Erstellt die Schüssel, fragt die Indizes aller Leerzeichen in der Schüssel ab, tastet eine Anzahl von Leerzeichen ab, die der Größe der Zeichenfolge entspricht, und füllt sie aus. Es samplewird keine sortierte Liste zurückgegeben, sodass kein Mischen erforderlich ist. Das Durchsuchen von Indizes bis 9*m*n(die mit ziemlicher Sicherheit außerhalb des Bereichs liegen) erhält weiterhin alle Leerzeichen und ist 1 Byte kürzer als 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}

Probieren Sie es online!

Rot , 120 116 114 112 Bytes

-2 Bytes dank @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]

Probieren Sie es online!

Perl 6 , 74 67 Bytes

-5 Bytes dank Jo King

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

Probieren Sie es online!

Erläuterung

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

-2 Bytes mit freundlicher Genehmigung von @NahuelFouilleul

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

Probieren Sie es online!

k4, 32 28 Bytes

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

edit: -4 danke an Galen Ivanov!

genannt wie

f["hey";3 3]

Erläuterung:

                 (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 bis 178 Byte

Kein einziger zusätzlicher Import:

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

Probieren Sie es online!

Es war ein ziemlicher Kampf, dieses Golfspiel zu gewinnen. Insbesondere die mit den Collections.shuffle () / Arrays-Methoden verbundenen Importe waren zu viel, um akzeptiert zu werden, sodass ich meinen eigenen String-Shuffling-Algorithmus erstellen musste (wahrscheinlich weder effizient noch gleichmäßig verteilt). Ein riesiges Dankeschön an Steven für den Beweis, dass eine Reihe von Positionen generiert werden kann dem Algorithmus kann.

Formatiert (mit Erklärung):

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

Kohle , 27 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Übernimmt die Eingabe in der Reihenfolge Breite, Höhe, Zeichenfolge. Erläuterung:

ＮθＮη

Geben Sie die Breite und Höhe ein.

↖Ｂ⁺²θ⁺²η#

Rahmen die Schüssel.

ＦＳ«

Schleife über die Zeichen in der Zeichenkette.

Ｗ℅ＫＫＪ‽θ‽η

Springe zu einer zufälligen Position in der Schüssel, bis eine leere Stelle gefunden wird.

Ｐι

Druckt das aktuelle Zeichen, ohne den Cursor zu bewegen.

Japt -R , 21 18 Bytes

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

Versuch es

ú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 Bytes

pZ@iy~hw)1GeTT35&Ya

Probieren Sie es online!

Danke @LuisMendo für -8 Bytes!

Erläuterung: pBerechnet die Anzahl der Suppenpixel. Dann Z@erzeugt eine zufällige Permutation der Größe der Anzahl von Pixeln Suppe. Wir werden dies als Indizes verwenden, zu iy~hdenen die Eingabezeichenfolge mit genügend Leerzeichen hinzugefügt wird. w)vertauscht die beiden und indiziert einen mit dem anderen. Wir formen dann 1Gedie Form in das gewünschte Rechteck um und #füllen es mit -pad auf TT35&Ya.

T-SQL 2017, 232 Byte

Dies online zu testen ist eine ältere Version von SQL-Server, die einen anderen Charakter kostet. Ich habe die kürzere Version gepostet.

Golf gespielt:

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

Probieren Sie es online aus

Ungolfed:

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 (Klappern) , 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);}

Probieren Sie es online!

-2 Setzen Sie a = o in time (), und rufen Sie // for (srand (time (a = o)) auf; ...

Gespeichert 7 @ceilingcat Vorschlag zur Verwendung von - ~ Variable und Auto-Speicher für Zeichenfolge o sowie viele Verbesserungen.

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

Probieren Sie es online!

Gelee , 16 Bytes

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

Ein dyadischer Link, der eine Liste von ganzen Zahlen [M, N]auf der linken Seite und eine Liste von Zeichen Sauf der rechten Seite akzeptiert, die eine Liste von Zeichenlisten , die Zeilen, ergibt. Verwendet das Tilde-Zeichen,~ , als Rahmen.

Probieren Sie es online!

Alle möglichen Ausgaben haben eine Wahrscheinlichkeit ungleich Null, dass sie ausgegeben werden, da wir Ẋeine Liste der Zeichen von shuffle ( ) erstellenS zusammen mit der entsprechenden Anzahl von Leerzeichen .

Der Code Ṿ€«”~ZƊ⁺speichert das Byte, von dem ich mir vorstelle, dass es erforderlich wäre, es mit Zeilenumbrüchen zu verbinden, die vollständige Programme mit einer Ganzzahl wie Null benötigen (z . B. P⁶ẋaẊs⁸Ṫ;€0ZUƊ4¡Yoder P⁶ẋaẊs⁸Ṫj@€Ø0Z$⁺Y). Vielleicht gibt es eine Möglichkeit, mehr zu sparen ...?