Compito

Dati due numeri interi positivi:

1. Disegna il rettangolo con le dimensioni specificate dai due numeri interi.
2. Ripetere il passaggio 3 fino a quando non c'è più spazio.
3. Disegna e riempi il quadrato più grande toccando i tre lati del rettangolo (rimanente).
4. Stampa il rettangolo risultante.

Esempio

Ad esempio, il nostro input è 6e 10.

Disegniamo il rettangolo vuoto delle dimensioni 6 x 10:

xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx
xxxxxxxxxx

Dopo aver riempito ripetutamente i quadrati, questo è ciò che otterremmo:

aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaabbbb
aaaaaaccdd
aaaaaaccdd

Ci sono 4 quadrati here ( a, b, c, d), ciascuno con lato di lunghezza 6, 4, 2, 2rispettivamente.

Regole e libertà

1. Devi usare una lettera diversa per ogni quadrato.
2. Puoi scegliere quali lettere supportare, purché le lettere supportate siano tutte caratteri stampabili e ci siano almeno 10caratteri supportati.
3. In ogni iterazione del passaggio 3 sopra, hai due scelte (tranne nell'ultima iterazione, in cui hai solo una scelta). Entrambe le scelte sono valide.
4. Il numero di quadrati richiesti non supererà il numero di lettere supportate.
5. Puoi riempire i quadrati con le lettere che supporti in qualsiasi ordine .

Casi test

Ingresso: 6, 10

Produzione:

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

Ingresso: 1,1

Produzione:

a

Ingresso: 1,10

Produzione:

abcdefghij

Ingresso: 10,1

Produzione:

a
b
c
d
e
f
g
h
i
j

Nota che ci sono più possibilità di quelle che posso includere per i test di cui sopra.

punteggio

Questo è code-golf . Vince la risposta più breve in byte.

Si applicano scappatoie standard .

Carbone , 30 byte

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

Provalo online! Spiegazione:

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

Il comando Oblong di Charcoal fastidiosamente non avrà 0una dimensione, che mi costa 4 byte. L'altro approccio sarebbe quello di eseguire il ciclo mentre g * d, ma poi non sono riuscito a capire come ripetere b(che è predefinito alle lettere minuscole).

Pyth , 34 byte

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

Provalo online!

Haskell , 90 byte

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

Provalo online!

Gelatina , 32 byte

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

Provalo online!

Ṁ,ạ/yvuoi una spiegazione? Ecco qui.

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

Posso probabilmente giocare a golf un po 'di più usando argomenti impliciti invece di ³,⁴.

Haskell , 181 byte

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)

Provalo online!

Per 10byte in più invece ottieni una bella spirale :)

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

Provalo online!

Ungolfed

L' (#)operatore mette due matrici una accanto all'altra, ma traspone quella giusta, ad esempio:

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

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

Questa è fondamentalmente la versione ricorsiva dell'algoritmo di Euclide, ma invece di dimenticare i divisori e i resti e restituire il gcd, costruisce quadrati da esso e li accumula (#). La svariabile sono i caratteri rimanenti che possiamo usare:

(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 funzione effettiva chiama semplicemente la funzione dall'alto con una stringa di tutti i caratteri stampabili:

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