Il tuo compito è, data una mappa come input, ingrandirla o ingrandirla, a seconda della scala. Si noti che la scala fornita è la scala con cui eseguire lo zoom indietro , quindi una scala compresa tra 0 e 1 ingrandirà effettivamente.

Ad esempio, vista la seguente mappa (realizzata male):

..____....
../OOO\...
..\OO/\...
..........

E un fattore di scala di 2, dovresti prima separarlo in sezioni 2x2:

.. | __ | __ | .. | ..
.. | /O | OO | \. | ..
----------------------
.. | \O | O/ | \. | ..
.. | .. | .. | .. | ..

E in ogni sezione trovi il personaggio più comune:

.__..
.....

Si noti che c'era una sezione ambigua:

__
OO

Ho scelto di utilizzare _per questa sezione, ma l'utilizzo Osarebbe stato perfettamente accettabile.

Se, ad esempio, ti venisse dato il fattore di scala 4, lo divideresti in sezioni 4x4, in questo modo:

..__ | __.. | ..
../O | OO\. | ..
..\O | O/\. | ..
.... | .... | ..

Come puoi vedere, la mappa non si adatta perfettamente alle sezioni 4x4, ma va bene, in quanto possiamo semplicemente ridurre le dimensioni della sezione laterale.

Inoltre, ogni volta che dobbiamo tagliare le nostre mappe, tagliamo in basso o sul lato destro.

La mappa risultante dovrebbe apparire così:

...

Che mappa interessante!

Per i fattori di scala inferiori a 1, ad esempio 0,5, il processo è più semplice quando si ingrandisce invece. Prendi questa mappa:

./O\.
.\O/.

Zoom con una scala di 0,5:

..//OO\\..
..//OO\\..
..\\OO//..
..\\OO//..

Si noti che ogni volta che il fattore di zoom è inferiore 1, il seguente sarà sempre vero: 1/(zoom factor) % 2 == 0. Quando è sopra 1, l'unica garanzia che hai è che sarà un numero intero. Quando lo è 1, la mappa dovrebbe rimanere la stessa.

Esempi:

4
/OO\
|OO|
|OO|
\OO/

O


0.25
ABCD

AAAABBBBCCCCDDDD
AAAABBBBCCCCDDDD
AAAABBBBCCCCDDDD
AAAABBBBCCCCDDDD

1
My zoom
should
not change

My zoom
should
not change

Puoi anche prendere la mappa come un array separato da nuova riga.

Mathematica, 105 byte

If[#<1,ArrayFlatten[#2/.n_String:>Table[n,1/#,1/#]],Map[First@*Commonest,#2~Partition~UpTo@{#,#},{2,3}]]&

L'input è (scala, matrice di caratteri). La scala deve essere un numero intero o una frazione esatta.

Spiegazione

If[#<1, ..., ... ]

Se il primo input è inferiore a 1 ...

#2/.n_String:>Table[n,1/#,1/#]

Sostituisci tutte le stringhe nel secondo input in un array quadrato, con lunghezza 1 / (primo input)

ArrayFlatten[ ... ]

Appiattire il risultato in un array 2D.

If[#<1, ..., ... ]

Se il primo input non è inferiore a 1 ...

#2~Partition~UpTo@{#,#}

Partizionare il (secondo input) in partizioni la cui larghezza / lunghezza sono al massimo (primo input).

Map[ ..., ... ,{2,3}]

Mappa su livello 2 e livello 3 ...

First@*Commonest

La composizione della funzione più comune (trova l'elemento più comune in un elenco) e First (prendi il primo elemento; nel caso ci siano più elementi più comuni).

Python, 191 182 180 byte

lambda m,s,j=''.join,i=int:[j((lambda p:max(p,key=p.count))(j(g[i(x*s):-i(~x*s//1)]for g in m[i(y*s):-i(~y*s//1)]))for x in range(-i(-len(m[0])//s)))for y in range(-i(-len(m)//s))]

Chiama _(map, scale_factor), dove map è una matrice di linee e restituisce una matrice di linee.

Sebbene questa risposta sia già stata battuta, voglio spiegarla, in quanto non è un caso speciale in cui il fattore di scala è inferiore a uno.

Fa una hda wmatrice, dove h = ceiling(map height / scale factor), e w = ceiling(map width / scale factor).

Per ogni indice (x, y) nella matrice, eseguire:

• Prendi una sottotrix dalle coordinate int(x * scale factor), int(y * scale factor)a ceil((x + 1) * scale factor), ceil((y + 1) * scale factor).
• Metti il ​​carattere più comune in quella sottostruttura in (x, y).

Provalo online!

Prova i casi di test