Tarefa

Dados dois números inteiros positivos:

1. Desenhe o retângulo com as dimensões especificadas pelos dois números inteiros.
2. Repita a Etapa 3 até não haver mais espaço.
3. Desenhe e preencha o quadrado maior tocando três lados do retângulo (restante).
4. Saída do retângulo resultante.

Exemplo

Por exemplo, nossa entrada é 6e 10.

Desenhamos o retângulo oco de tamanho 6 x 10:

xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx

Depois de preencher repetidamente os quadrados, é isso que obteríamos:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

Existem 4 quadrados aqui ( a, b, c, d), cada um com um comprimento de lado 6, 4, 2, 2respectivamente.

Regras e liberdade

1. Você deve usar uma letra diferente para cada quadrado.
2. Você pode escolher quais letras apoiar, desde que as letras suportadas sejam todos caracteres imprimíveis e que haja pelo menos 10caracteres suportados.
3. Em cada iteração da Etapa 3 acima, você tem duas opções (exceto na última iteração, onde você tem apenas uma opção). Ambas as escolhas são válidas.
4. O número de quadrados necessários não excederá o número de letras que você suporta.
5. Você pode preencher os quadrados com as letras que você apoia em qualquer ordem .

Casos de teste

Entrada: 6, 10

Resultado:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

ou

aaaaaaccdd
aaaaaaccdd
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb

ou

bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
ccddaaaaaa
ccddaaaaaa

ou

ccddaaaaaa
ccddaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa

ou

ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddbbcc
ddddddbbcc

Entrada: 1,1

Resultado:

a

Entrada: 1,10

Resultado:

abcdefghij

Entrada: 10,1

Resultado:

a
b
c
d
e
f
g
h
i
j

Observe que existem mais possibilidades do que posso incluir para os casos de teste acima.

Pontuação

Isso é código-golfe . A resposta mais curta em bytes vence.

Aplicam-se brechas padrão .

Carvão , 30 bytes

ＮδＮγＦβ¿×γδ«ＵＯγδι¿‹γδＡ⁻δγδＡ⁻γδγ

Experimente online! Explicação:

Ｎδ      Input d
Ｎγ      Input g
Ｆβ      For i In ['a' ... 'z']
 ¿×γδ«   If g * d
  ＵＯγδι   Oblong g, d, i
  ¿‹γδ    If g < d
   Ａ⁻δγδ   d = d - g
   Ａ⁻γδγ   Else g = g - d

Irritantemente, o comando Oblong do carvão não leva 0para uma dimensão, que me custa 4 bytes. A outra abordagem seria fazer um loop enquanto g * d, mas não consegui descobrir como iterar b(o que é predefinido para as letras minúsculas).

Pitão , 34 bytes

M?*GH?<HGCgHG+*G]jk*G]~hZgG-HGYjgF

Experimente online!

Haskell , 90 bytes

(['a'..]!)
a?x=a<$[1..x]
((a:b)!y)x|x*y<1=""?y|x>y=map(a?y++)$b!y$x-y|z<-y-x=a?x?x++(b!z)x

Experimente online!

Jelly , 32 bytes

Ṁ,ạ/y
³,⁴ÇÐĿp/€Fs2
pµ¢ṣLµ€+95ỌsY

Experimente online!

Ṁ,ạ/yvocê quer uma explicação? Aqui está.

Ṁ,ạ/y          - perform one step of the Euclidean Algorithm, input 2-element list
 ,             - pair of the following two:
Ṁ              -  maximum of the the input list
  ạ/           -  absolute difference of the two elements
    y          - use this as a mapping on the input.

³,⁴ÇÐĿp/€Fs2   - apply Euclidean Algorithm
³,⁴            - start with the pair [input 1, input 2]
   Ç           - apply a step of the Euclidean Algorithm
    ÐĿ         - repetitively until the results repeat
      p/€      - take the Cartesian product of each step
         Fs2   - flatten and split into all coordinate pairs of letters

pµ¢ṣLµ€+95ỌsY
p              - Cartesian product of inputs: provides all possible coordinate pairs.
 µ   µ€       - for each coordinate
   ṣL         - find the number of times it is included in
  ¢           - the above list of covered coordinates.
       +95Ọ   - convert number of times to letters
           s  - split into rows
            Y - join by newlines.

Provavelmente posso jogar um pouco mais usando argumentos implícitos em vez de ³,⁴.

Haskell , 181 bytes

import Data.List
(['!'..'~']&)
a#[]=a
a#b=zipWith(++)a$transpose b
(s&a)b|b<1=[]|b>a=transpose$s&b$a|n<-div a b,(t,u)<-splitAt n s=foldl1(#)((<$[1..b]).(<$[1..b])<$>t)#(u&b$mod a b)

Experimente online!

Para 10bytes mais, você obtém uma espiral agradável :)

!!!!!!!!!!!!!$$$#####
!!!!!!!!!!!!!$$$#####
!!!!!!!!!!!!!$$$#####
!!!!!!!!!!!!!%%'#####
!!!!!!!!!!!!!%%&#####
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""
!!!!!!!!!!!!!""""""""

Experimente online!

Ungolfed

O (#)operador coloca duas matrizes próximas uma da outra, mas transpõe a correta, por exemplo:

!!!                !!!"
!!! # "#$    ->    !!!#
!!!                !!!$

a # [] = a
a # b  = zipWith (++) a $ transpose b

Esta é basicamente a versão recursiva do algoritmo de Euclides, mas em vez de esquecer os divisores e os restos e retornar o gcd, ele constrói quadrados a partir dele e os acumula (#). A svariável são os caracteres restantes que podemos usar:

(s & a) b
  | b == 0 = []                     -- Base case
  | b > a = transpose $ (s & b) a   -- In this case we can just flip the arguments and rotate the result by 90 degrees
  | n <- div a b                    -- set n to the number of squares we need
  , (t,u) <- splitAt n s =          -- take n characters, ..
               ((<$[1..b]).(<$[1..b]) <$> t)                     -- .. build squares from them and ..
    foldl1 (#)                                                   -- put them next to each other
                                             (u & b $ mod a b)   -- recursively build the smaller squares with the remaining characters..
                                            #                    -- .. flip them and put them next to the previous one(s)

A função real chama a função de cima com uma sequência de todos os caracteres imprimíveis:

(['!'..'~']&)