Aufgabe

Bei zwei positiven ganzen Zahlen:

1. Zeichnen Sie das Rechteck mit den durch die beiden Ganzzahlen angegebenen Abmessungen.
2. Wiederholen Sie Schritt 3, bis kein Platz mehr vorhanden ist.
3. Zeichnen und füllen Sie das größte Quadrat, das drei Seiten des (verbleibenden) Rechtecks ​​berührt.
4. Geben Sie das resultierende Rechteck aus.

Beispiel

Zum Beispiel ist unsere Eingabe 6und 10.

Wir zeichnen das hohle Rechteck der Größe 6 x 10:

xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx

Nach wiederholtem Ausfüllen von Quadraten erhalten wir Folgendes:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

Es gibt 4 Quadrate hier ( a, b, c, d), die jeweils mit der Seitenlänge 6, 4, 2, 2bzw..

Regeln und Freiheit

1. Sie müssen für jedes Quadrat einen anderen Buchstaben verwenden.
2. Sie können auswählen, welche Buchstaben unterstützt werden sollen, solange die unterstützten Buchstaben alle druckbare Zeichen sind und mindestens 10Zeichen unterstützt werden.
3. In jeder Iteration von Schritt 3 oben haben Sie zwei Möglichkeiten (außer in der letzten Iteration, in der Sie nur eine Wahl haben). Beide Auswahlmöglichkeiten sind gültig.
4. Die Anzahl der erforderlichen Quadrate überschreitet nicht die Anzahl der von Ihnen unterstützten Buchstaben.
5. Sie können die Quadrate mit den von Ihnen unterstützten Buchstaben in beliebiger Reihenfolge ausfüllen .

Testfälle

Eingang: 6, 10

Ausgabe:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

oder

aaaaaaccdd
aaaaaaccdd
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb

oder

bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
ccddaaaaaa
ccddaaaaaa

oder

ccddaaaaaa
ccddaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa

oder

ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddbbcc
ddddddbbcc

Eingang: 1,1

Ausgabe:

a

Eingang: 1,10

Ausgabe:

abcdefghij

Eingang: 10,1

Ausgabe:

a
b
c
d
e
f
g
h
i
j

Beachten Sie, dass es für die obigen Testfälle mehr Möglichkeiten gibt, als ich einschließen kann.

Wertung

Das ist Code-Golf . Die kürzeste Antwort in Bytes gewinnt.

Es gelten Standardlücken .

Holzkohle , 30 Bytes

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

Probieren Sie es online aus! Erläuterung:

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

Ärgerlicherweise wird Charcoals Oblong-Befehl keine 0Dimension annehmen , was mich 4 Bytes kostet. Der andere Ansatz wäre, eine Schleife zu machen g * d, aber dann konnte ich nicht herausfinden, wie ich iterieren soll b(was in Kleinbuchstaben vordefiniert ist).

Pyth , 34 Bytes

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

Probieren Sie es online aus!

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

Probieren Sie es online aus!

Gelee , 32 Bytes

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

Probieren Sie es online aus!

Ṁ,ạ/yWillst du eine Erklärung? Hier ist es.

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

Ich kann wahrscheinlich ein bisschen mehr Golf spielen, indem ich stattdessen implizite Argumente verwende ³,⁴.

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)

Probieren Sie es online aus!

Für 10mehr Bytes bekommst du stattdessen eine schöne Spirale :)

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

Probieren Sie es online aus!

Ungolfed

Der (#)Operator legt zwei Matrizen nebeneinander, transponiert jedoch die richtige, z.

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

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

Dies ist im Grunde die rekursive Version von Euklids Algorithmus, aber anstatt die Teiler und Reste zu vergessen und die zurückzugeben gcd, baut er Quadrate daraus auf und akkumuliert diese mit (#). Die sVariable sind die verbleibenden Zeichen, die wir verwenden können:

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

Die eigentliche Funktion ruft die Funktion nur von oben mit einer Zeichenfolge aller druckbaren Zeichen auf:

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