Su tarea es, dado un mapa como entrada, alejarlo o acercarlo, dependiendo de la escala. Tenga en cuenta que la escala es la escala dada por el cual se hace acercamiento a cabo , por lo que una escala entre 0 y 1 en realidad un zoom.

Por ejemplo, dado el siguiente mapa (mal hecho):

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

Y un factor de escala de 2, primero debe separarlo en secciones de 2x2:

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

Y en cada sección encuentra el personaje más común:

.__..
.....

Tenga en cuenta que había una sección ambigua:

__
OO

Elegí usar _para esta sección, pero usar Otambién habría sido perfectamente aceptable.

Si, por ejemplo, le dieron el factor de escala de 4, lo dividiría en secciones de 4x4, así:

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

Como puede ver, el mapa no encaja perfectamente en secciones de 4x4, pero está bien, ya que podemos reducir el tamaño de la sección a un lado.

Además, cada vez que necesitamos cortar nuestros mapas, cortamos en la parte inferior o en el lado derecho.

El mapa resultante se vería así:

...

¡Qué mapa tan interesante!

Para factores de escala por debajo de 1, como 0.5, el proceso es más simple ya que en su lugar nos acercamos. Toma este mapa:

./O\.
.\O/.

Zoom con una escala de 0.5:

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

Tenga en cuenta que cada vez que el factor de zoom es inferior a 1, lo siguiente será siempre ser verdad: 1/(zoom factor) % 2 == 0. Cuando está arriba 1, la única garantía que tiene es que será un número entero. Cuando es así 1, el mapa debe permanecer igual.

Ejemplos:

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

O


0.25
ABCD

AAAABBBBCCCCDDDD
AAAABBBBCCCCDDDD
AAAABBBBCCCCDDDD
AAAABBBBCCCCDDDD

1
My zoom
should
not change

My zoom
should
not change

También puede tomar el mapa como una matriz separada por una nueva línea.

Mathematica, 105 bytes

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

La entrada es (escala, matriz de caracteres). La escala debe ser un número entero o una fracción exacta.

Explicación

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

Si la primera entrada es menor que 1 ...

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

Reemplace todas las cadenas en la segunda entrada en una matriz cuadrada, con longitud 1 / (primera entrada)

ArrayFlatten[ ... ]

Acoplar el resultado en una matriz 2D.

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

Si la primera entrada no es inferior a 1 ...

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

Particione la (segunda entrada) en particiones cuyo ancho / largo sea como máximo (primera entrada).

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

Mapa en el nivel 2 y nivel 3 ...

First@*Commonest

La composición de la función más común (encuentra el elemento más común en una lista) y Primero (tome el primer elemento; en caso de que haya múltiples elementos más comunes).

Python, 191 182 180 bytes

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

Llamada _(map, scale_factor) , donde map es una matriz de líneas, y devuelve una matriz de líneas.

Aunque esta respuesta ya ha sido superada, quiero explicarla, ya que no es un caso especial donde el factor de escala es menor que uno.

Hace una matriz hpor w, donde h = ceiling(map height / scale factor), y w = ceiling(map width / scale factor).

Para cada índice (x, y) en la matriz, haga:

• Tome una submatriz de las coordenadas int(x * scale factor), int(y * scale factor)a ceil((x + 1) * scale factor), ceil((y + 1) * scale factor).
• Ponga el carácter más común en esa submatriz en (x, y).

Pruébalo en línea!

Prueba casos de prueba