Bu zorluk, bir Arduino mikrokontrolcüsünü programlayarak ilham verdi. Tahtadaki çeşitli pinlere bağlı 6 LED ve 6 buton var. Kodda, her bir düğmeye ve LED'e bir kimlik numarası (1-6) atanır. Kimlik numaralarına karşılık gelen pin numaraları (0-13 arasında değişen) bir switchifade kullanılarak aranır. Tamamen eğlence için, bu switchkodların gelecekteki kod koruyucular için dehşete düşecek bir aritmetik / başka bir işlevle üstesinden gelinebileceklerini merak ediyordum .

Meydan okuma

ID numarasını (tamsayı) parametre olarak alan ve koşullu ifadeleri (no if, no switchve no ternary) kullanmadan 6 LED ve / veya 6 düğmesinin pin numarasını (tamsayı) veren fonksiyonu / işlevleri sağlayın .

LED'ler için dönüş değerleri:

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

Düğmeler için dönüş değerleri:

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

Bonus mücadelesi

Bir ID numarası (tamsayı) ve LED veya düğme pinlerinin istenip istenmediğini belirten ikinci parametre (herhangi bir tür) alan ve karşılık gelen pimi (tamsayı) döndüren tek bir işlev sağlayın.

kurallar

Bu değil bir Arduino özgü meydan okuma. Herhangi bir dili kullanın , istediğiniz şeyi yapın.

Düzenleme: steveverril'in önerisi üzerine , bu şimdi kod kodlu bir oyundur .

İyi şanslar!

(Hala okuyorsanız: programlama standartlarına göre açıkça saçma ve keyfi olmasına rağmen, eşlemeler Arduino Micro'nun pin çıkışı üzerine kuruludur. 0 ve 1 numaralı pinler seri iletişim için ayrılmıştır, LED'ler en düşük numaralı 6 numaralı PWM özelliğine sahip pinlere atanmıştır. , düğmeler kalan pinlere atanır)

C, her biri 28 bayt

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

Bu temelde kirbyfan64sos tarafından verilen cevapla aynıdır, ancak tamsayılar yerine bir char dizisi kullanır ve kukla ilk bayta sahip olduğundan, işlev parametresinden 1 çıkarmaya gerek yoktur.

Haskell, her biri 24 bayt

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

kontrol etmek:

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

.

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

kontrol etmek:

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

bonus, Haskell, 36 bayt

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

kontrol etmek:

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

Düğmeler için 0, LED'ler için 1.

C (matematik), 32 / 27 26 bayt (bonus mücadelesi için 45)

Birkaç kişi çeşitli masa arama çözümleri yayınladı, ancak bu bana kolay yoldan çıkmak gibi görünüyordu. Tamamen matematiksel işlemlerle ne kadar iyi yapabileceğimi görmek istedim:

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

Birinin diğerini çağıran fonksiyonun kabul edilebilir olup olmadığı açık değildi; değilse, b(i)bunun yerine alternatif (33 bayt) tanımını kullanabilirsiniz :

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

Bonus Mücadelesi (45 bayt):

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

( t=0düğmeler t=1için geçiş , LED'ler için)

C, her biri 36 bayt (bonus mücadelesi için 49 bayt)

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

Üzgünüm ... Sadece yardım edemedim ... Tamam, şimdi gerçek bir çözüm buldum.

Bonus meydan okuma, 49 bayt

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

Kullanım f(button,0)ve f(pin,1).

Ideone'da canlı demo.

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 - Her biri 12 bayt

Base diziyi kodlar.

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

Sonuncusu on iki bayt, ancak bir satır başı yazamıyorum bu yüzden kaçtım.

Düğmeler için Test Paketi .

LED'ler için Test Suite .

Pyth, Sadece bonus: 20 bayt

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

param # 2, LED'ler için 0, Düğmeler için 1'dir. LED4 için Pin # almak için,g4 0

Bunu Maltysen'in girişine yorum olarak gönderirdim, ama daha yeni başladım, bu yüzden gereken itibarı bulamadım. Bu gece PYTH kullanmaya başladım ve bir listeyi verimli bir şekilde kodlama yöntemini utanmadan uyarladığımı itiraf ettim.

Bu uygunsuzsa, en derin özür dilerim, ve girişimi kaldıracağım.

MIPS, 16 bayt

Bit kaydırma ve bit maskesi. Giriş girişi $a0, çıkış girişi $v0.

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

Bonus için hemen kullanın 0xdc87420

F #, 28 + 28 bayt

Bunu arama masası olmadan denemek istedim.

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, her biri 34 bayt

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/2LED'ler içindir, b/2düğmeler içindir.

Bonus, 66 bayt

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 LED'ler için, Düğmeler için başka herhangi bir şey.

q / k (her biri 18 bayt)

Sadece bir indeksleme durumu:

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

Örnek:

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

Bonus (1 bayt, L & B tanımlı)

@

Örnek:

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

CJam, her biri 10 bayt

Bunlar isimsiz fonksiyonlardır. Çevrimiçi tercümana olan bağlantılar, tüm giriş değerleri için işlevi yerine getiren küçük bir test kablo demeti içinde gösterilir.

İşlev 1 (LED):

{5*3|4+3/}

Çevrimiçi deneyin

İşlev 2 (düğmeler):

{_6|5+*5/}

Çevrimiçi deneyin

Bu ifadeleri üreten ve değerlendiren küçük bir program yazdım. Her ikisi için de 8 karakterli bir dizi çözüm buldu (ifadeyi yalnızca parantezsiz olarak sayarak), ancak hiçbiri daha az olmadı.

Javascript (ES6), 26/27 bayt

LED'ler:

a=>`0   
`.charCodeAt(a)

Düğmeler:

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

Yukarıdakiler çalışmazsa (muhtemel), işte bir 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)|

İkinciyi çiğ bir CR ile çalışamadım, bu yüzden kullanmak zorunda kaldım. \r

Bonus, 41 bayt

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

İkinci parametre, LED'ler için 0, düğmeler için 1'dir.

Brainf ** k, 107 bayt

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

Bu, ilk el kodlu BF programım olduğundan, yapılacak birkaç optimizasyon olduğundan şüphem yok. Ama yine de harika. :)

[]Şartlı olarak sayılır mı bilmiyorum ama ...: /

POWERSHELL - 27-27-72

LED kullanımı 1.6

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

düğme kullanımı olarak 1..6

:\>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 veya BUTTON b1 kullanır; 12; b 6; L 5 vs 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

Oktav, 40 bayt (bonus mücadelesi)

Büyük bir işlev kullanma:

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

Bu fonksiyonu tanımladıktan sonra, bu işlev çağrısı ans(x,y), xpim / düğme sayısıdır ve ydeğerleri ile pim ya da renkli gösterir 1ve 2sırasıyla.

Çevrimiçi deneyin

JavaScript 113 74 66 59 52 33 (bir işlev)

4 bitlik değerleri almak için bit kaydırma kullanın. P (n, 195650864 veya 231240736) ile çağrılmalıdır.

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

Alternatif.

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

Perl 4 (37 ve 31 bayt)

LED'ler (37 bayt):

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

... ama bir arama tablosu kullanıyor.

Düğmeler (31 bayt, arama yok):

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

JavaScript (ES6) 18,22,44

Düzenleme Shorter ama sıkıcı

// 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, Her Birinde 31 Bayt

Tam olarak yaratıcı değil ya da bir şey, ama işe yarıyor!

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

Bonus, 44 Bayt

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

y LED'ler için 0, düğmeler için 1 olmalıdır.

Python, 60 + 58 = 118 bayt

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)

Bunlar berbat. Burada ne yaptığımı bile bilmiyorum ...

Ama yine de oldukça ilginçler! : D

Ruby, 45 Bayt

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

Test Girişleri:

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

Dördüncü, her biri 26 bayt, bonus için 34

Squeamish tarafından C sürümüne benzer.

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

Bonus:

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

LED'ler için 0, düğmeler için 6 kullanın. Ve parametre sırası önemli değil

Pyth, her biri 19 bayt

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

Pimler ve düğmeler için sırasıyla.