Les défis de caméléon sont apparemment une mauvaise chose . Dommage, les caméléons sont de belles créatures. Le temps de changer!

Comme nous le savons tous, de nombreux caméléons possèdent une remarquable capacité à se fondre dans leur environnement en changeant la couleur de leur peau. C'est aussi l'objectif de ce défi.

Défi

Imaginez un carré de neuf pixels. Huit pixels sont les environs. Au centre se trouve le caméléon.

Comme ça:

Le caméléon essaie naturellement de se fondre dans son environnement. Il le fait en changeant sa couleur à la moyenne de celle des pixels environnants. Donc, dans ce cas, le caméléon changerait de couleur .

Objectif

Compte tenu des couleurs des pixels environnants, sortez la couleur du caméléon.

La couleur du caméléon est définie comme le total de tous les rouges, verts et bleus dans les pixels ÷ 8.

Contribution

Un tableau de valeurs de couleur pour les huit pixels environnants, commençant en haut à gauche et se poursuivant dans le sens horaire, comme ceci:

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

Vous pouvez choisir de recevoir une entrée sous une forme différente, à condition qu'elle se compose de huit triplets de nombres décimaux 0-255.

_{Si vous recevez des entrées sous une forme différente, les nombres doivent être d'une longueur cohérente ou avoir un séparateur non numérique entre eux. Les triplets doivent avoir un caractère de séparation, sauf s'ils sont remplis de 0 à 9 chiffres. (Par exemple, 044200255044200255044200255044200255044200255044200255044200255044200255est valide, ainsi que 44 200 255 44 200 255 44 200 255 44 200 255 44 200 255 44 200 255 44 200 255 44 200 255et 44?200?255$44?200?255$44?200?255$44?200?255$44?200?255$44?200?255$44?200?255$44?200?255, mais 4420025544200255442002554420025544200255442002554420025544200255ne l'est pas.)}

Production

Un tableau / chaîne / etc. contenant les couleurs du pixel central (en décimal), comme ceci:

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

_{Dans le cas où vous produisez autre chose qu'un tableau: les nombres doivent être de longueur cohérente ou avoir un séparateur non numérique entre eux. (Par exemple, il 044200255est valide 44 200 255, mais 44200255ne l'est pas.)}

_{Les nombres peuvent ne pas contenir de décimales, par exemple, ils ne 44.0 200 255.0sont pas valides.}

Arrondi

La sortie doit être arrondie à l'entier le plus proche. (Les moitiés doivent être arrondies.) Par exemple, si la somme de tout le rouge est 1620 , vous devez produire 203, non 202ou 202.5.

Exemples

Les photos sont à titre indicatif seulement. Le pixel du milieu est la sortie, les pixels environnants sont l'entrée.

Contribution:

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

Production:

[200,200,200]

Contribution:

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

Production:

[128,128,128]

Contribution:

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

Production:

[83,125,103]

Contribution:

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

Production:

[45,65,85]

_{Les soumissions peuvent être un programme complet ou une fonction. Les règles d' E / S standard et d' échappatoire s'appliquent.}

MATL, 8 4 octets

YmYo

Essayez-le en ligne!

4 octets économisés grâce au bécher!

Explication:

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

Python, 38 octets

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

Arrondit la moyenne (vers l'entier le plus proche, avec des moitiés arrondies) en ajoutant 4 à la somme, puis en divisant le plancher par 8 via le décalage de bits >>3.

Gelée , 5 octets

S+4:8

Suite de tests . (Légèrement modifié de manière à vérifier tous les tests en même temps.)

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

C, 151 123 103 91

Nécessite 24 paramètres transmis au programme, dans l'ordre RGBRGB ... et sort le triplet RGB sans nouvelle ligne.

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 octets

m.R.Od0C

Suite de tests .

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 octets

,FsOO8f

Essayez-le ici!

J, 11 octets

0.5<.@++/%#

Prend l'entrée comme un tableau 8x3 où chaque ligne est une valeur RVB

Explication

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 octets

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

Une réponse JavaScript pour commencer.

Edit: enregistré 11 octets grâce à Dendrobium , et 9 autres grâce à Neil .

Lisp - 180 179 octets

EDIT: formaté pour la poursuite du 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)))

Le fait-il de la bonne façon , je suppose. ^{Non testé.}

• a est juste moyen
• rest l'arrondi correct de ce défi, puisque Lisp roundarrondit à l'entier pair le plus proche
• cfait le vrai travail, en prenant la saisie dans le format '((R G B) (R G B) (R G B) (R G B) (R G B) (R G B) (R G B) (R G B))et en renvoyant une '(R G B)liste contenant la réponse.

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]

Définit une procédure anonyme, qui nécessite l'entrée transmise sous forme de séquence imbriquée et les sorties sous forme de tableau à 3 éléments. La procédure ne peut être utilisée que comme argument d'une autre procédure; pour tester, utilisez le wrapper suivant:

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

Une séquence Nim est un tableau avec @devant, comme @[1, 2, 3]. Un apport à cette procédure pourrait donc être:

@[@[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 octets

yx ®/8 r

Essayez-le

Alternative, 9 octets

3Æxv /8 r

Essayez-le

Forth (gforth) , 65 octets

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

Essayez-le en ligne!

Prend les entrées comme arguments de pile (ordre RVB)

Explication

Pour chacun des 3 canaux de couleur:

• déplacer tous les numéros de ce canal vers le haut de la pile
• ajoutez-les ensemble
• ajouter 4 (pour gérer l'arrondi)
• diviser par 8

Explication du code

: 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

Enchantements runiques , 41 octets

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

Essayez-le en ligne!

Utilise 3 pointeurs d'instructions pour analyser l'entrée dans le bon ordre (car les valeurs d'entrée sont toujours dans l'ordre RGB, RGB,...) et tant que chacune des trois IP ne fusionne pas et ne passe pas itrop tôt à la prochaine commande read nput (d'où tous les espaces), cela fonctionne et économise des octets sur la rotation continue de la pile pour garder la valeur correcte en haut afin de calculer les sommes.

Techniquement, ce code contient une erreur dans les x.5valeurs d' arrondi correctement pour certaines entrées, mais cela est dû à la méthode d'arrondi par défaut utilisée par C # , qui consiste à arrondir au numéro d'événement le plus proche, plutôt qu'à la hausse et est due à des problèmes de perte de précision en virgule flottante et je n'étais pas au courant de ce problème avant d'écrire cette réponse et de vérifier les cas de test. Cela sera corrigé dans une future version , avec quelques autres choses telles que cette exception non gérée .

En attendant, cette modification apporte les ajustements nécessaires.