Este desafío se inspiró en la programación de un microcontrolador Arduino. Tengo 6 LED y 6 botones conectados a varios pines en el tablero. En el código, a cada botón y LED se le asigna un número de identificación (1-6). Los números de PIN (que van del 0 al 13) correspondientes a los números de ID se buscan utilizando una switchdeclaración. Solo para divertirme, me preguntaba si estos switcheses podrían eludirse con una función aritmética / otra solo para horrorizar a los futuros mantenedores de código.

El reto

Proporcione la función / funciones que toman el número de ID (entero) como parámetro y devuelve el número de pin (entero) para los 6 LED y / o los 6 botones, sin usar declaraciones condicionales (no if, no switchy no ternary).

Valores de retorno para LED:

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

Valores de retorno para botones:

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

Desafío de bonificación

Proporcione una única función que tome un número de identificación (entero) y un segundo parámetro (cualquier tipo) que indique si se solicitan LED o pines de botón, y devuelva el pin correspondiente (entero).

Reglas

Este no es un desafío específico de Arduino. Usa cualquier idioma , haz lo que quieras.

Editar: a sugerencia de steveverril , este es ahora un desafío de golf de código .

¡Buena suerte!

(Si todavía está leyendo: aunque es evidentemente absurdo y arbitrario según los estándares de programación, los mapeos se basan en el pinout del Arduino Micro. Los pines 0 y 1 están reservados para la comunicación en serie, los LED se asignan a los 6 pines con capacidad PWM con el número más bajo , los botones se asignan a los pines restantes)

C, 28 bytes cada uno

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

Esto es básicamente lo mismo que la respuesta de kirbyfan64sos, pero usa una matriz de caracteres en lugar de enteros, y tiene un primer byte ficticio, por lo que no es necesario restar 1 del parámetro de la función.

Haskell, 24 bytes cada uno

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

verificar:

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

.

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

verificar:

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

bonificación, Haskell, 36 bytes

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

verificar:

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

0 para botones, 1 para LED.

C (matemáticas), 32 / 27 26 bytes (45 para desafío extra)

Varias personas han publicado varias soluciones de búsqueda de tablas, pero eso me pareció una solución fácil. Quería ver qué tan bien podría hacerlo con operaciones puramente matemáticas:

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

No estaba claro si una función que llamaba a la otra era aceptable o no; si no, uno puede usar esta definición alternativa de b(i)(33 bytes) en su lugar:

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

Bonus Challenge (45 bytes):

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

(pase t=0para botones, t=1para LED)

C, 36 bytes cada uno (49 bytes para el desafío adicional)

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

Lo siento ... no pude evitarlo ... Ok, ahora pongo una solución real.

Bonus challenge, 49 bytes

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

Uso f(button,0)y f(pin,1).

Demostración en vivo en Ideone.

Originales:

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 uno

Base codifica la matriz.

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

El último es en realidad doce bytes, excepto que no puedo escribir un retorno de carro, así que escapé.

Test Suite para botones .

Test Suite para LEDS .

Pyth, solo bonificación: 20 bytes

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

el parámetro # 2 es 0 para LED, 1 para botones. Para obtener el Pin # para LED4,g4 0

Hubiera publicado esto como un comentario a la entrada de Maltysen, pero recién comencé, así que carece de la reputación requerida. Acabo de comenzar a usar PYTH esta noche, y admito que adapté descaradamente su método de codificar eficientemente una lista.

Si esto fue inapropiado, mis más sinceras disculpas, y eliminaré mi entrada.

MIPS, 16 bytes

Bit shifting y bitmask. Entrada $a0, salida en $v0.

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

Para obtener bonificaciones, use inmediatamente 0xdc87420

F #, 28 + 28 bytes

Quería probar esto sin una tabla de búsqueda.

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 uno

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 es para LEDs, b/2 es para botones.

Bonus, 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 LED, cualquier otra cosa para botones.

q / k (18 bytes cada uno)

Simplemente un caso de indexación:

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

Ejemplo:

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

Bono (1 byte, dado que L y B están definidos)

@

Ejemplo:

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

CJam, 10 bytes cada uno

Estas son funciones anónimas. Los enlaces al intérprete en línea se muestran dentro de un pequeño arnés de prueba que ejecuta la función para todos los valores de entrada.

Función 1 (LED):

{5*3|4+3/}

Pruébalo en línea

Función 2 (botones):

{_6|5+*5/}

Pruébalo en línea

Escribí un pequeño programa que genera y evalúa estas expresiones. Para ambos, encontró una serie de soluciones con 8 caracteres (contando la expresión solo sin las llaves), pero ninguna con menos.

Javascript (ES6), 26/27 bytes

LEDs:

a=>`0   
`.charCodeAt(a)

Botones:

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

Si lo anterior no funciona (lo que es probable), aquí hay un 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)|

No pude conseguir que el segundo funcionara con un CR sin procesar, así que tuve que usar \r

Bonus, 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)|

El segundo parámetro es 0 para los LED y 1 para los botones.

Brainf ** k, 107 bytes

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

Siendo este mi primer programa BF codificado a mano, no dudo que haya varias optimizaciones que hacer. Pero sigue siendo asombroso. :)

No estoy seguro si []cuenta como condicional, aunque ...: /

POWERSHELL - 27-27-72

LED usa 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ón 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 o BOTÓN uso b 1; l 2; 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

Octava, 40 bytes (desafío adicional)

Usando una función anónima:

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

Después de definir esta función, llame a esta función como ans(x,y), donde xestá el número de pin / botón e yindica pin o botón con valores 1y 2respectivamente.

Pruébalo en línea

JavaScript 113 74 66 59 52 33 (una función)

Usando bit shift para obtener valores de 4 bits. Debe llamarse con p (n, 195650864 o 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}

Alterno.

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

Perl 4 (37 y 31 bytes)

LED (37 bytes):

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

... pero usa una tabla de búsqueda.

Botones (31 bytes, sin búsqueda):

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

JavaScript (ES6) 18,22,44

Editar más corto pero aburrido

// 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 uno

No es exactamente creativo ni nada, ¡pero funciona!

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

Bonus, 44 Bytes

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

y debe ser 0 para los LED y 1 para los botones.

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)

Estos son horribles Ni siquiera sé lo que estoy haciendo aquí ...

¡Pero son bastante interesantes! :RE

Rubí, 45 bytes

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

Entradas de prueba:

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

Adelante, 26 bytes cada uno, 34 para bonificación

Similar a la versión C de Squeamish.

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

Prima:

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

Use 0 para LED y 6 para botones. Y el orden de los parámetros no importa

Pyth, 19 bytes cada uno

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

Para alfileres y botones, respectivamente.