Diese Herausforderung wurde durch die Programmierung eines Arduino-Mikrocontrollers inspiriert. Ich habe 6 LEDs und 6 Tasten mit verschiedenen Pins auf der Platine verbunden. Im Code ist jeder Taste und LED eine ID-Nummer (1-6) zugeordnet. PIN-Nummern (von 0-13), die den ID-Nummern entsprechen, werden mit einer switchAnweisung gesucht . Nur zur Unterhaltung habe ich mich gefragt, ob diese switchmit einer arithmetischen / anderen Funktion umgangen werden können, um zukünftige Codewartende zu schrecken.

Die Herausforderung

Geben Sie die Funktion (en) an, für die die ID-Nummer (Ganzzahl) als Parameter verwendet wird, und geben Sie die PIN-Nummer (Ganzzahl) für die 6 LEDs und / oder die 6 Tasten zurück, ohne bedingte Anweisungen (nein if, nein switchund ternär) zu verwenden.

Rückgabewerte für LEDs:

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

Rückgabewerte für Schaltflächen:

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

Bonus Herausforderung

Stellen Sie eine einzelne Funktion bereit, die eine ID-Nummer (Ganzzahl) und einen zweiten Parameter (beliebiger Typ) verwendet, die angeben, ob LED- oder Tastenstifte angefordert werden, und den entsprechenden Stift (Ganzzahl) zurückgibt.

Regeln

Dies ist keine Arduino-spezifische Herausforderung. Verwenden Sie eine beliebige Sprache und machen Sie , was Sie wollen.

Edit: Auf Anregung von Steveverril ist dies nun eine Code-Golf- Herausforderung.

Viel Glück!

(Wenn Sie noch lesen: Obwohl die Zuordnungen nach Programmierstandards offensichtlich absurd und willkürlich sind, basieren sie auf der Pinbelegung des Arduino Micro. Die Pins 0 und 1 sind für die serielle Kommunikation reserviert, die LEDs sind den 6 PWM-fähigen Pins mit der niedrigsten Nummer zugeordnet , Tasten sind den verbleibenden Pins zugeordnet)

C jeweils 28 Bytes

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

Dies ist im Grunde das Gleiche wie die Antwort von kirbyfan64sos, verwendet jedoch ein Zeichen-Array anstelle von Ganzzahlen und hat ein Dummy-erstes Byte, sodass vom Funktionsparameter keine 1 subtrahiert werden muss.

Haskell, jeweils 24 Bytes

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

überprüfen:

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

.

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

überprüfen:

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

Bonus, Haskell, 36 Bytes

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

überprüfen:

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

0 für Tasten, 1 für LEDs.

C (Mathe), 32 / 27 26 Bytes (45 für Bonus Challenge)

Einige Leute haben verschiedene Tabellen-Lookup-Lösungen veröffentlicht, aber das schien mir ein einfacher Ausweg zu sein. Ich wollte sehen, wie gut ich mit rein mathematischen Operationen umgehen kann:

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

Es war nicht klar, ob eine Funktion, die die andere aufruft, akzeptabel war oder nicht. Wenn nicht, kann b(i)stattdessen diese alternative Definition von (33 Byte) verwendet werden:

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

(Pass t=0für Tasten, t=1für LEDs)

C, je 36 Bytes (49 Bytes für die Bonus-Challenge)

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

Es tut mir leid ... ich konnte einfach nicht anders ... Ok, ich habe jetzt eine echte Lösung gefunden.

Bonus Challenge, 49 Bytes

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

Verwenden Sie f(button,0)und f(pin,1).

Live-Demo bei Ideone.

Originale:

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 - jeweils 12 Bytes

Base codiert das Array.

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

Das letzte ist tatsächlich zwölf Bytes, außer ich kann keinen Wagenrücklauf schreiben, so dass ich es geschafft habe.

Test Suite für Buttons .

Testsuite für LEDS .

Pyth, nur Bonus: 20 Bytes

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

Parameter 2 ist 0 für LEDs, 1 für Tasten. Pin # für LED4 erhalten,g4 0

Ich hätte dies als Kommentar zu Maltysens Eintrag gepostet, aber ich habe gerade erst angefangen, daher fehlt mir der erforderliche Ruf. Ich habe heute Abend gerade angefangen, PYTH zu verwenden, und gebe zu, dass ich seine Methode zum effizienten Codieren einer Liste schamlos angepasst habe.

Wenn dies unangemessen war, entschuldige ich mich zutiefst und werde meinen Eintrag entfernen.

MIPS, 16 Bytes

Bitverschiebung und Bitmaske. Eingabe in $a0, Ausgabe in $v0.

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

Für Bonus sofort verwenden 0xdc87420

F #, 28 + 28 Bytes

Ich wollte dies ohne eine Nachschlagetabelle versuchen.

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 mit jeweils 34 Bytes

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/2ist für LEDs, b/2ist für Tasten.

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 für LEDs, alles andere für Buttons.

q / k (jeweils 18 Bytes)

Einfach ein Indizierungsfall:

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

Beispiel:

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

Bonus (1 Byte, gegebenes L & B definiert)

@

Beispiel:

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

CJam, jeweils 10 Bytes

Dies sind anonyme Funktionen. Die Links zum Online-Interpreter zeigen dann innerhalb eines kleinen Testgeschirrs, dass die Funktion für alle Eingabewerte ausführt.

Funktion 1 (LEDs):

{5*3|4+3/}

Probieren Sie es online aus

Funktion 2 (Tasten):

{_6|5+*5/}

Probieren Sie es online aus

Ich habe ein kleines Programm geschrieben, das diese Ausdrücke generiert und auswertet. Für beide wurden eine Reihe von Lösungen mit 8 Zeichen gefunden (der Ausdruck wird nur ohne geschweifte Klammern gezählt), jedoch keine mit weniger.

Javascript (ES6), 26/27 Bytes

LEDs:

a=>`0   
`.charCodeAt(a)

Tasten:

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

Wenn das obige nicht läuft (was wahrscheinlich ist), ist hier ein 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)|

Ich konnte den zweiten nicht dazu bringen, mit einem rohen CR zu arbeiten, also musste ich verwenden \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)|

Der zweite Parameter ist 0 für LEDs und 1 für Tasten.

Brainf ** k, 107 Bytes

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

Da dies mein erstes handcodiertes BF-Programm ist, bezweifle ich nicht, dass mehrere Optimierungen vorgenommen werden müssen. Aber es ist trotzdem großartig. :)

Ich bin mir nicht sicher, ob dies []als Bedingung gilt ...: /

POWERSHELL - 27-27-72

LED verwenden 1..6 als Argumente

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

button benutze 1..6 als Argumente

:\>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 oder TASTE verwenden b 1; l 2; b 6; L 5 usw. als Argumente

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

Oktave, 40 Bytes (Bonus Challenge)

Verwendung einer anonymen Funktion:

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

Rufen Sie nach dem Definieren dieser Funktion diese Funktion auf als ans(x,y), wobei xdie Pin- / Tastennummer ist und yPin oder Taste mit Werten 1bzw. 2bezeichnet.

Probieren Sie es online aus

JavaScript 113 74 66 59 52 33 (eine Funktion)

Verwenden der Bitverschiebung zum Abrufen von 4-Bit-Werten. Muss mit p (n, 195650864 oder 231240736) aufgerufen werden.

/*
  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}

Wechseln.

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

Perl 4 (37 und 31 Bytes)

LEDs (37 Byte):

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

... aber es wird eine Nachschlagetabelle verwendet.

Schaltflächen (31 Byte, keine Suche):

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

JavaScript (ES6) 18,22,44

Bearbeiten Kürzer aber langweilig

// 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, jeweils 31 Bytes

Nicht gerade kreativ oder so, aber es funktioniert!

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 sollte 0 für LEDs und 1 für Tasten sein.

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)

Diese sind schrecklich. Ich weiß nicht mal, was ich hier mache ...

Aber sie sind trotzdem ziemlich interessant! : D

Rubin, 45 Bytes

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

Testeingänge:

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

Viertens jeweils 26 Bytes, 34 als Bonus

Ähnlich wie die C-Version von Squeamish.

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

Bonus:

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

Verwenden Sie 0 für LEDs und 6 für Tasten. Und die Reihenfolge der Parameter spielt keine Rolle

Pyth, jeweils 19 Bytes

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

Für Stifte bzw. Knöpfe.