Tâche

Étant donné deux nombres entiers positifs:

1. Dessinez le rectangle avec les dimensions spécifiées par les deux entiers.
2. Répétez l'étape 3 jusqu'à ce qu'il n'y ait plus d'espace.
3. Dessinez et remplissez le plus grand carré touchant les trois côtés du rectangle (restant).
4. Sortez le rectangle résultant.

Exemple

Par exemple, notre entrée est 6et 10.

Nous dessinons le rectangle creux de taille 6 x 10:

xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx

Après avoir rempli des carrés à plusieurs reprises, voici ce que nous obtiendrions:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

Il y a 4 carrés ici ( a, b, c, d), chacun ayant des côtés de longueur 6, 4, 2, 2respectivement.

Règles et liberté

1. Vous devez utiliser une lettre différente pour chaque carré.
2. Vous pouvez choisir les lettres à prendre en charge, tant que les lettres prises en charge sont tous des caractères imprimables et qu'il y a au moins des 10caractères pris en charge.
3. Dans chaque itération de l'étape 3 ci-dessus, vous avez deux choix (sauf dans la dernière itération, où vous n'avez qu'un seul choix). Les deux choix sont valides.
4. Le nombre de carrés requis ne dépassera pas le nombre de lettres que vous soutenez.
5. Vous pouvez remplir les cases avec les lettres que vous soutenez dans n'importe quel ordre .

Cas de test

Contribution: 6, 10

Production:

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

Contribution: 1,1

Production:

a

Contribution: 1,10

Production:

abcdefghij

Contribution: 10,1

Production:

a
b
c
d
e
f
g
h
i
j

Notez qu'il y a plus de possibilités que je ne peux en inclure pour les tests ci-dessus.

Notation

C'est du code-golf . La réponse la plus courte en octets l'emporte.

Des échappatoires standard s'appliquent.

Fusain , 30 octets

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

Essayez-le en ligne! Explication:

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

La commande oblongue de Charcoal ne prend pas 0une dimension, ce qui me coûte 4 octets. L'autre approche serait de boucler tout g * d, mais je n'ai pas pu trouver comment itérer b(qui est prédéfini pour les lettres minuscules).

Pyth , 34 octets

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

Essayez-le en ligne!

Haskell , 90 octets

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

Essayez-le en ligne!

Gelée , 32 octets

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

Essayez-le en ligne!

Ṁ,ạ/yvous voulez une explication? C'est ici.

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

Je peux probablement jouer un peu plus au golf en utilisant des arguments implicites au lieu de ³,⁴.

Haskell , 181 octets

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)

Essayez-le en ligne!

Pour les 10octets de plus, vous obtenez une belle spirale à la place :)

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

Essayez-le en ligne!

Non golfé

L' (#)opérateur place deux matrices l'une à côté de l'autre, mais transpose la bonne, par exemple:

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

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

Il s'agit essentiellement de la version récursive de l'algorithme d'Euclide, mais au lieu d'oublier les diviseurs et les restes et de renvoyer le gcd, il en construit des carrés et les accumule avec (#). Les svariables sont les caractères restants que nous pouvons utiliser:

(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 fonction réelle appelle simplement la fonction d'en haut avec une chaîne de tous les caractères imprimables:

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