Los desafíos del camaleón son algo malo , aparentemente. Lástima, los camaleones son hermosas criaturas. ¡Es tiempo de un cambio!

Como todos sabemos, muchos camaleones poseen una notable capacidad de mezclarse con su entorno cambiando el color de su piel. Cuál es también el objetivo de este desafío.

Desafío

Imagina un cuadrado de nueve píxeles. Ocho píxeles son los alrededores. En el centro está el camaleón.

Me gusta esto:

El camaleón, naturalmente, trata de mezclarse con su entorno. Lo hace cambiando su color al promedio de los píxeles circundantes. Entonces, en este caso, el camaleón cambiaría su color a .

Objetivo

Dados los colores de los píxeles circundantes, genera el color del camaleón.

El color del camaleón se define como el total de todos los rojos, verdes y azules en los píxeles ÷ 8.

Entrada

Una matriz de valores de color para los ocho píxeles circundantes, comenzando en la parte superior izquierda y continuando en el sentido de las agujas del reloj, de esta manera:

[[<red>,<green>,<blue>],[<red>,<green>,<blue>],[<red>,<green>,<blue>],[<red>,<green>,<blue>],[<red>,<green>,<blue>],[<red>,<green>,<blue>],[<red>,<green>,<blue>],[<red>,<green>,<blue>]]

Puede elegir recibir información en una forma diferente, siempre que conste de ocho triples de números decimales 0-255.

_{Si recibe información en una forma diferente, los números deben ser de una longitud consistente o tener un separador no numérico entre ellos. Los triples deben tener un carácter separador a menos que estén rellenados con 0 a 9 dígitos. (Por ejemplo, 044200255044200255044200255044200255044200255044200255044200255044200255es válido, también lo son 44 200 255 44 200 255 44 200 255 44 200 255 44 200 255 44 200 255 44 200 255 44 200 255y 44?200?255$44?200?255$44?200?255$44?200?255$44?200?255$44?200?255$44?200?255$44?200?255, pero 4420025544200255442002554420025544200255442002554420025544200255no lo es).}

Salida

Una matriz / cadena / etc. que contiene los colores del píxel central (en decimal), como este:

[<red>,<green>,<blue>]

_{En caso de que genere algo que no sea una matriz: los números deben ser de una longitud constante o tener un separador no numérico entre ellos. (Por ejemplo, 044200255es válido, también lo es 44 200 255, pero 44200255no lo es).}

_{Los números pueden no contener puntos decimales, por lo que, por ejemplo, 44.0 200 255.0no es válido.}

Redondeo

La salida debe redondearse al entero más cercano. (Las mitades se deben redondear hacia arriba). Por ejemplo, si la suma de todos los rojos es 1620 , debe generar 203, no 202o 202.5.

Ejemplos

Las imágenes son sólo ilustrativas. El píxel del medio es la salida, los píxeles circundantes son la entrada.

Entrada:

[[200,200,200],[200,200,200],[200,200,200],[200,200,200],[200,200,200],[200,200,200],[200,200,200],[200,200,200]]

Salida:

[200,200,200]

Entrada:

[[0,0,0],[255,255,255],[0,0,0],[255,255,255],[255,255,255],[0,0,0],[255,255,255],[0,0,0]]

Salida:

[128,128,128]

Entrada:

[[0,200,200],[200,0,200],[200,200,0],[60,200,0],[200,0,200],[0,200,220],[2,200,0],[0,0,0]]

Salida:

[83,125,103]

Entrada:

[[0,56,58],[65,0,200],[33,200,0],[60,33,0],[98,0,200],[0,28,220],[2,200,0],[99,0,5]]

Salida:

[45,65,85]

_{Los envíos pueden ser un programa completo o una función. Se aplican las reglas estándar de E / S y lagunas .}

MATL, 8 4 bytes

YmYo

Pruébalo en línea!

¡4 bytes guardados gracias al vaso de precipitados!

Explicación:

Ym          "Get the average of each column
  Yo        "And round up

Python, 38 bytes

lambda l:[sum(r)+4>>3for r in zip(*l)]

Redondea el promedio (hacia el entero más cercano, con mitades redondeando hacia arriba) agregando 4 a la suma, luego dividiendo el piso por 8 a través del desplazamiento de bits >>3.

Jalea , 5 bytes

S+4:8

Banco de pruebas . (Ligeramente modificado para verificar todas las cajas de prueba a la vez).

S+4:8
S      sum (vectorized)
 +4    add 4
   :8  floor division by 8

C, 151 123 103 91

Requiere 24 parámetros pasados ​​al programa, en el orden RGBRGB ... y genera el triplete RGB sin una nueva línea.

i,t;main(c,v)char**v;{for(i=0;t=4,i++<3;printf("%d ",t/8))for(c=i;c<24;c+=3)t+=atoi(v[c]);}

Pyth , 8 bytes

m.R.Od0C

Banco de pruebas .

m.R.Od0C     input: Q
m.R.Od0CQ    implicit arguments
        Q    input
       C     transpose
m    d       for each:
   .O            take average
 .R   0          round off

Pyke, 7 bytes

,FsOO8f

Pruébalo aquí!

J, 11 bytes

0.5<.@++/%#

Toma la entrada como una matriz de 8x3 donde cada fila es un valor RGB

Explicación

0.5<.@++/%#  Input: a
          #  Count the number of rows
       +/    Sum along the columns
         %   Divide each sum by the count to get the averages
0.5   +      Add 0.5 to each average
   <.@       Floor each value and return

JavaScript 75 64 55 bytes

a=>a.reduce((p,c)=>p.map((e,i)=>e+c[i])).map(x=>x+4>>3)

Una respuesta de JavaScript para comenzar.

Editar: ahorró 11 bytes gracias a Dendrobium , y otros 9 gracias a Neil .

Lisp - 180 179 bytes

EDITAR: Formateado para más golf.

(defun a(l)(/(apply #'+ l)(length l)))(defun r(a)(if(integerp(* a 2))(ceiling a)(round a)))(defun c(s)(mapcar(lambda(i)(r(sqrt(a(mapcar(lambda(x)(expt(nth i x)2))s)))))'(0 1 2)))

Lo hace de la manera correcta , supongo. ^{No probado}

• a es solo promedio
• res el redondeo correcto de este desafío, ya que Lisp roundredondea al entero par más cercano
• chace el trabajo real, toma la entrada en el formato '((R G B) (R G B) (R G B) (R G B) (R G B) (R G B) (R G B) (R G B))y devuelve una '(R G B)lista con la respuesta.

Nim , 134 126 115 108 78 bytes

import math,future
x=>lc[(lc[x[j][i]|(j<-0..7),int].sum+4)shr 3|(i<-0..2),int]

Define un procedimiento anónimo, que requiere que la entrada se pase como una secuencia doblemente anidada y las salidas como una matriz de 3 elementos. El procedimiento solo puede usarse como argumento para otro procedimiento; para probar, use el siguiente contenedor:

import math,future
import strutils
proc test(x: seq[seq[int]] -> seq[int]) =
 echo x(#[ Insert your input here ]#)
test(x=>lc[(lc[x[j][i]|(j<-0..7),int].sum+4)shr 3|(i<-0..2),int])

Una secuencia de Nim es una matriz con @delante, como @[1, 2, 3]. Por lo tanto, una entrada a este procedimiento podría ser:

@[@[0,0,0],@[255,255,255],@[0,0,0],@[255,255,255],@[255,255,255],@[0,0,0],@[255,255,255],@[0,0,0]]

Japt, 8 bytes

yx ®/8 r

Intentalo

Alternativa, 9 bytes

3Æxv /8 r

Intentalo

Adelante (gforth) , 65 bytes

: f 3. do 8. do 3 j - i * 2 + roll loop 4 8. do + loop 8 / loop ;

Pruébalo en línea!

Toma datos como argumentos de pila (orden rgb)

Explicación

Para cada uno de los 3 canales de color:

• mover todos los números de ese canal a la parte superior de la pila
• agréguelos juntos
• agregue 4 (para manejar el redondeo)
• dividir por 8

Explicación del código

: f            \ start new word definition
  3. do        \ start a counted loop from 0 to 2
    8. do      \ start a counted loop from 0 to 7
      3 j -    \ get the offset of the channel
      i * 2 +  \ get the absolute position of the channel value
      roll     \ move the value to the top of the stack
    loop       \ end the inner loop
    4          \ add 4 to the top of the stack
    8. do      \ loop from 0 to 7
      +        \ add the top two stack numbers
    loop       \ end loop. (Result on top of stack with be sum of values for channel + 4)
    8 /        \ divide by 8
  loop         \ end outer loop
;              \ end word definition

Encantamientos rúnicos , 41 bytes

>iRi+ i+ i+ i+ i+ i+ i+8,'rA' q$;
>iU
>iU

Pruébalo en línea!

Utiliza 3 punteros de instrucciones para analizar la entrada en el orden correcto (ya que los valores de entrada siempre están en el orden RGB, RGB,...) y siempre que cada una de las tres IP no se fusionen y no avancen al siguiente icomando de lectura de entrada demasiado pronto (de ahí todos los espacios), funciona y ahorra bytes al tener que rotar continuamente la pila para mantener el valor correcto en la parte superior para calcular las sumas.

Técnicamente, este código contiene un error al redondear correctamente los x.5valores para algunas entradas, pero esto se debe al método de redondeo predeterminado utilizado por C # , que consiste en redondear al número de evento más cercano, en lugar de hacia arriba y se debe a problemas en la pérdida de precisión de coma flotante , y no tenía conocimiento de este problema antes de escribir esta respuesta y verificar los casos de prueba. Esto se solucionará en una compilación futura , junto con algunas otras cosas, como esta excepción no controlada .

Mientras tanto, esta modificación hace el ajuste necesario.