Ce défi a été inspiré par la programmation d'un microcontrôleur Arduino. J'ai 6 LED et 6 boutons connectés à différentes broches de la carte. Dans le code, chaque bouton et LED reçoit un numéro d'identification (1-6). Les numéros de broche (allant de 0 à 13) correspondant aux numéros d'identification sont recherchés à l'aide d'une switchdéclaration. Par pur amusement, je me demandais si ces switches pouvaient être contournés avec une fonction arithmétique / autre juste pour horrifier les futurs responsables de code.

Le défi

Fournissez la fonction / les fonctions qui prennent le numéro d'identification (entier) comme paramètre et renvoient le numéro de broche (entier) pour les 6 voyants et / ou les 6 boutons, sans utiliser d'instructions conditionnelles (non if, non switchet pas ternaire).

Valeurs de retour pour les LED:

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

Renvoie les valeurs des boutons:

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

Défi bonus

Fournissez une fonction unique qui prend un numéro d'identification (entier) et un deuxième paramètre (n'importe quel type) indiquant si les broches de LED ou de bouton sont demandées, et renvoie la broche correspondante (entier).

Règles

Ce n'est pas un défi spécifique à Arduino. Utilisez n'importe quelle langue , faites ce que vous voulez.

Edit: à la suggestion de steveverril , c'est maintenant un défi de golf de code .

Bonne chance!

(Si vous continuez à lire: bien que manifestement absurdes et arbitraires selon les normes de programmation, les mappages sont basés sur le brochage de l'Arduino Micro. Les broches 0 et 1 sont réservées pour la communication série, les LED sont affectées aux 6 broches compatibles PWM les moins numérotées , les boutons sont affectés aux broches restantes)

C, 28 octets chacun

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

C'est fondamentalement la même que la réponse de kirbyfan64sos, mais utilise un tableau de caractères au lieu d'entiers, et a un premier octet fictif donc il n'est pas nécessaire de soustraire 1 du paramètre de fonction.

Haskell, 24 octets chacun

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

vérifier:

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

.

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

vérifier:

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

bonus, Haskell, 36 octets

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

vérifier:

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

0 pour les boutons, 1 pour les LED.

C (mathématiques), 32 / 27 26 octets (45 pour le défi bonus)

Plusieurs personnes ont publié diverses solutions de recherche de table, mais cela me semblait être une solution de facilité. Je voulais voir dans quelle mesure je pouvais faire avec des opérations purement mathématiques:

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

Il n'était pas clair si une fonction appelant l'autre était acceptable ou non; sinon, on peut utiliser cette autre définition de b(i)(33 octets) à la place:

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

Challenge Bonus (45 octets):

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

(passer t=0pour les boutons, t=1pour les LED)

C, 36 octets chacun (49 octets pour le défi bonus)

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

Je suis désolé ... je ne pouvais pas m'en empêcher ... Ok, j'ai mis une vraie solution maintenant.

Défi bonus, 49 octets

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

Utilisez f(button,0)et f(pin,1).

Démo en direct chez Ideone.

Originaux:

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

La base code le tableau.

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

Le dernier fait en fait douze octets, sauf que je ne peux pas écrire de retour chariot, donc je l'ai échappé.

Suite de tests pour les boutons .

Suite de tests pour LEDS .

Pyth, Bonus uniquement: 20 octets

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

param # 2 est 0 pour les LED, 1 pour les boutons. Pour obtenir la broche # pour LED4,g4 0

J'aurais posté cela comme un commentaire à l'entrée de Maltysen, mais je viens de commencer, donc je n'ai pas la réputation requise. Je viens de commencer à utiliser PYTH ce soir et j'avoue que j'ai sans vergogne adapté sa méthode d'encodage efficace d'une liste.

Si cela était inapproprié, mes plus sincères excuses et je supprimerai mon entrée.

MIPS, 16 octets

Décalage de bits et masque de bits. Entrée $a0, sortie $v0.

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

Pour bonus, utilisez immédiatement 0xdc87420

F #, 28 + 28 octets

Je voulais essayer ceci sans table de consultation.

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

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 est pour les LED, b/2 est pour les boutons.

Bonus, 66 octets

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 pour les LED, rien d'autre pour les boutons.

q / k (18 octets chacun)

Un simple cas d'indexation:

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

Exemple:

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

Bonus (1 octet, étant donné le L & B défini)

@

Exemple:

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

CJam, 10 octets chacun

Ce sont des fonctions anonymes. Les liens vers l'interpréteur en ligne s'affichent ensuite dans un petit faisceau de test qui exécute la fonction pour toutes les valeurs d'entrée.

Fonction 1 (LED):

{5*3|4+3/}

Essayez-le en ligne

Fonction 2 (boutons):

{_6|5+*5/}

Essayez-le en ligne

J'ai écrit un petit programme qui génère et évalue ces expressions. Pour les deux, il a trouvé un certain nombre de solutions avec 8 caractères (en comptant l'expression uniquement sans les accolades), mais aucune avec moins.

Javascript (ES6), 26/27 octets

LED:

a=>`0   
`.charCodeAt(a)

Boutons:

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

Si ce qui précède ne fonctionne pas (ce qui est probable), voici 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)|

Je n'ai pas réussi à faire fonctionner le second avec un CR brut, j'ai donc dû utiliser \r

Bonus, 41 octets

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

Le deuxième paramètre est 0 pour les LED et 1 pour les boutons.

Brainf ** k, 107 octets

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

Ceci étant mon premier programme BF codé à la main, je ne doute pas qu'il y ait plusieurs optimisations à faire. Mais c'est quand même génial. :)

Je ne sais pas si cela []compte comme conditionnel, cependant ...: /

POWERSHELL - 27-27-72

Les LED utilisent 1 à 6 comme arguments

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

le bouton utilise 1..6 comme arguments

:\>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 BOUTON utiliser b 1; l 2; b 6; l 5 etc comme 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

Octave, 40 octets (défi bonus)

Utilisation d'une fonction anonuyme:

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

Après avoir défini cette fonction, appelez cette fonction comme ans(x,y), où xest le numéro de broche / bouton et yindique la broche ou le bouton avec des valeurs 1et2 respectivement.

Essayez-le en ligne

Javascript 113 74 66 59 52 33 (une fonction)

Utilisation du décalage de bits pour obtenir des valeurs de 4 bits. Doit être appelé avec 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}

Alterner.

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

Perl 4 (37 et 31 octets)

LED (37 octets):

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

... mais il utilise une table de recherche.

Boutons (31 octets, pas de recherche):

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

JavaScript (ES6) 18,22,44

Modifier plus court mais ennuyeux

// 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 octets chacun

Pas exactement créatif ou quoi que ce soit, mais ça marche!

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

Bonus, 44 octets

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

y devrait être 0 pour les LED et 1 pour les boutons.

Python, 60 + 58 = 118 octets

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)

Ce sont horribles. je ne sais même pas ce que je fais ici ...

Mais ils sont quand même assez intéressants! :RÉ

Rubis, 45 octets

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

Entrées de test:

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

Quatrième, 26 octets chacun, 34 pour le bonus

Similaire à la version C de squeamish.

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

Prime:

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

Utilisez 0 pour les LED et 6 pour les boutons. Et l'ordre des paramètres n'a pas d'importance

Pyth, 19 octets chacun

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

Pour les broches et les boutons, respectivement.