Tarea

Dados dos enteros positivos:

1. Dibuja el rectángulo con las dimensiones especificadas por los dos enteros.
2. Repita el paso 3 hasta que no haya más espacio.
3. Dibuja y llena el cuadrado más grande tocando tres lados del rectángulo (restante).
4. Salida del rectángulo resultante.

Ejemplo

Por ejemplo, nuestra entrada es 6y 10.

Dibujamos el rectángulo hueco de tamaño 6 x 10:

xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx

Después de llenar repetidamente cuadrados, esto es lo que obtendríamos:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

Hay 4 cuadrados aquí ( a, b, c, d), cada uno con una longitud de lado 6, 4, 2, 2respectivamente.

Reglas y libertad

1. Debes usar una letra diferente para cada cuadrado.
2. Puede elegir qué letras admitir, siempre que las letras admitidas sean todos caracteres imprimibles y haya al menos 10caracteres admitidos.
3. En cada iteración del Paso 3 anterior, tiene dos opciones (excepto en la última iteración, donde solo tiene una opción). Ambas opciones son válidas.
4. El número de cuadrados requeridos no excederá el número de letras que admite.
5. Puede completar los cuadrados con las letras que admite en cualquier orden .

Casos de prueba

Entrada: 6, 10

Salida:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

o

aaaaaaccdd
aaaaaaccdd
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb

o

bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
ccddaaaaaa
ccddaaaaaa

o

ccddaaaaaa
ccddaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa

o

ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddbbcc
ddddddbbcc

Entrada: 1,1

Salida:

a

Entrada: 1,10

Salida:

abcdefghij

Entrada: 10,1

Salida:

a
b
c
d
e
f
g
h
i
j

Tenga en cuenta que hay más posibilidades de las que puedo incluir para los casos de prueba anteriores.

Puntuación

Este es el código de golf . La respuesta más corta en bytes gana.

Se aplican lagunas estándar .

Carbón , 30 bytes

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

Pruébalo en línea! Explicación:

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

El molesto comando Oblong de Charcoal no tomará 0una dimensión, lo que me cuesta 4 bytes. El otro enfoque sería hacer un ciclo mientras g * d, pero no pude averiguar cómo iterar b(que está predefinido a las letras minúsculas).

Pyth , 34 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Jalea , 32 bytes

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

Pruébalo en línea!

Ṁ,ạ/yquieres una explicacion? Aquí 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.

Probablemente pueda jugar un poco más al golf usando argumentos implícitos en lugar 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)

Pruébalo en línea!

Para 10bytes más, obtienes una buena espiral :)

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

Pruébalo en línea!

Sin golf

El (#)operador coloca dos matrices una al lado de la otra, pero transpone la correcta, por ejemplo:

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

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

Esta es básicamente la versión recursiva del algoritmo de Euclides, pero en lugar de olvidar los divisores y residuos y devolver el gcd, construye cuadrados a partir de ellos y los acumula (#). La svariable son los 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)

La función real solo llama a la función desde arriba con una cadena de todos los caracteres imprimibles:

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