任务

给定两个正整数：

1. 绘制由两个整数指定的尺寸的矩形。
2. 重复步骤3，直到没有更多空间。
3. 绘制并填充与（剩余）矩形的三个边接触的最大正方形。
4. 输出结果矩形。

例

例如，我们的输入是6和10。

我们绘制大小为6 x 10的空心矩形：

xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx

重复填充正方形后，我们将获得以下结果：

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

有4个方格位置（a，b，c，d），每个边长6，4，2，2分别。

规则与自由

1. 您必须为每个正方形使用不同的字母。
2. 您可以选择要支持的字母，只要支持的字母都是可打印字符，并且至少10支持字符即可。
3. 在上面的步骤3的每个迭代中，您都有两个选择（在上一个迭代中，只有一个选择）。两种选择均有效。
4. 所需的平方数不会超过您支持的字母数。
5. 您可以按任何顺序用支持的字母填写方块。

测试用例

输入： 6, 10

输出：

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

要么

aaaaaaccdd
aaaaaaccdd
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb

要么

bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
ccddaaaaaa
ccddaaaaaa

要么

ccddaaaaaa
ccddaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa

要么

ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddbbcc
ddddddbbcc

输入： 1,1

输出：

a

输入： 1,10

输出：

abcdefghij

输入： 10,1

输出：

a
b
c
d
e
f
g
h
i
j

请注意，以上测试用例包含的可能性比我能提供的更多。

计分

这是代码高尔夫球。以字节为单位的最短答案将获胜。

有标准漏洞。

木炭，30字节

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

在线尝试！说明：

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

烦人的是，木炭的“椭圆形”命令不会占用0一个尺寸，这花了我4个字节。另一种方法是循环while g * d，但是后来我不知道如何迭代b（已预定义为小写字母）。

Pyth，34个字节

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

在线尝试！

90字节的Haskell

(['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

在线尝试！

果冻，32字节

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

在线尝试！

Ṁ,ạ/y您想要一个解释吗？这里是。

Ṁ,ạ/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.

通过使用隐式参数而不是，我可能可以进行更多操作³,⁴。

Haskell，181个字节

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)

在线尝试！

对于10更多的字节，您会得到一个不错的螺旋形:)

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

在线尝试！

不打高尔夫球

该(#)操作员将两个矩阵彼此相邻，但调换的权利之一，例如：

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

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

这基本上是Euclid算法的递归版本，但是它没有忘记除数和余数并返回gcd，而是从中建立平方并用累加(#)。该s变量是剩余的字符，我们可以使用：

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

实际函数只是使用所有可打印字符的字符串从上方调用函数：

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