Le défi

Étant donné les deux chaînes hexadécimales majuscules (les deux 6 caractères de long, XXXXXX et YYYYYY) représentant les valeurs RVB (allant de 000000à FFFFFFinclus), et un entier positif non nul N, afficher une transition linéaire des N + 2 couleurs générées de XXXXXX à YYYYYY cela entraînerait un dégradé de couleurs.

Exemple

Contribution

FF3762
F08800
9

Production

Veuillez noter dans notre exemple, j'ai demandé 9 étapes intermédiaires entre les deux couleurs, donc 11 lignes seront affichées de la couleur initiale à la couleur finale

FF3762
FD3F58
FC474E
FA4F44
F9573A
F75F31
F66727
F46F1D
F37713
F17F09
F08800

Avertissements

Bien que j'aie opté pour un processus linéaire simple de dérivation des valeurs entières pour les couleurs intermédiaires avant de les reconvertir en hexadécimal, vos méthodes peuvent varier. Veuillez considérer les différentes façons d'arrondir / diminuer vos chiffres en conséquence.

Essai

Pour rendre cela intéressant, j'ai fourni un extrait pour permettre le test de votre code, y compris un bouton pour vous fournir deux couleurs aléatoires pour tester votre code. L'affichage de vos résultats est facultatif, mais c'est encouragé!

c1=()=>('00000'+(Math.random()*(1<<24)|0).toString(16)).slice(-6);

$("#col").click(function(){
  alert("Your two colors are: "+c1()+" and "+c1()+".");
});
        
$("#colors").blur(function(){
  $("#test").empty();
	var colArr = $("#colors").val().split("\n");
	for(c in colArr){
  	$("#test").append('<div class="tester" style="background-color:#'+colArr[c]+';">'+colArr[c]+'</div>')
  }
  
});

.tester{height: 20px;
width: 60px;padding: 4px;border: 1px solid black;}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<button id="col">Your two colors</button><br />
<textarea id="colors"></textarea>
<div id="test">

</div>

1) Vous pouvez accéder à deux couleurs aléatoires pour votre test en cliquant sur le bouton "Vos deux couleurs". 2) Le nombre d'étapes intermédiaires sera le même que le nombre de caractères dans votre nom d'utilisateur PPCG, espaces compris, dans le cas de "WallyWest", il serait de 9 (comme dans mon exemple ci-dessus). 3) Exécutez votre code avec les deux couleurs et le numéro et une fois que vous avez votre liste générée, vous avez la possibilité de coller votre sortie dans la zone de texte et de la tabuler pour obtenir votre dégradé de couleurs généré.

Mon exemple est montré ici:

Je dois admettre que ça a l'air génial!

Veuillez noter: Comme je l'ai mentionné, montrer votre test de votre sortie à l'aide de l'extrait est facultatif, mais c'est encouragé! :)

Production

La sortie de la liste doit être sous la forme de N + 2 ensembles de nombres hexadécimaux à 6 chiffres séparés par des sauts de ligne (\ n) comme indiqué dans mon exemple ci-dessus. La sortie peut prendre la forme de lignes séparées, d'une liste séparée par des espaces / virgules, d'un tableau ou de tout ce qui convient le mieux à votre langue ... (Merci @nimi pour les informations) N'oubliez pas que si vous prévoyez de tester votre code avec l'extrait, mais vous séparez chaque "couleur" est à vous.

Règles

Il s'agit de code-golf, donc la solution la plus courte en octets sera couronnée gagnante. Pas de failles , naturellement. L'entrée doit accepter les deux chaînes et un nombre (qui, comme je l'ai dit, équivaudra au nombre de lettres de votre nom d'utilisateur sur PPCG, donc votre sortie résultante aura toujours un minimum de trois lignes.

MATL , 31 octets

2+1yhjjh2e!1ZA3e!b:1&Ynk8W5Y2Za

Cela utilise une interpolation linéaire avec arrondi. Le format d'entrée est

9
FF3762
F08800

Essayez-le en ligne!

Sortie graphique, 31 octets

2+1yhjjh2e!1ZA3e!b:t2YG1&Ynk2ZG

C'est le résultat pour les entrées

5
FF3762
F08800

Essayez-le dans MATL Online ! L'interprète est actuellement expérimental. Si vous n'obtenez aucune sortie, actualisez la page et appuyez à nouveau sur "Exécuter".

JavaScript (ES6), 130 octets

g=
(f,t,n)=>[...Array(++n+1)].map((_,i)=>f.replace(/../g,(e,j)=>((`0x${e}`*(n-i)+`0x${t[j]+t[j+1]}`*i)/n|256).toString(16).slice(1)))
;
p=_=>g(f.value,t.value,+n.value).map(e=>o.insertRow().insertCell().appendChild(document.createTextNode(e)).parentNode.bgColor=e);

<input id=f value=e14f09><input id=t value=9a04f6><input id=n value=4 type=number><input type=button onclick=p() value=Go!><table id=o bgcolor=black cellpadding=4>

Dyalog APL , 44 octets

Demande N , puis B eginning-color, puis E nding-color. Besoins ⎕IO←0par défaut sur de nombreux systèmes.

h[↑⌊B∘+¨(⍳2+N)×(-/E B←(h←⎕D,⎕A)∘⍳¨⍞⍞)÷1+N←⎕]

h[... ]index en h (qui a une valeur lorsque nous finissons d'évaluer le contenu du support)

 N←⎕invite pour N numérique (4)

 1+ajouter un à N (5)

 (... )÷utilisez cela pour diviser le résultat de ...

  ⍞⍞ invite pour deux chaînes de caractères ["7E0E7E", "FF3762"]

  (... )∘⍳¨trouver les indices des caractères de chaque chaîne dans ...

   ⎕D,⎕A D igits suivie d' une lphabet

   h←assigné à h

  nous avons maintenant "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

  E B←affecter les indices à E et B [[7,14,0,14,7,14], [15,15,3,7,6,2]]

  -/soustraire et entourer B de E [[-8, -1, -3,7,1,12]]

  le résultat jusqu'à présent est [[-1.6, -0.2, -0.6,1.4,0.2,2.4]]

 (... )×multipliez cela par ...

  2+Ndeux plus N (6)

  ⍳ premiers entiers [0,1,2,3,4,5]

 cela nous donne [[0,0,0,0,0,0,0], [- 1,6, -0,2, -0,6,1,4,0,2,2,4], [- 3,2, -0,4, -1,2,2,8,0,4,4,8 ], ...]

 B∘+¨ajouter B à chacun [[15,15,3,7,6,2], [13.4,14.8,2.4,8.4,6.2.4.4], [11.8,14.6,1.8,9.8,6.4,6.8], ... ]

 ⌊ arrondir [[15,15,3,7,6,2], [13,14,2,8,6,4], [11,14,1,9,6,6], ...]

 ↑ faire la liste des listes dans le tableau

[[15,15, 3, 7, 6, 2]
 [13,14, 2, 8, 6, 4]
 [11,14, 1, 9, 6, 6]
 [10,14, 1,11, 6, 9]
 [ 8,14, 0,12, 6,11]
 [ 7,14, 0,14, 7,14]]

ici, nous indexons en h , donnant

[["F","F","3","7","6","2]
 ["D","E","2","8","6","4]
 ["B","E","1","9","6","6]
 ["A","E","1","B","6","9]
 ["8","E","0","C","6","B]
 ["7","E","0","E","7","E]]

ce qui est le même que

[["FF3762"]
 ["DE2864"]
 ["BE1966"]
 ["AE1B69"]
 ["8E0C6B"]
 ["7E0E7E"]]

et imprime en

FF3762
DE2864
BE1966
AE1B69
8E0C6B
7E0E7E

TryAPL en ligne!

Pyth - 35 octets

Golfe horriblement, abandonne.

j++hQsMCm.HMsM:F+dc-FdvzCmiR16cd2Qe

Essayez-le en ligne ici .

Exemple:

PowerShell v2 +, 176 159 150 octets

param($a,$b,$n)$x=$a-split'(..)'-ne'';$a;++$n..1|%{$j=$_;-join($x=$x|%{"{0:x2}"-f(+"0x$_"-[int]((+"0x$_"-"0x$(($b-split'(..)'-ne'')[$i++%3])")/$j))})}

Prend l'entrée sous la forme de deux chaînes et d'un nombre, puis convertit la chaîne de départ en un tableau de chaînes réparties sur deux caractères, stocke cela dans $x. Nous sortons ensuite en $atant que section de départ et bouclons de ++$nà 1(pour assurer une clôture correcte).

Chaque itération, définit l'assistant $jsur le numéro actuel (utilisé plus tard pour s'assurer que nous avons le bon nombre d'étapes entre l'endroit où nous en sommes actuellement à notre destination) et calcule l'étape suivante en fonction d'une boucle $x.

Chaque boucle intérieure n'est qu'une affectation. Nous définissons $xà l'endroit approprié égal à une nouvelle chaîne en "{0:x2}"utilisant l' -fopérateur ormat. L' x2ici spécifie une sortie hexadécimal à deux chiffres, et l'entrée est du côté droit de l' -fopérateur. PowerShell a un opérateur natif hexadécimal en décimal 0x, donc cette longue expression imbriquée parens utilise cet opérateur pour convertir l'hex courant en nombres, en soustrayant pour trouver la différence à faire (en divisant dynamiquement $bici comme nous l'avons fait $a, et en utilisant modulo pour sélectionner le bon élément), en divisant par les $jétapes restantes, en[int] (PowerShell arrondit le banquier par défaut) et soustrait ce nombre de pas de l'hex actuel pour obtenir ce que notre prochain hex doit être.

Le résultat de ce calcul est stocké dans $xtrois éléments hexadécimaux. C'est encapsulé dans des parens pour créer une copie sur le pipeline, et -joinédité ensemble dans une seule chaîne. Toutes ces chaînes résultantes sont laissées sur le pipeline, et la sortie via implicite Write-Outputse produit lors de l'exécution du programme.

Exemple

On m'a donné 0ba7c5 et 6c0e50 pour mes deux couleurs, et TimmyD contient 6 caractères.

PS C:\Tools\Scripts\golfing> .\rgb-gradients-generation.ps1 '0ba7c5' '6c0e50' 6
0ba7c5
1991b4
277ba3
356592
434f82
513971
5f2361
6c0e50

Python 2, 189 octets

w='[int(%s[i:i+2],16)for i in range(0,6,2)]'
def f(a,b,n):
 l=lambda x,y:'%02x'%int((x*(n-i)+y*i)/n);c,d,e=eval(w%'a');f,g,h=eval(w%'b');n+=1
 for i in range(n+1):print l(c,f)+l(d,g)+l(e,h)

[Groovy] Mise à jour finale (199 octets) - selon la demande

Non-golf

def g(a,b,n){
  (0..(1.0/n)).collect{
    c->
    x={s->s.split("(?<=\\G.{2})").collect{Integer.parseInt(it,16)}};
    (0..2).collect {
      (int)(x(a).get(it)*n*c+x(b).get(it)*(1-n*c))
    }.collect {
      String.format("%X", it)
    }.join()
  }
}
g('FFFFFF','000000',1/10​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​)​​​​​​​​​​​​​​

Le golf

g(a,b,n){(0..(1.0/n)).collect{c->x={s->s.split("(?<=\\G.{2})").collect{Integer.parseInt(it,16)}};(0..2).collect {(int)(x(a).get(it)*n*c+x(b).get(it)*(1-n*c))}.collect{String.format("%X",it)}.join()}}

Essayez la finale ici: https://groovyconsole.appspot.com/script/5130696796405760

ANCIENNES VERSIONS CI-DESSOUS, REFUSÉES PAR OP

Groovy (123 octets)

Le golf

def g(r,g,b,r2,g2,b2,s){(1..(1.0/s)).collect{c->[(int)(r*s*c+r2*(1-s*c)),(int)(g*s*c+g2*(1-s*c)),(int)(b*s*c+b2*(1-s*c))]}}

Non-golf

def g(r,g,b,r2,g2,b2,s){
  (1..(1.0/s)).collect {
    c ->
    [(int)(r*s*c+r2*(1-s*c)),(int)(g*s*c+g2*(1-s*c)),(int)(b*s*c+b2*(1-s*c))]
  }
}

Contributions

r,g,b -> Starting RGB Color
r2,g2,b2 -> Ending RGB Color
s -> Gradient step

Exemple de sortie

(00,00,00,255,255,255,.5)

résulte en

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

Essayez-le vous-même: https://groovyconsole.appspot.com/script/5184465357766656

Avec conversions hexadécimales incluses

Je suppose que je triche aussi ... Voici le script avec l'utilisation de hex:

Nouveau code avec des conversions hexadécimales:

​    def g(r,g,b,r2,g2,b2,s){
      (0..(1.0/s)).collect {
        c ->
        String.format("%X", ((int)(r*s*c+r2*(1-s*c)))) +  String.format("%X", ((int)(g*s*c+g2*(1-s*c)))) + "" +  String.format("%X", ((int)(b*s*c+b2*(1-s*c))))
      }
    }

    g(126,34,166,218,26,33,0.0625)​

188 personnages au golf:

def g(r,g,b,r2,g2,b2,s){(0..(1.0/s)).collect {c->String.format("%X",((int)(r*s*c+r2*(1-s*c))))+String.format("%X",((int)(g*s*c+g2*(1-s*c))))+String.format("%X",((int)(b*s*c+b2*(1-s*c))))}}

Sortie pour 000000 vers FFFFFF et 16 (longueur du nom d'utilisateur)

g(00,00,00,255,255,255,0.0625).each{println it}​

R, 68 octets

Il existe une fonction intégrée qui interpole deux couleurs:

a=scan(,'')
colorRampPalette(paste0("#",a[1:2]))(as.numeric(a[3])+2)

Contribution:

d9e7a5
3ef951
15

Sortie: un vecteur avec des valeurs

"#D9E7A5" "#CFE89F" "#C5E99A" "#BBEA95" "#B2EB90" "#A8EC8A" "#9EED85" "#95EE80"
"#8BF07B" "#81F175" "#78F270" "#6EF36B" "#64F466" "#5BF560" "#51F65B" "#47F756"
"#3EF951"

La spécification des couleurs dans R nécessite un symbole de hachage.

Trottons quelque chose, comme une fonction:

filled.contour(outer(1:20, 1:20, function(x,y) sin(sqrt(x*y)/3)),
    col = colorRampPalette(paste0("#",a[1:2]))(as.numeric(a[3])+2))

C, 175 169 168 octets

i;j;x[6];f(a,b,n)char*a,*b;{char*f="%2x%2x%02x";for(n++;i<=n;i++,puts(""))for(j=sscanf(a,f,x,x+1,x+2)-sscanf(b,f,x+3,x+4,x+5);j++<printf(f+6,x[j]+(x[j+3]-x[j])*i/n););}

Non golfé:

int i, j;
int x[3], y[3];

f(char *a, char *b, int n) {
  sscanf(a, "%2x%2x%2x", &x[0], &x[1], &x[2]);
  sscanf(b, "%2x%2x%2x", &y[0], &y[1], &y[2]);

  for(i = 0, n++; i <= n; i++) {
    for(j = 0; j < 3; j++)
      printf("%02x", x[j] + (y[j] - x[j]) * i / n);
    puts("");
  }
}

Merci à @ h-walters d'avoir rasé 5 octets!

sh + ImageMagick, 81 octets

convert -size 1x$((2+$3)) gradient:#$1-#$2 -depth 8 txt:-|grep -o "[A-F0-9]\{6\}"

usage:

> ./grad.sh FF3762 F08800 9
FF3762
FE3F58
FC474E
FB4F45
F9573B
F86031
F66827
F5701D
F37814
F2800A
F08800

("-depth 8" n'est pas nécessaire si votre messagerie instantanée est compilée avec 8bpp par défaut)