Zadanie

Biorąc pod uwagę dwie dodatnie liczby całkowite:

1. Narysuj prostokąt o wymiarach określonych przez dwie liczby całkowite.
2. Powtarzaj krok 3, aż nie będzie już miejsca.
3. Narysuj i wypełnij największy kwadrat, dotykając trzech boków (pozostałego) prostokąta.
4. Wyjmij wynikowy prostokąt.

Przykład

Na przykład nasz wkład to 6i 10.

Rysujemy pusty prostokąt o wymiarach 6 x 10:

xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx

Po wielokrotnym wypełnianiu kwadratów otrzymalibyśmy:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

Istnieją 4 kwadraty o ( a, b, c, d), każda o długości boku 6, 4, 2, 2odpowiednio.

Zasady i wolność

1. Musisz użyć innej litery dla każdego kwadratu.
2. Możesz wybrać, które litery mają być obsługiwane, o ile obsługiwane są wszystkie litery do wydrukowania i 10obsługiwane są co najmniej znaki.
3. W każdej iteracji kroku 3 powyżej masz dwie możliwości (z wyjątkiem ostatniej iteracji, w której masz tylko jeden wybór). Obie opcje są prawidłowe.
4. Wymagana liczba kwadratów nie przekroczy liczby obsługiwanych liter.
5. Możesz wypełnić kwadraty literami, które wspierasz w dowolnej kolejności .

Przypadki testowe

Wejście: 6, 10

Wynik:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

lub

aaaaaaccdd
aaaaaaccdd
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb

lub

bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
ccddaaaaaa
ccddaaaaaa

lub

ccddaaaaaa
ccddaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa
bbbbaaaaaa

lub

ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddaaaa
ddddddbbcc
ddddddbbcc

Wejście: 1,1

Wynik:

a

Wejście: 1,10

Wynik:

abcdefghij

Wejście: 10,1

Wynik:

a
b
c
d
e
f
g
h
i
j

Zauważ, że jest więcej możliwości, niż mogę uwzględnić dla powyższych przypadków testowych.

Punktacja

To jest golf golfowy . Najkrótsza odpowiedź w bajtach wygrywa.

Obowiązują standardowe luki .

Węgiel drzewny , 30 bajtów

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

Wypróbuj online! Wyjaśnienie:

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

Irytujące polecenie Podłużne węgla drzewnego nie przyjmuje 0wymiaru, który kosztuje mnie 4 bajty. Innym podejściem byłoby zapętlenie g * d, ale wtedy nie mogłem wymyślić, jak wykonać iterację b(która jest predefiniowana dla małych liter).

Pyth , 34 bajty

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

Wypróbuj online!

Haskell , 90 bajtów

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

Wypróbuj online!

Galaretka , 32 bajty

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

Wypróbuj online!

Ṁ,ạ/ychcesz wyjaśnienia? Oto jest.

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

Prawdopodobnie mogę trochę bardziej grać w golfa, używając domyślnych argumentów zamiast ³,⁴.

Haskell , 181 bajtów

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)

Wypróbuj online!

Za 10bajty więcej dostajesz ładną spiralę :)

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

Wypróbuj online!

Nie golfił

W (#)puts operator dwie macierze obok siebie, ale transponuje tę właściwą, na przykład:

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

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

Jest to w zasadzie rekurencyjna wersja algorytmu Euclida, ale zamiast zapominać o dzielnikach i resztkach i zwracać gcd, buduje z niego kwadraty i kumuluje je (#). sZmienne są pozostałe znaki, które możemy użyć:

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

Rzeczywista funkcja po prostu wywołuje funkcję z góry z ciągiem wszystkich drukowalnych znaków:

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