Esse desafio foi inspirado na programação de um microcontrolador Arduino. Tenho 6 LEDs e 6 botões conectados a vários pinos na placa. No código, cada botão e LED recebe um número de identificação (1-6). Os números dos pinos (variando de 0 a 13) correspondentes aos números de identificação são pesquisados ​​usando uma switchinstrução. Puramente por diversão, eu queria saber se essas switches poderiam ser contornadas com uma função aritmética / outra apenas para horrorizar futuros mantenedores de código.

O desafio

Forneça a função / funções que tomam o número de identificação (número inteiro) como parâmetro e retorne o número do pino (número inteiro) para os 6 LEDs e / ou os botões 6, sem usar instruções condicionais (não if, não switche não ternário).

Valores de retorno para LEDs:

ID    Pin
1      3 
2      5
3      6
4      9
5     10
6     11

Retorne valores para os botões:

ID    Pin
1      2 
2      4
3      7
4      8
5     12
6     13

Desafio de bônus

Forneça uma única função que use um número de identificação (número inteiro) e um segundo parâmetro (qualquer tipo) indicando se os pinos de LED ou botão são solicitados e retorne o pino correspondente (número inteiro).

Regras

Este não é um desafio específico do Arduino. Use qualquer idioma , faça o que quiser.

Edit: por sugestão de steveverril , este é agora um desafio de código de golfe .

Boa sorte!

(Se você ainda está lendo: apesar de claramente absurdo e arbitrário pelos padrões de programação, os mapeamentos são baseados na pinagem do Arduino Micro. Os pinos 0 e 1 são reservados para comunicação serial, os LEDs são atribuídos aos 6 pinos com capacidade PWM de número mais baixo botões são atribuídos aos pinos restantes)

C, 28 bytes cada

p(i){return"@cefijk"[i]&15;}
b(i){return"@bdghlm"[i]&15;}

Isso é basicamente o mesmo que a resposta de kirbyfan64sos, mas usa uma matriz de caracteres em vez de números inteiros e possui um primeiro byte fictício, portanto não é necessário subtrair 1 do parâmetro de função.

Haskell, 24 bytes cada

l 1=3
l n=n+l(div(n+2)3)

checar:

> map l [1..6]
[3,5,6,9,10,11]

.

b 1=2
b n=n+b(div(n+1)2)

checar:

> map b [1..6]
[2,4,7,8,12,13]

bônus, Haskell, 36 bytes

a f 1=f+2
a f n=n+a f(n+f+1`div`f+2)

checar:

> map (a 0) [1..6]
[2,4,7,8,12,13]
> map (a 1) [1..6]
[3,5,6,9,10,11]

0 para botões, 1 para LEDs.

C (matemática), 32 / 27 26 bytes (45 para desafio de bônus)

Várias pessoas postaram várias soluções de pesquisa de tabela, mas isso me pareceu o caminho mais fácil. Eu queria ver o quão bem eu poderia fazer com operações puramente matemáticas:

p(i){return~i&1|i*2^i*!(i%5-1);}
b(i){return i/5*5+1^p(i);}

Não ficou claro se uma função que chamava a outra era aceitável ou não; caso contrário, pode-se usar esta definição alternativa de b(i)(33 bytes):

b(i){return(i&1|i*2)+i/5-!(i/2);}

Desafio de bônus (45 bytes):

f(i,t){return(i&1|i*2)+i/5-!(i/2)^t+i/5*5*t;}

(passe t=0para botões, t=1para LEDs)

C, 36 bytes cada (49 bytes para o desafio do bônus)

p(i){return 3500459>>(4*(7+~i))&15;}
b(i){return 2390221>>(4*(7+~i))&15;}

Me desculpe ... eu simplesmente não pude evitar ... Ok, eu coloquei uma solução real agora.

Desafio de bônus, 49 bytes

f(i,t){return(2390221+t*1110238)>>(4*(7+~i))&15;}

Use f(button,0)e f(pin,1).

Demonstração ao vivo na Ideone.

Originais:

p(i){int a[]={3,5,6,9,10,11};return a[i-1];}
b(i){int a[]={2,4,7,8,12,13};return a[i-1];}

Pyth - 12 bytes cada

Base codifica a matriz.

@jC"Ý"14tQ (buttons)
@jC"\r'"12tQ (leds)

O último é na verdade doze bytes, exceto que eu não posso escrever um retorno de carro, então eu escapei dele.

Conjunto de teste para botões .

Conjunto de teste para LEDS .

Pitão, apenas bônus: 20 bytes

M@jC"5i«$xÍ"16+*6HtG

o parâmetro 2 é 0 para LEDs, 1 para botões. Para obter o Pin # para LED4,g4 0

Eu teria postado isso como um comentário na entrada de Maltysen, mas acabei de começar, por isso não tenho a reputação necessária. Comecei a usar o PYTH hoje à noite e admito que adaptei descaradamente o método dele de codificar com eficiência uma lista.

Se isso foi inapropriado, peço desculpas mais profundas e removerei minha entrada.

MIPS, 16 bytes

Mudança de bit e máscara de bit. Entrada $a0, saída $v0.

sll     $t0, $a0, 2 
li      $t1, 0xba96530
srlv    $t0, $t1, $t0   
andi    $v0, $t0, 0xf

Para bônus, use imediatamente 0xdc87420

F #, 28 + 28 bytes

Eu queria tentar isso sem uma tabela de pesquisa.

let L x=1+x*2-x%4/3-x/5-x/6
let B x=x*2+x/3-x/4+x%6/5*2

SWI-Prolog, 34 bytes cada

l(I,P):-nth1(I,[3,5,6,9,10,11],P).
b(I,P):-nth1(I,[2,4,7,8,12,13],P).

l/2é para LEDs, b/2é para botões.

Bônus, 66 bytes

a(I,S,P):-nth1(I,[3:2,5:4,6:7,9:8,10:12,11:13],A:B),(S=0,P=A;P=B).

S = 0 para LEDs, qualquer outra coisa para botões.

q / k (18 bytes cada)

Simplesmente um caso de indexação:

L:0N 3 5 6 9 10 11
B:0N 2 4 1 8 12 13

Exemplo:

q) L[2]
5
q) B[6]
13

Bônus (1 byte, considerando L & B definido)

@

Exemplo:

q) @[`L;2]
5
q) @[`B;6]
13

CJam, 10 bytes cada

Essas são funções anônimas. Os links para o intérprete online são exibidos em um pequeno equipamento de teste que executa a função para todos os valores de entrada.

Função 1 (LEDs):

{5*3|4+3/}

Experimente online

Função 2 (botões):

{_6|5+*5/}

Experimente online

Eu escrevi um pequeno programa que gera e avalia essas expressões. Para os dois, encontrou várias soluções com 8 caracteres (contando a expressão apenas sem chaves), mas nenhuma com menos.

Javascript (ES6), 26/27 bytes

LEDs:

a=>`0   
`.charCodeAt(a)

Botões:

a=>`0\r`.charCodeAt(a)

Se o acima não for executado (o que é provável), aqui está um hexdump:

00000000: 6C 3D 61 3D 3E 60 30 03 - 05 06 09 0A 0B 60 2E 63 |l=a=>`0      `.c|
00000010: 68 61 72 43 6F 64 65 41 - 74 28 61 29 0A 62 3D 61 |harCodeAt(a) b=a|
00000020: 3D 3E 60 30 02 04 07 08 - 0C 5C 72 60 2E 63 68 61 |=>`0     \r`.cha|
00000030: 72 43 6F 64 65 41 74 28 - 61 29                   |rCodeAt(a)|

Não consegui que o segundo trabalhasse com um CR bruto, então tive que usar \r

Bônus, 41 bytes

(a,b)=>`0   
\r`.charCodeAt(a+b*6)

Hexdump

00000000: 28 61 2C 62 29 3D 3E 60 - 30 03 05 06 09 0A 0B 02 |(a,b)=>`0       |
00000010: 04 07 08 0C 5C 72 60 2E - 63 68 61 72 43 6F 64 65 |    \r`.charCode|
00000020: 41 74 28 61 2B 62 2A 36 - 29                      |At(a+b*6)|

O segundo parâmetro é 0 para LEDs e 1 para botões.

Brainf ** k, 107 bytes

,>++++++++[>+>++++++<<-<------>]<[>+++<-[>++<-[>+<-[>+++<-[>>>+>+<<<[-]+<-]]]]]>>[<++++++>-]<.>>>[-[-]<-.>]

Sendo este o meu primeiro programa BF codificado manualmente, não duvido que haja várias otimizações a serem feitas. Mas ainda é incrível. :)

Não tenho certeza se []conta como condicional, no entanto ...: /

POWERSHELL - 27-27-72

LED use 1..6 como args

:\>wc -c LED.PS1 & cat LED.PS1 & echo.& powershell -nologo -f LED.PS1 1
27 LED.PS1
(0,3,5,6,9,10,11)[$args[0]]
3

botão use 1..6 como args

:\>wc -c button.PS1 & cat button.PS1 & echo.& powershell -nologo -f button.PS1 6    
27 button.PS1
(0,2,4,7,8,12,13)[$args[0]]
13

LED ou BOTÃO use b 1; 12; b 6; l 5 etc como args

:\>wc -c ledbutt.PS1 & cat ledbutt.PS1 & echo.& powershell -nologo -f ledbutt.PS1 b 5
72 ledbutt.PS1
$a=@{"b"=(0,3,5,6,9,10,11);"l"=(0,2,4,7,8,12,13)};$a[$args[0]][$args[1]]
10
:\>powershell -nologo -f ledbutt.PS1 l 5
12    
:\>powershell -nologo -f ledbutt.PS1 b 3
6    
:\>powershell -nologo -f ledbutt.PS1 l 2
4

Oitava, 40 bytes (desafio bônus)

Usando uma função anônima:

@(x,y)[3 2;5 4;6 7;9 8;10 12;11 13](x,y)

Depois de definir esta função, chame-a como ans(x,y), onde xé o número do pino / botão e yindica o pino ou botão com valores 1e 2respectivamente.

Experimente online

Javascript 113 74 66. 59. 52 33 (uma função)

Usando deslocamento de bits para obter valores de 4 bits. Deve ser chamado com p (n, 195650864 ou 231240736).

/*
  11   10    9    6    5    3
1011 1010 1001 0110 0101 0011 0000 = 195650864

  13   12    8    7    4    2
1101 1100 1000 0111 0100 0010 0000 = 231240736

                   b >> i * 4 xxxx
                         & 15 1111
                              yyyy (matching 1s)
*/
// Where b = 195650864 for pins and 231240736 for buttons.
function p(i,b){return b>>i*4&15}

Alternar.

/*
Using bitwise * 4 for bitwise only.    
function p(i,b){return b>>(i<<2)&15}
*/

Perl 4 (37 e 31 bytes)

LEDs (37 bytes):

$c=pop;$c*2+($c~~[1,2,4,6]&&5.5<=>$c)

... mas usa uma tabela de pesquisa.

Botões (31 bytes, sem pesquisa):

$c=pop;2*($c+($c==5))+($c%3==0)

JavaScript (ES6) 18,22,44

Editar Mais curto, mas chato

// LED 
l=i=>1-~' 134789'[i]
// Buttons
b=i=>[,2,4,7,8,12,13][i]

// bonus
f=(i,t)=>1-~[' 134789',[,0,2,5,6,10,11]][t][i]

//Test

out=x=>O.innerHTML+=x+'\n'

for(i=1;i<=6;i++) out(i +' -> '+l(i) + ' '+b(i) +' '+f(i,0)+' '+f(i,1))

<pre id=O></pre>

Python, 31 bytes cada

Não é exatamente criativo ou qualquer coisa, mas funciona!

l=lambda x:int(" 3569AB"[x],16)
b=lambda x:int(" 2478CD"[x],16)

Bônus, 44 bytes

k=lambda x,y:int("3569AB2478CD"[x-1+6*y],16)

y deve ser 0 para LEDs e 1 para botões.

Python, 60 + 58 = 118 bytes

p=lambda i:(2**i)*(i<3)+1+(i>2)*(5+3*(i-3))-(i>4)*(i-3+~i%2)
b=lambda i:2**i-(i>2)-(i>3)*(2**(i-1)-1)-4*(i>4)-15*(i==6)

Estes são horríveis. eu nem sei o que estou fazendo aqui ...

Mas eles são bem interessantes, no entanto! : D

Ruby, 45 bytes

->i,t{[3,5,6,9,10,11,2,4,7,8,12,13][t*6+i-1]}

Entradas de teste:

->i,t{[3,5,6,9,10,11,2,4,7,8,12,13][t*6+i-1]}.call 1,0
=> 3

->i,t{[3,5,6,9,10,11,2,4,7,8,12,13][t*6+i-1]}.call 3,1
=> 7

Quarto, 26 bytes cada, 34 para bônus

Semelhante à versão C por melindroso.

: P " CEFIJK" + C@ F AND ;
: B " BDGHLM" + C@ F AND ;

Bônus:

: A " CEFIJKBDGHLM" + + C@ F AND ;

Use 0 para LEDs e 6 para botões. E a ordem dos parâmetros não importa

Pyth, 19 bytes cada

L.&.>3500459*4-6b15
L.&.>2390221*4-6b15

Para alfinetes e botões, respectivamente.