Cor RGB int para hexadecimal

13

Dado três números inteiros rgb, produza representação hexadecimal como uma sequência.

Input:          Output:
72 61 139       #483D8B
75 0 130        #4B0082
0 255 127       #00FF7F

O código mais heterodoxo mais curto vence

code-golf 
— Quillion
fonte
16
Nosso FAQ diz que todas as perguntas neste site ... devem ter um critério objetivo de vitória primário, para que seja possível decidir indiscutivelmente qual entrada deve ganhar. . O menor é objetivo, mas o "não ortodoxo" não é. Além disso, a tag code-golf deve ser usada apenas se a condição vencedora for apenas o código mais curto; e a tag code-challenge deve ser usada apenas se a tag code-golf não for.
— Peter Taylor
e aceitar o vencedor antes de algum tempo (neste caso, nem sequer era 24h) tipo de desencoraja outras contribuições ...
— woliveirajr
@PeterTaylor Desculpe eu vou ter certeza de ler os guidlines a partir de agora :( Eu acho que você é pouco ortodoxo direito é muito vago
— Quillion

Respostas:

14

Ruby: 19 caracteres

$_=?#+"%02X"*3%$F

Exemplo de execução:

bash-4.1$ ruby -pae '$_=?#+"%02X"*3%$F' <<< '72 61 139'
#483D8B

bash-4.1$ ruby -pae '$_=?#+"%02X"*3%$F' <<< '75 0 130'
#4B0082

bash-4.1$ ruby -pae '$_=?#+"%02X"*3%$F' <<< '0 255 127'
#00FF7F
— homem a trabalhar
fonte
16

Rubi

Eu estava indo mais para a parte "não ortodoxa". ;)

10;a=    gets.   split
.  map  {|       x|  #x
"%02X"  %(  x.   to_i)
}; $>   <<   ?#  <<  a[
00  ..   1+2].   join;

A fonte (no meu navegador da web) é um pouco alta, portanto parece distorcida, mas fica melhor no Courier New:

imagem

Exemplo de execução:

c:\a\ruby>rgb2hex
255 100 0
#FF6400
— Maçaneta da porta
fonte
Isso é genial!
— Albert Renshaw
6

q / k (3 caracteres)

Não exatamente heterodoxo, mas bastante curto

4h$

Exemplo

q)4h$ 72 61 139
0x483d8b

Para corresponder exatamente ao formato de saída na pergunta, podemos fazer (por 9 caracteres):

"#",/$4h$
— skeevey
fonte
1
Está faltando o sinal de libra (#) necessário para as saídas de amostra na pergunta.
— Iszi
5

PowerShell: 71 52 51 41

Os agradecimentos a @manatwork por apontar ForEach-Objectpodem ser usados ​​no lugar de um forloop.
Obrigado a @Joey por apontar que eu poderia usar -joina saída do loop, em vez de precisar colocá-la em variáveis.

Código de golfe:

'#'+-join(1..3|%{"{0:X2}"-f+(read-host)})

Nota:

Não há erro ao verificar aqui se há entradas inválidas. O script aceita 256, 4096 e 65536 como entradas e, em seguida, gera a saída # 100100010000 (que obviamente não funciona como RGB).

Ungolfed, com comentários:

# Put a hashtag in front of the output.
'#'+

# Join the nested code into one string.
-join(

    # Pipe 1..3 to ForEach-Object to run a loop three times.
    1..3|%{

        # Take user input and format it as hex, with minimum two digits in output.
        "{0:X2}"-f+(read-host)
    }
)
— Iszi
fonte
Faça o loop foreach($i in 1,2,3)para reduzi-lo para 68 caracteres.
— manatwork
@ manatwork Eu não acho que essa seja a sintaxe apropriada para um foreachno PowerShell. (Pelo menos, não consegui fazer algumas execuções de teste funcionarem.) No entanto, usando a sintaxe correta, um alias interno e outro atalho do PowerShell que descobri recentemente, acho que tenho algo melhor: fazer a barba outros 12 caracteres fora da sua sugestão. (1..3)|%{...}(Insira uma declaração entre colchetes do script existente no lugar das reticências.) Ainda preciso testar isso completamente no script, mas obrigado por me indicar nessa direção!
— Iszi 13/11
Não faço ideia se é a sintaxe adequada ou não, mas a referência do SS64 foreachmenciona isso e funciona para mim. (Nenhuma idéia sobre a versão. A que acompanha o Windows 7.)
— manatwork
@ manatwork Isso é interessante. Eu gostaria de descobrir um pouco mais sobre o que há de errado nisso (eu estava recebendo erros de "token inesperado 'em' ..."). É possível que o artigo SS64 tenha sido escrito para uma versão diferente do PowerShell - não tenho certeza. Por enquanto, confirmei que (1..3)|%funciona e reduz o script para 56 caracteres. Vou editar isso na resposta e, definitivamente, dar crédito a você pela ideia. Obrigado novamente!
— Iszi
2
Oh, caramba. Você pode obter este a 41 usando -join: '#'+-join(1..3|%{"{0:X2}"-f+(read-host)}).
— Joey
4

bash 22 21 caracteres

(Obrigado @manatwork por 1 caractere usando em \vez de aspas duplas)

printf \#%02X%02X%02X 12 12 12 
#0C0C0C

ou lendo STDIN em um loop: 48 caracteres:

while read f;do printf "#%02X%02X%02X\n" $f;done <<<$'72 61 139\n75 0 130\n0 255 127'
#483D8B
#4B0082
#00FF7F

Adicionado em 06-10-2015: bash ( método não ortodoxo ) 84 83 chars

c=({0..9} {a..f}) d=\#;for b;do for a in / %;do d+=${c[$b$a 020]};done;done;echo $d

Eu sei, poderia ter 82 caracteres se 020escrito 16, mas eu prefiro isso ... Ou talvez o d+=${c[$b$a 0x10]}que foi o primeiro post.

hexcolor() {
    local a b c=({0..9} {a..f}) d=\#
    for b ;do
        for a in / % ;do
            d+=${c[$b$a 0x10]}
        done
    done
    echo $d
}
hexcolor 72 61 139
#483d8b
hexcolor 75 0 130
#4b0082
hexcolor 0 255 127
#00ff7f

Outra abordagem bash

#!/bin/bash
browser=firefox   #  google-chrome iceweasel
url="data:text/html;charset=UTF-8,<html><head></head><body>"
url+="<script type='text/javascript'>
  function h(i){var h=i.toString(16);if(16>1*i)h='0'+h;
  return h};function C(r,g,b){return'\043'+h(r)+h(g)+h(b)};
  function m(){ var r=1.0*R.value; var g=1.0*G.value; var b=1.0*B.value;
   var fore='black';if(384>r+g+b)fore='white';var c=C(r,g,b);
   s.setAttribute('style','background:'+c+';color:'+fore+';');s.innerHTML=c};
  function w(e){console.log(e);var val=e.target.value;var q=1;if(e.shiftKey)
  q=15;if(e.detail){if(e.detail>0){q=0-q;}}else if(0>e.wheelDelta){q=0-q;};
  val=1*val+q;if(val>255)val=255;if(0>val)val=0;e.target.value=val;m(); };
  function k(e){console.log(e);var val=e.target.value;var q=1;if(e.shiftKey)q=
  15;if(e.keyCode==38){val=1*val+q;if(val>255)val=255;e.target.value=val;m();}
  else if(e.keyCode==40){val=1*val-q;if(0>val)val=0;e.target.value=val;m();}};
  function n(){R=document.getElementById('R');G=document.getElementById('G');
    B=document.getElementById('B');s=document.getElementById('s');
    R.addEventListener('DOMMouseScroll',w);R.addEventListener('mousewheel',w);
    G.addEventListener('DOMMouseScroll',w);G.addEventListener('mousewheel',w);
    B.addEventListener('DOMMouseScroll',w);B.addEventListener('mousewheel',w);
  m();};var R, G, B, s;window.onload=n;
  </script><style>div{display:inline-block;width:10em;}</style>
  <div id='s'>&nbsp;</div>"
input="%s:<input type='text' size='5' value='200'"
input+=" onKeyDown='k(event)' onChange='m()' id='%s' />"
for c in R G B ;do
    printf -v add "$input" $c $c
    url+="$add"
  done    
$browser "$url"

Isso exibirá uma janela do navegador, com:

Conversor hexadecimal RGB int 2

Onde você pode rolar o botão do mouse para alterar os valores (com a tecla Shift pressionada no passo 15) ...

— F. Hauri
fonte
Na verdade, a nova linha final não foi solicitada e apenas "#" precisa ser escapado, o que printf \#%02X%02X%02Xé suficiente.
— Manatwork
Adicionado um método mais não ortodoxo :
— F. Hauri 06/10
Ri muito. Esse laço interno é realmente incrivelmente heterodoxo.
— manatwork
@manatwork obrigado, acho d+=${c[$b$a 0x10]}algo sexy !
— F. Hauri
1
... ou talvez d+=${c[$b$a 020]}irá fazer o trabalho e aparência agradável
— F. Hauri
3

Perl, 31 caracteres

perl -nE 'say"#",map{unpack H2,chr}split'

É difícil tornar um programa tão curto não ortodoxo, mas acho que isso funciona.

— caixa de pão
fonte
Eu gosto desta resposta :) mais algumas e acho que posso resolver isso se nada melhor acontecer.
— Quillion 7/11
Legal! Apenas uma unpackpergunta: você pode fazer o hexadecimal a..f em maiúsculas, como na pergunta?
— 113813 manatwork
Manatwork @ Eu tentei encontrar uma maneira de fazê-lo dentro de unpack, mas sem sorte. Uma maneira é usar em sprintfvez de unpack, mas isso é mais longo e completamente ortodoxo. A outra maneira é apenas modificar a string para maiúscula:, map{uc unpack H2,chr}a um custo de três caracteres.
— breadbox
Obrigado, @breadbox. Esses pequenos truques packe unpacknunca entram no meu estilo de codificação. Portanto, não é ortodoxo o suficiente para mim.
— Manatwork
Contagem errada. Isso faz 30 caracteres!
— 11553 F. Hauri
3

Script de Ação 3 | 43 caracteres

trace("#"+(72<<16|61<<139|b).toString(16));

Resultado: #483D8B

— Ilya Gazman
fonte
Você não pode deixar muito espaço em branco aqui? Eu não sei Action Script, mas eles não parecem necessário
— Triturador de
@ Cruncher sim desculpe, uma das minhas primeiras respostas aqui.
— Ilya Gazman
2
Mate o ponto-e-vírgula no final para salvar um caractere
— Maçaneta da porta
3

Perl 24 chars

perl -ne 'printf"#"."%02x"x3,split'
13 31 133
#0d1f85

Desculpe, não é tão sexy quanto usar unpack, mas mais curto!

Versão mais obscura:

Mas se você realmente preferir usar unpack, poderá:

$==24;s/\d+[\n ]*/{$=-=8;($&<<$=).do{rand>.5?qw<+>[0]:"|"}}/eg;$_=
pack("N",eval($_.587.202.560));say$1,unpack("H6",$2)if/^(.)(.*)$/s

Por exemplo, não é a versão mais curta, mas eu gosto! (Observe o uso de randpara randering this :-)

perl -nE '
    $==24;s/\d+[\n ]*/{$=-=8;($&<<$=).
    do{rand>.5?qw<+>:"|"}}/eg;$_=pack(
    "N",eval($_.587.202.560) );say $1,
    unpack("H"."6",$2) if /^(.)(.*)$/s
  ' <<< $'72 61 139\n75 0 130\n0 255 127'
#483d8b
#4b0082
#00ff7f
— F. Hauri
fonte
3

> <> 103 60

"#"or>1[:82*%:}-82*,86*+:"9"v
    ;^?l ]o+*7)"9":+*68o+*7)<

Utilizou o espaço em branco desperdiçado e moveu algum código para ele

Execute com entradas da linha de comandos:

python fish.py generateHex.fish -v 255 36 72

saída: "# FF2448"

— Triturador
fonte
Fornecerá explicação a pedido. Se você pode descobrir isso eu prefiro não incomodar
— Cruncher
2

Quarto, 62 caracteres

: D 0 <<# # # #> TYPE #>> ; 35 EMIT HEX SWAP ROT D D D DECIMAL
— Darren Stone
fonte
não funciona para 1 1 1 que deve saída # 010101
— catraca aberração
Oi @ratchetfreak. Funciona para mim. Apenas testado com gforth. Dando 1 1 1saídas #010101. Quaisquer outros valores de 0 a 255 também funcionam. Que ambiente ou você está usando?
— precisa
2

C (67 caracteres sem clichê principal)

int r,g,b;
scanf("%d %d %d",&r,&b,&g);
printf("#%06x",r<<16|g<<8|b);

o uso padrão do pântano printf & bit twiddler

— catraca arrepiante
fonte
Espera readf? Não deveria ser scanf?
— breadbox
@breadbox ah sim, eu passei muito tempo em D; De qualquer maneira nenhuma diferença na contagem de char
— aberração catraca
2

Dc: 35 32 caracteres

[#]n16o?ShShSh[Lhd16/n16%n]ddxxx

Exemplo de execução:

bash-4.1$ dc -e '[#]n16o?ShShSh[Lhd16/n16%n]ddxxx' <<< '72 61 139'
#483D8B

bash-4.1$ dc -e '[#]n16o?ShShSh[Lhd16/n16%n]ddxxx' <<< '75 0 130'
#4B0082

bash-4.1$ dc -e '[#]n16o?ShShSh[Lhd16/n16%n]ddxxx' <<< '0 255 127'
#00FF7F

Dc: 27 24 caracteres

(Mas precisa dos números de entrada em linhas separadas.)

[#]n16o[?d16/n16%n]ddxxx

Exemplo de execução:

bash-4.1$ dc -e '[#]n16o[?d16/n16%n]ddxxx' <<< $'72\n61\n139'
#483D8B

bash-4.1$ dc -e '[#]n16o[?d16/n16%n]ddxxx' <<< $'75\n0\n130'
#4B0082

bash-4.1$ dc -e '[#]n16o[?d16/n16%n]ddxxx' <<< $'0\n255\n127'
#00FF7F
— homem a trabalhar
fonte
2
Não há dcrespostas suficientes neste site.
— breadbox
2

JavaScript, 89 caracteres

console.log('#' + ('00000' + eval('256*(256*(' + DEC.replace(/ /g, ')+')).toString(16)).slice(-6))

Convertidos 72 61 139para 256*(256*(72)+61)+139e evals TI.

— Casey Chu
fonte
Agradável, mas falha na 3ª amostra publicada na pergunta.
— manatwork
Ah, boa ligação. Fixo.
— Casey Chu
2
Usando em eval('(('+DEC.replace(/ /g,'<<8)+'))vez de eval('256*(256*('+DEC.replace(/ /g,')+'))permitir salvar 5 caracteres!
— F. Hauri 12/11
2

PowerShell, 45

'#'+-join(-split(read-host)|%{'{0:X2}'-f+$_})

Ou, se puder ser usado canalizando os dados, você pode apenas usar

'#'+-join(-split"$input"|%{'{0:X2}'-f+$_})

o que reduz para 42 .

— Joey
fonte
Bom trabalho! Shows Ainda tenho muito a aprender sobre golfe!
— Iszi
Ah, sua ideia com as variáveis ​​também foi inteligente; nunca teria passado pela minha cabeça. Acontece que é mais do que o meu favorito de sempre: -splite -join.
— Joey
2

PowerShell 37

economizou um byte graças a TimmyD

cat rgb2hex.ps1
$args|%{$o+="{0:X2}"-f[byte]$_};"#$o"
wc -c rgb2hex.ps1
38 rgb2hex.ps1
powershell -f .\rgb2hex.ps1 72 61 139
#483D8B
powershell -f .\rgb2hex.ps1 0 255 127
#00FF7F
— blabb
fonte
Você pode salvar alguns bytes, livrando-se do [byte]dado que recebemos a entrada como números inteiros e editando sua saída para "#$o"- que fornece 31 bytes para$args|%{$o+="{0:X2}"-f$_};"#$o"
— AdmBorkBork
@ TimmyD não sei se a remoção de [byte] funciona corretamente em todas as versões de uma versão em que eu testei (iirc 2.0 em xp) sem [byte] não estava concatenando como hexadecimal, mas como ints, isto é, 72 61 139 era # 7261139 e não # 483d8b "# $ o" dentro de aspas não é uma string literal, mas uma string avaliada é bom saber obrigado, comentários sobre a conversão hexadecimal serão apreciados
— blabb
Aparentemente, é uma diferença entre o PowerShell v2 e a v3 - deve haver algo em como a versão .NET correspondente lida com a conversão hexadecimal, mas não consigo encontrar documentação.
— AdmBorkBork
2

R, 16 bytes

É isso aí. Use o incorporado.

rgb(r,g,b,m=255)
— J.Doe
fonte
1

C, 67 73 caracteres (65 caracteres, exceto principal)

main(){int a,b,c;scanf("%d%d%d",&a,&b,&c);printf("#%02X%02X%02X",a,b,c);}

Programa C chato - muito ortodoxo.

— Ian James
fonte
não funciona com ab ou c menor do que 16
— catraca aberração
% X para% 02X alterado.
— 31513 Ian
1

Python 2.7 (80 caracteres)

x=lambda y: ("0"+hex(int(y))[2:])[-2:]
print "#"+''.join(map(x,input().split()))

Estou procurando uma maneira melhor de lidar com os valores hexadecimais de um dígito. Alguma ideia?

— Will Coggins
fonte
Talvez use seqüências de caracteres de formato? '% 02x' parece ser o que todos os outros fizeram.
— Jqblz # 7/15
1

Befunge-98, 45 caracteres

Bleh, código duplicado. Ah bem. Apenas uma implementação direta da conversão de raiz.

"#",v
7*+,>#@&:97+/"0"+:"9"`7*+,97+%"0"+:"9"`

Execução de amostra

% cfunge tohex.98 <<<'72 61 139'
#483D8B
% cfunge tohex.98
#75 0 130
4800820 255 127
00FF7F

(Nota: imprime '#' antes de ler a entrada - a tarefa não proíbe isso; dados três números no stdin, ele produz a saída correta no stdout. Também não se incomoda com as novas linhas e, como você pode ver, não adicione '#' corretamente quando executar "interativamente".)

— FireFly
fonte
1

Linguagem do Game Maker, 175 (Erro na posição 81)

Solicita RGB de 3 a 9 dígitos. Retorna hexadecimal com sinal hexadecimal GML,$

d=get_string('','')if(d=='')e=""else e="00"h="0123456789ABCDEF"while(d!=''){b=d&255i=string_char_at(h,byte div 16+1)l=string_char_at(h,byte mod 16+1)e+=i+l;d=d>>8}return '$'+e

Faça disso um script. Além disso, compile com variáveis ​​não inicializadas tratadas como 0.

Fonte

— Timtech
fonte
1

Gema, 93 caracteres

\B=@set{x;0123456789abcdef}\#
<D>=@substring{@div{$1;16};1;$x}@substring{@mod{$1;16};1;$x}
?=

Exemplo de execução:

bash-4.3$ gema '\B=@set{x;0123456789abcdef}\#;<D>=@substring{@div{$1;16};1;$x}@substring{@mod{$1;16};1;$x};?=' <<< '0 255 127'
#00ff7f
— homem a trabalhar
fonte
1

Burlsque, 12 bytes (10 bytes para minúsculas)

Se letras minúsculas também forem permitidas, 10 bytes:

psb6\['#+]

Uso:

blsq ) "72 61 139"psb6\['#+]
"#483d8b"

Se você precisar desesperadamente de letras maiúsculas, adicione ZZ:

blsq ) "72 61 139"psb6\['#+]ZZ
"#483D8B"

Se você não receber os números inteiros como em uma string, vá com:

blsq ) {72 61 139}b6\['#+]
"#483d8b"

Explicação:

ps -- parse string
b6 -- to hex
\[ -- concat
'#+] -- prepend #

Experimente online aqui .

Bônus:

Para convertê-lo novamente, use o seguinte:

blsq ) "#483d8b"[-2cob6
{72 61 139}
— mroman
fonte
1

Powershell, 28 bytes

'#{0:X2}{1:X2}{2:X2}'-f$args

Script de teste:

$f = {

"#{0:X2}{1:X2}{2:X2}"-f$args
}

@(
    ,('#483D8B',72, 61, 139)
    ,('#4B0082',75,  0, 130)
    ,('#00FF7F',0 ,255, 127)
) | % {
    $e,$a = $_
    $r = &$f @a
    "$($r-eq$e): $r"
}

Resultado:

True: #483D8B
True: #4B0082
True: #00FF7F
— confuso
fonte
0

Python3.3 a 60 caracteres

print("#"+3*"%.2X"%tuple(int(n) for n in input().split()))

Não pude resistir:

[dan@danbook:code_golf/int_to_hex]$ python3.3 int_to_hex.py
176 11 30
#B00B1E
— danmcardle
fonte
0

Clojure 76 Personagens

Isso pode ser tarde, por uma questão de integridade:

(defn hexy [r g b] (reduce str (cons "#" (map #(format "%02X" %) [r g b]))))

Chamadas de exemplo:

(hexy 0 255 127)
"#00FF7F"
— Lynx Luna
fonte
0

Mathematica, 40 caracteres

f = StringJoin["#", IntegerString[#, 16, 2]] &

rgbs = {{72, 61, 139}, {75, 0, 130}, {0, 255, 127}}

f /@ rgbs // Column

# 483d8b

# 4b0082

# 00ff7f

— Chris Degnen
fonte
0

Lisp comum, 39 caracteres

(format()"#~@{~2,'0x~}"#1=(read)#1##1#)

Leia três números inteiros, retorne uma string.

— coredump
fonte
0

Javascript ES6, 63 bytes

h=>'#'+h.split` `.map(x=>(x<16?0:'')+(x*1).toString(16)).join``
— Mama Fun Roll
fonte
Coincidentemente, acabei escrevendo quase exatamente a mesma coisa que você antes de ver a sua. Muito bom =) Eles estão próximos o suficiente para eu não publicar os meus, mas você pode salvar alguns bytes no seu mapeamento com este: # x=>(x<16?0:'')+x.toString(16)
— Mwr247
1
Além disso, não há necessidade de incluir o r=no início. Ele ainda conta como uma função, mesmo como uma função anônima, pois você pode invocá-la sem precisar atribuir nada.
— Mwr247
Ops. O mapa era o seguinte: o x=>(x<16?0:'')+(x*1).toString(16)seu e o meu primeiro indicam valores incorretos no momento x>9.
— Mwr247
Atualmente, ele retorna em #7261139vez de #483D8Bpara o primeiro caso de teste.
— Dennis
0

Python 2, 40 bytes

s='#';exec's+="%02X"%input();'*3;print s

Lê a entrada de três linhas separadas. Abusosexec e multiplicação de strings.

Exemplo de uso:

$ python2 rgbint.py
72
61
139
#483D8B

$ python2 rgbint.py
75
0
130
#4B0082

$ python2 rgbint.py
0
255
127
#00FF7F
— jqblz
fonte
0

Python (55 caracteres)

'#'+''.join([hex(int(i))[2:].upper() for i in input()])
— Dhruv Ramani
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.