Votre tâche consiste à, en fonction d'une carte en entrée, effectuer un zoom avant ou arrière, en fonction de l'échelle. Notez que l'échelle donnée est l'échelle de zoom arrière , donc une échelle entre 0 et 1 fera un zoom avant.

Par exemple, étant donné la carte suivante (mal faite):

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

Et un facteur d'échelle de 2, vous devez d'abord le séparer en sections 2x2:

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

Et dans chaque section, trouvez le personnage le plus courant:

.__..
.....

Notez qu'il y avait une section ambiguë:

__
OO

J'ai choisi d'utiliser _cette section, mais l'utilisation Oaurait également été parfaitement acceptable.

Si, par exemple, on vous donnait le facteur d'échelle de 4, vous le diviseriez en sections 4x4, comme ceci:

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

Comme vous pouvez le constater, la carte ne s'intègre pas parfaitement dans les sections 4x4, mais c'est bien, car nous pouvons simplement réduire la taille de la section sur le côté.

De plus, chaque fois que nous devons couper nos cartes, nous les coupons en bas ou à droite.

La carte résultante ressemblerait à ceci:

...

Quelle carte intéressante!

Pour les facteurs d'échelle inférieurs à 1, tels que 0,5, le processus est plus simple car nous zoomons à la place. Prenez cette carte:

./O\.
.\O/.

Zoom avec une échelle de 0,5:

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

Notez que chaque fois que votre facteur de zoom est inférieur 1, ce qui suit sera toujours vrai: 1/(zoom factor) % 2 == 0. Lorsqu'il est au-dessus 1, la seule garantie que vous avez est qu'il s'agira d'un nombre entier. Lorsqu'il est1 , la carte doit rester la même.

Exemples:

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

O


0.25
ABCD

AAAABBBBCCCCDDDD
AAAABBBBCCCCDDDD
AAAABBBBCCCCDDDD
AAAABBBBCCCCDDDD

1
My zoom
should
not change

My zoom
should
not change

Vous pouvez également prendre la carte comme un tableau séparé par des sauts de ligne.

Mathematica, 105 octets

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

L'entrée est (échelle, tableau de caractères). L'échelle doit être un entier ou une fraction exacte.

Explication

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

Si la première entrée est inférieure à 1 ...

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

Remplacer toutes les chaînes de la deuxième entrée dans un tableau carré, de longueur 1 / (première entrée)

ArrayFlatten[ ... ]

Aplatissez le résultat dans un tableau 2D.

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

Si la première entrée n'est pas inférieure à 1 ...

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

Partitionnez la (deuxième entrée) en partitions dont la largeur / longueur sont au maximum (première entrée).

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

Carte au niveau 2 et au niveau 3 ...

First@*Commonest

La composition de la fonction Commonest (trouve l'élément le plus commun dans une liste) et First (prenez le premier élément; au cas où il y a plusieurs éléments les plus communs).

Python, 191 182 180 octets

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

Appel _(map, scale_factor), où map est un tableau de lignes et renvoie un tableau de lignes.

Bien que cette réponse ait déjà été battue, je veux l'expliquer, car ce n'est pas un cas particulier où le facteur d'échelle est inférieur à un.

Il fait une matrice hpar w, où h = ceiling(map height / scale factor)et w = ceiling(map width / scale factor).

Pour chaque indice (x, y) de la matrice, faites:

• Prenez une sous-matrice des coordonnées int(x * scale factor), int(y * scale factor)à ceil((x + 1) * scale factor), ceil((y + 1) * scale factor).
• Mettez le caractère le plus courant dans cette sous-matrice à (x, y).

Essayez-le en ligne!

Essayez des cas de test