Encha uma tigela com sopa de letrinhas

24

Nós parecem não obter cansado de desafios alfabeto-relacionados ...


A receita

Dado

  • uma sequência de letras S e
  • dois inteiros positivos M, N,

produza uma sopa de letrinhas com as letras de Socupar posições aleatórias em uma tigela retangular de tamanho M× N, emoldurada por um caractere não alfabético e sem espaço para representar a borda da tigela.

As posições não usadas por letras devem ser exibidas como espaços. Veja os exemplos abaixo .

Regras adicionais

  • O tamanho M× Nrefere-se ao interior da tigela. O tamanho incluindo o aro é M+2×N+2 .
  • Cada personagem de Sdeve aparecer uma vez na tigela, em uma posição diferente ; isto é, um personagem não pode substituir outro.
  • S pode conter duplicatas . Por exemplo, se Sfor a sequência 'abcc', a sopa deve conter um a, um be doisc (todos em posições diferentes).
  • As entradas irão satisfazer as restrições M >= 1 , N >= 1, 1 <= length(S) <= M*N.
  • A borda da tigela pode ser qualquer caractere não alfabético e não espacial , consistente entre as execuções do programa e os valores de entrada.
  • As posições das letras na tigela são aleatórias, portanto o resultado pode variar sempre que o programa for executado com as mesmas entradas.
  • Dada a entrada, todo conjunto possível de posições de letras deve ter uma probabilidade diferente de zero . Como isso não pode ser verificado em algumas realizações do programa, explique como o seu código cumpre isso.
  • Espaço em branco à esquerda ou à direita ao redor da borda são permitidos.
  • Sconterão apenas letras maiúsculas. Se desejar, você pode escolher apenas letras minúsculas .
  • Entrada e saída são flexíveis, como de costume. Por exemplo, a saída pode ser uma sequência com novas linhas, uma matriz de caracteres 2D ou uma lista de linhas.
  • Programas ou funções são permitidos, em qualquer linguagem de programação . As brechas padrão são proibidas.
  • O código mais curto em bytes vence.

Exemplos

As entradas são mostradas como S, [M N], onde Mé o número de linhas e o Nnúmero de colunas. O personagem #é usado para a borda.

'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
fonte
"As posições das letras na tigela são aleatórias, [...]" <- você quer dizer que pode ser aleatória ou deve ser aleatória? E todas as linhas podem ter o mesmo número de caracteres o tempo todo?
Ismael Miguel
@IsmaelMiguel Must . E toda configuração deve ter uma probabilidade diferente de zero (declarada no desafio). Então isso exclui a abordagem sempre do mesmo comprimento
Luis Mendo
O aro pode ser consistente entre as execuções do programa e os valores de entrada, mas usa várias letras que não são letras, por exemplo, desenhando uma borda de arte ASCII |+-?
Adám 03/10
@ Adám Hm, vou dizer não, é uma mudança muito grande
Luis Mendo

Respostas:

13

05AB1E , 20 18 16 15 14 bytes

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

Toma três entradas na ordem: altura, largura, sequência. Saída como uma lista 2D de caracteres.
Usa 8como borda, mas pode ter qualquer dígito.

-1 byte graças a @Grimy .

Experimente online ou verifique todos os casos de teste . (O TIO contém }}J»no rodapé para imprimir bem o resultado; fique à vontade para removê-lo para ver a lista 2D de caracteres de saída real.)

Explicação:

*               # 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
fonte
1
@LuisMendo Na verdade, acabei de dizer o desafio 3 minutos atrás. ;) É uma implementação bastante direta. Vai tentar jogar golfe daqui.
Kevin Cruijssen em
1
Muito bom, eu não pensei nisso *j! Aqui estão 13 para legados ou 14 feios para modernos (gera uma matriz de caracteres 2D).
Grimmy 03/10
1
@ Grimy O 13-byter parece falhar na entrada 1,1,"O", então eu acho que tem que ser o 14-byter para o legado também. Obrigado por -1 embora.
Kevin Cruijssen 03/10
7

APL (Dyalog Unicode) , SBCS de 25 bytes

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

Experimente online!

-22 graças a @ngn, -7 graças a @ngn e @ Adám

Explicação:

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

Os ângulos da jante são caracteres diferentes

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

Experimente online!

Usando o dfn para exibir a caixa.

Ven
fonte
29: '#',∘⌽∘⍉⍣4⊢⍴∘(?⍨∘≢⊃¨⊂)↑⍨∘(×/) Experimente online!
Adám 03/10
28: {'#',∘⌽∘⍉⍣4⊢⍵⍴⍺\⍨(≢⍺)>?⍨×/⍵}(ou em vez de >se ⎕io=1)
ngn
na verdade, 27:'#',∘⌽∘⍉⍣4{⍵⍴⍺\⍨(≢⍺)>?⍨×/⍵}
ngn 03/10
3
25:'#',∘⌽∘⍉⍣4{⍵⍴⊃¨↓∘⍺¨?⍨×/⍵}
ngn
Em relação aos 21
Adám 03/10
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)]

Experimente online!

Aleatoriza usando uma setcompreensão e retorna uma matriz de caracteres 2D.

Jitse
fonte
Bom uso da compreensão do conjunto para randomizar. +1. Mas seus códigos se baseiam no nome 'f' da função. Portanto, acho que a solução lambda não é válida ...
agtoever
1
@agtoever Obrigado! A função não é recursiva, portanto pode ser anônima. Você está se referindo à f'{s:{m*n}}'peça? Porque essa é a sintaxe de uma string formatada, que por coincidência também começa com um f.
Jitse 03/10
3
Este código parece violar o PEP 8 de várias maneiras.
Christofer Ohlsson
1
@ Christofer-Ohlsson absolutamente!
Jitse
2
@ChristoferOhlsson Bem-vindo ao mundo do código-golfe, haha. ;) Nenhum comentário / documentação; variáveis ​​/ métodos de caractere único, sem espaços (desnecessários) / novas linhas; potencialmente centenas de avisos do compilador que simplesmente ignoramos; aumento do desempenho de O (log (N)) para O (N ^ N); etc. Se ele pode salvar até um único byte, está tudo bem e vale totalmente a pena pelo código de golfe. ;)
Kevin Cruijssen em
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

Exemplo de execução:

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

Experimente online!

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

Exemplo de execução:

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

Experimente online! (Parcialmente, como boxesnão está instalado no TIO.)

homem a trabalhar
fonte
5

J , 30 29 bytes

-1 byte graças a Jonah

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

Experimente online!

Galen Ivanov
fonte
1
Porque o TIO usa uma semente aleatória fixa. 9!:1]6!:9''corrige isso
Adám 03/10
2
Realmente como a maneira usada no preenchimento zero {.. Pequenos ajustes para 29 '#'|.@|:@,^:4[$*/@[(?~@[{{.)]: Experimente online!
Jonah
1
@Jonah Obrigado!
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#
'

Experimente online!

$wAceita entrada como id, $hoito,$s tring.

Constrói uma sequência do idth #apropriado $w, junta-se à mesma com alguma computação e, em seguida, a mesma #sequência novamente. O cálculo começa com a entrada da seqüência de caracteres $se a execução de um .padRig htaté o oitavo comprimento $wpor $hoito (ou seja, faça uma string longa o suficiente para ocupar completamente o espaço retangular. Depois convertemos a string toCharArra ye sortela também Random. a parte do meio confusa, enfim, dividimos -replaceem pedaços iguais e $wcercamos esses pedaços com# s.

-52 graças à inspiração do AZTECCO
-18 bytes graças ao mazzy

AdmBorkBork
fonte
Você tem 2 x aleatórios (12) enquanto JS tem um, ele adicionou espaços para preencher o tamanho M * N e classificou, depois disso você ainda paga 21 por '$' infelizmente
AZTECCO
1
@AZTECCO Obrigado pela inspiração!
AdmBorkBork
Obrigado @mazzy - muito inteligente ao -replaceinvés de se separar e se juntar.
AdmBorkBork
4

JavaScript (ES7), 125 bytes

Retorna uma string. Usa 0como o caractere do quadro.

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

Experimente online!

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

APL (Dyalog Extended) , SBCS de 23 bytes

Função de infixo tácito anônimo. Toma [M,N]como argumento à esquerda e Scomo argumento à direita.

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

Experimente online!

×/⍛() Aplique a seguinte função entre os argumentos, substituindo o argumento esquerdo por seu produto:

 pegue M× Ncaracteres S, preenchendo espaços à direita

 reordene isso na seguinte ordem:

?⍨⍤ os índices embaralhados de 1 a…
 o argumento esquerdo ( M× N)

r esforme isso para a seguinte forma:

 o argumento da esquerda (ou seja, Mlinhas e Ncolunas)

'#'⍣4 Aplique a seguinte função quatro vezes, cada vez com o caractere hash como argumento esquerdo:
∘⍉ transponha o argumento direito
∘⌽ espelhe o argumento direito
,concatenar uma coluna de hashes para o lado esquerdo desse argumento

Adão
fonte
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._

Graças a:

  • Ismael Miguel por me lembrar sobre as funções de seta do PHP 7.4 (-10 caracteres)
  • Night2 para reverter eficientemente as concatenações e join()(-8 caracteres)
  • Night2 para mostrar como usar chunk_split()o $endparâmetro (-5 caracteres)

Experimente online!

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

Graças a:

  • Night2 para reverter eficientemente as concatenações e os join()(-5 caracteres)
  • Night2 para mostrar como usar chunk_split()o $endparâmetro (-4 caracteres)

Exemplo de execução:

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

Experimente online!

homem a trabalhar
fonte
1
Eu acredito 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";deve funcionar no PHP 7.4 ( wiki.php.net/rfc/arrow_functions_v2 ), e um release de lançamento foi lançado ( wiki.php.net/todo/php74 ), portanto, é um "compilador" disponível que veio antes desse desafio, e qualquer um pode usá-lo.
Ismael Miguel
1
Doh, você está certo. Leia sobre, mas esqueci. (Nota para mim mesmo: da próxima vez, não basta ler a dica do Night2 . Voto-o também, talvez ajude a lembrar.)
manatwork
2
99 bytes
Night2
1
Obrigado, @ Night2. Não consigo imaginar o que errei ontem, pois tentei mover mais coisas para dentro join(), mas não reduzi o tamanho. ☹
manatwork
1
Foi ainda mais curto usando chunk_split: 94 bytes Também removi o último ponto-e-vírgula porque acredito que não é necessário; você escreveu uma função; portanto, o código que vai atribuí-lo a uma variável não deve contar.
Night2
3

MATL , 22 19 bytes

tZ"ibpyn&Z@(TT35&Ya

Experimente online!

Obrigado @LuisMendo por salvar 3 bytes, agora ele tem o mesmo número de bytes que a resposta de @ flawr , mas suficientemente diferente para postar de qualquer maneira. Visão geral do agoritmo de alto nível:

 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
fonte
Você pode mudar Z}&O por Z", e que também permite que você remova a finalc
Luis Mendo
@LuisMendo Oh, isso ajuda muito! Venha para pensar sobre isso, eu deveria pelo menos ter feito 1$O.
Sanchises em
3

Ruby , 121 bytes

Cria a tigela, consulta os índices de todos os espaços dentro da tigela, mostra um número de espaços iguais ao tamanho da string e os preenche. sample Não retorna uma lista classificada, portanto, não é necessário embaralhar. A pesquisa de índices até 9*m*n(que quase certamente sai do intervalo) ainda terá todos os espaços e é 1 byte menor 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}

Experimente online!

Value Ink
fonte
3

Vermelho , 120 116 114 112 bytes

-2 bytes graças 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]

Experimente online!

Galen Ivanov
fonte
2
-2 bytes, livrando-se do + 1e usando to"""00"0 n.
Kevin Cruijssen em
1
@KevinCruijssen Thanks! Substituí-o por copy, pela mesma contagem de bytes.
Galen Ivanov
1
Isso realmente parece um pouco mais limpo! Eu não conheço Red, exceto pelas respostas que eu vi de você, então eu estava apenas brincando um pouco. ;) Colocar a tlinha como item inicial / final antes de fazer o loop para economizar os dois soltos print tseria mais curto? Duvido, mas como não sei como adicionar itens a uma lista, não tenho certeza.
Kevin Cruijssen 03/10
3

Perl 6 , 74 67 bytes

-5 bytes graças a Jo King

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

Experimente online!

Explicação

{                                                                 }
                                         ^$^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
fonte
69 bytes
Jo King
3

Perl 5 -lF , 99 97 bytes

-2 bytes de cortesia de @NahuelFouilleul

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

Experimente online!

Xcali
fonte
($i++%$n==0)poderia ser alterado por!($i++%$n)
Nahuel Fouilleul 04/10
3

k4, 32 28 bytes

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

edit: -4 graças a Galen Ivanov!

chamado como

f["hey";3 3]

explicação:

                 (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 (|)
rabisco
fonte
1
Eu acho que você pode salvar alguns bytes se você apenas anexar #no final de cada linha e transpor / reverter 4 vezes, algo como isto .
Galen Ivanov
1
@GalenIvanov nice, updated!
rabisco
3

Java (JDK) , 180 178 bytes

Nem uma única importação 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#");}

Experimente online!

Foi uma grande luta para conseguir isso. Em particular, as importações envolvidas com os métodos Collections.shuffle () / Arrays eram demais para serem aceitas; portanto, tive que criar meu próprio algoritmo de embaralhamento de String (provavelmente nem eficiente nem distribuído uniformemente). Agradecimentos enormes a Steven por provar que qualquer conjunto de posições pode ser gerado partir do algoritmo.

Formatado (com explicação):

(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
fonte
Boa resposta! +1 de mim. Uma coisa pequena para o golfe: .replaceAll("(.{"+n+"})","\n#$1#")pode se tornar.replaceAll(".{"+n+"}","\n#$0#")
Kevin Cruijssen
@KevinCruijssen Obrigado pela melhoria :)
Avi
2

Carvão , 27 bytes

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

Experimente online! Link é a versão detalhada do código. Recebe entrada na ordem largura, altura, string. Explicação:

NθNη

Insira a largura e a altura.

↖B⁺²θ⁺²η#

Enquadre a tigela.

FS«

Faça um loop sobre os caracteres na sequência.

W℅KKJ‽θ‽η

Pule para uma posição aleatória na tigela até encontrar um lugar vazio.

Pι

Imprima o caractere atual sem mover o cursor.

Neil
fonte
Isso é Move(:UpLeft)necessário? Funciona bem sem ele, mas talvez você o tenha adicionado por um motivo em que não penso?
Kevin Cruijssen 03/10
1
@KevinCruijssen Sem ele, nunca seria capaz de escrever cartas na linha inferior ou na coluna da direita.
Neil
Ah, então foi isso. Isso explica tudo, obrigado!
Kevin Cruijssen 03/10
2

Japonês -R , 21 18 bytes

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

Tente

ú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
Shaggy
fonte
2

MATL , 29 27 19 bytes

pZ@iy~hw)1GeTT35&Ya

Experimente online!

Obrigado @LuisMendo por -8 bytes!

Explicação: pcalcula o número de pixels de sopa. Em seguida, Z@produz uma permutação aleatória do tamanho do número de pixels da sopa. Usaremos isso como índices aos iy~hquais é a string de entrada com espaço suficiente adicionado. w)troca os dois e indexa um pelo outro. Em seguida, reformulamos 1Gea forma no retângulo desejado e #pressionamos-a usando TT35&Ya.

flawr
fonte
2
Inteligente! Minha tentativa foi de 22 bytes
Sanchises 03/10
2
@Sanchises Vá postá-lo de qualquer maneira!
flawr 03/10
2

T-SQL 2017, 232 bytes

Testar esse online é uma versão mais antiga do sql-server que custa outro caractere. Eu postei a versão mais curta.

Golfe:

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

Experimente online

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(@))
t-clausen.dk
fonte
2

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

Experimente online!

-2 colocando a = o em time () chamada // for (srand (time (a = o)); ...

Salvo 7 sugestão de @ceilingcat para usar - ~ armazenamento variável e automático para a sequência o, além de muitas melhorias.

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
fonte
Sugerir em *a=--i;)*a++=i%m?-~i%m<3|i<m|i>m*n?35:32:10;for(;vez de--i;)*a++=i%m?-~i%m<3|i<m|i>m*n?35:32:10;for(*a=0;
ceilingcat 6/10
@ceilingcat deve funcionar, mas por algum motivo fornece saída errada nos últimos 2 casos de teste
AZTECCO
2

Ícone , 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

Experimente online!

Galen Ivanov
fonte
1

Gelatina , 16 bytes

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

Um link diádico que aceita uma lista de números inteiros, [M, N]à esquerda e uma lista de caracteres, Sà direita, que produz uma lista de listas de caracteres, as linhas. Usa o caractere til,, ~como a borda.

Experimente online!

Todas as saídas possíveis têm uma chance diferente de zero de ser gerada, uma vez que embaralhamos ( ) uma lista dos caracteres Sjuntamente com o número apropriado de espaços.

O código Ṿ€«”~ZƊ⁺salva o byte que eu imagino que seria necessário associar a novas linhas que programas completos usando um número inteiro como zero precisariam empregar (por exemplo, P⁶ẋaẊs⁸Ṫ;€0ZUƊ4¡You P⁶ẋaẊs⁸Ṫj@€Ø0Z$⁺Y). Talvez haja uma maneira de economizar mais ...?

Jonathan Allan
fonte