Questa sfida è stata ispirata dalla programmazione di un microcontrollore Arduino. Ho 6 LED e 6 pulsanti collegati a vari pin sulla scheda. Nel codice, a ciascun pulsante e LED è assegnato un numero ID (1-6). I numeri di pin (compresi tra 0 e 13) corrispondenti ai numeri ID vengono cercati utilizzando aswitch un'istruzione. Per puro divertimento, mi chiedevo se questi switches potessero essere elusi con un'aritmetica / altra funzione solo per spaventare i futuri manutentori del codice.

La sfida

Fornire la funzione / le funzioni che accettano il numero ID (numero intero) come parametro e restituiscono il numero del pin (numero intero) per i 6 LED e / o i 6 pulsanti, senza utilizzare istruzioni condizionali (no if, no switche no ternary).

Valori di ritorno per LED:

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

Valori di ritorno per i pulsanti:

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

Sfida bonus

Fornire una singola funzione che accetta un numero ID (intero) e un secondo parametro (qualsiasi tipo) che indica se sono richiesti LED o pin dei pulsanti e restituisce il pin corrispondente (intero).

Regole

Questa non è una sfida specifica per Arduino. Usa qualsiasi lingua , fai quello che vuoi.

Modifica: su suggerimento di Steveverril , questa è ora una sfida al golf del codice .

In bocca al lupo!

(Se stai ancora leggendo: sebbene palesemente assurdo e arbitrario secondo gli standard di programmazione, i mapping sono basati sulla piedinatura di Arduino Micro. I pin 0 e 1 sono riservati per la comunicazione seriale, i LED sono assegnati ai 6 pin con PWM con il numero più basso , i pulsanti sono assegnati ai pin rimanenti)

C, 28 byte ciascuno

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

Questa è sostanzialmente la stessa della risposta di kirbyfan64sos, ma utilizza un array di caratteri anziché numeri interi e ha un primo byte fittizio, quindi non è necessario sottrarre 1 dal parametro della funzione.

Haskell, 24 byte ciascuno

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

controllare:

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

.

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

controllare:

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

bonus, Haskell, 36 byte

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

controllare:

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

0 per i pulsanti, 1 per i LED.

C (matematica), 32 / 27 26 byte (45 per sfida bonus)

Diverse persone hanno pubblicato varie soluzioni per la ricerca di tabelle, ma mi è sembrato di prendere una semplice via d'uscita. Volevo vedere quanto potevo fare con operazioni puramente matematiche:

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

Non era chiaro se una funzione che chiamava l'altra fosse accettabile o meno; in caso contrario, è possibile utilizzare questa definizione alternativa di b(i)(33 byte) invece:

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

Bonus Challenge (45 byte):

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

(passa t=0per i pulsanti, t=1per i LED)

C, 36 byte ciascuno (49 byte per la sfida bonus)

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

Mi dispiace ... non potevo proprio evitarlo ... Ok, ho messo una soluzione reale ora.

Sfida bonus, 49 byte

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

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

Demo live su Ideone.

Originals:

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

Base codifica l'array.

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

L'ultimo è in realtà dodici byte, tranne per il fatto che non riesco a scrivere un ritorno a capo, quindi sono scappato.

Test Suite per pulsanti .

Test Suite per LED .

Pyth, solo bonus: 20 byte

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

il parametro # 2 è 0 per i LED, 1 per i pulsanti. Per ottenere il Pin # per LED4,g4 0

Avrei pubblicato questo come commento alla voce di Maltysen, ma ho appena iniziato, quindi non ho la reputazione richiesta. Ho appena iniziato a usare PYTH stasera e ammetto di aver spudoratamente adattato il suo metodo per codificare in modo efficiente un elenco.

Se questo fosse inappropriato, le mie scuse più profonde e rimuoverò la mia iscrizione.

MIPS, 16 byte

Spostamento e maschera di bit. Ingresso in $a0, uscita in $v0.

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

Per bonus, usa immediato 0xdc87420

F #, 28 + 28 byte

Volevo provare questo senza una tabella di ricerca.

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

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è per i LED, b/2è per i pulsanti.

Bonus, 66 byte

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 per i LED, qualsiasi altra cosa per i pulsanti.

q / k (18 byte ciascuno)

Semplicemente un caso di indicizzazione:

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

Esempio:

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

Bonus (1 byte, dato L & B definito)

@

Esempio:

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

CJam, 10 byte ciascuno

Queste sono funzioni anonime. I collegamenti all'interprete online mostrano quindi all'interno di un piccolo cablaggio di test che esegue la funzione per tutti i valori di input.

Funzione 1 (LED):

{5*3|4+3/}

Provalo online

Funzione 2 (pulsanti):

{_6|5+*5/}

Provalo online

Ho scritto un piccolo programma che genera e valuta queste espressioni. Per entrambi, ha trovato una serie di soluzioni con 8 caratteri (contando l'espressione solo senza parentesi graffe), ma nessuna con meno.

Javascript (ES6), 26/27 byte

LED:

a=>`0   
`.charCodeAt(a)

pulsanti:

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

Se quanto sopra non funziona (il che è probabile), ecco 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)|

Non sono riuscito a far funzionare il secondo con un CR non elaborato, quindi ho dovuto utilizzarlo \r

Bonus, 41 byte

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

Il secondo parametro è 0 per i LED e 1 per i pulsanti.

Brainf ** k, 107 byte

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

Trattandosi del mio primo programma BF codificato a mano, non dubito che ci siano diverse ottimizzazioni da apportare. Ma è comunque fantastico. :)

Non sono sicuro se []conta come condizionale, però ...: /

POWERSHELL - 27-27-72

I LED usano 1..6 come 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

il pulsante usa 1..6 come 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 PULSANTE utilizzano b 1; l 2; b 6; l 5 ecc. come 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

Ottava, 40 byte (sfida bonus)

Usando una funzione anonuymous:

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

Dopo aver definito questa funzione, chiamare questa funzione come ans(x,y), dove si xtrova il numero pin / pulsante e yindica pin o pulsante con valori1 e 2rispettivamente.

Provalo online

JavaScript 113 74 66 59 52 33 (una funzione)

Utilizzo del bit shift per ottenere valori a 4 bit. Deve essere chiamato 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}

Alternato.

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

Perl 4 (37 e 31 byte)

LED (37 byte):

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

... ma utilizza una tabella di ricerca.

Pulsanti (31 byte, nessuna ricerca):

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

JavaScript (ES6) 18,22,44

Modifica più breve ma noioso

// 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 byte ciascuno

Non esattamente creativo o altro, ma funziona!

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

Bonus, 44 byte

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

y dovrebbe essere 0 per i LED e 1 per i pulsanti.

Python, 60 + 58 = 118 byte

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)

Sono orribili. non so nemmeno cosa ci faccio qui ...

Ma sono comunque piuttosto interessanti! : D

Rubino, 45 byte

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

Ingressi di prova:

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

Avanti, 26 byte ciascuno, 34 per bonus

Simile alla versione C di schizzinoso.

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

Bonus:

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

Utilizzare 0 per i LED e 6 per i pulsanti. E l'ordine dei parametri non ha importanza

Pyth, 19 byte ciascuno

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

Per pin e pulsanti, rispettivamente.