Thử thách này được lấy cảm hứng từ việc lập trình một vi điều khiển Arduino. Tôi có 6 đèn LED và 6 nút được kết nối với các chân khác nhau trên bảng. Trong mã, mỗi nút và đèn LED được gán một số ID (1-6). Số pin (từ 0-13) tương ứng với số ID được tra cứu bằng cách sử dụng switchcâu lệnh. Hoàn toàn để giải trí, tôi đã tự hỏi liệu những switches này có thể bị phá vỡ bằng một hàm số học / chức năng khác chỉ để làm cho những người duy trì mã trong tương lai kinh hoàng.

Các thách thức

Cung cấp hàm / hàm lấy số ID (số nguyên) làm tham số và trả về số pin (số nguyên) cho 6 đèn LED và / hoặc 6 nút, mà không sử dụng các câu lệnh có điều kiện (không if, không switchvà không có ternary).

Trả về giá trị cho đèn LED:

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

Trả về giá trị cho các nút:

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

Phần thưởng thử thách

Cung cấp một hàm duy nhất lấy số ID (số nguyên) và tham số thứ hai (bất kỳ loại nào) cho biết liệu đèn LED hoặc chân nút có được yêu cầu hay không và trả về chân (số nguyên) tương ứng.

Quy tắc

Đây không phải là một thách thức dành riêng cho Arduino. Sử dụng bất kỳ ngôn ngữ , làm bất cứ điều gì bạn muốn.

Chỉnh sửa: theo gợi ý của steveverril , đây hiện là một thử thách golf mã .

Chúc may mắn!

(Nếu bạn vẫn đang đọc: mặc dù vô lý và tùy tiện theo tiêu chuẩn lập trình, các ánh xạ được dựa trên sơ đồ chân của Arduino Micro. , các nút được gán cho các chân còn lại)

C, 28 byte mỗi

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

Điều này về cơ bản giống như câu trả lời của kirbyfan64sos, nhưng sử dụng một mảng char thay vì số nguyên và có một byte đầu tiên giả nên không cần phải trừ 1 từ tham số hàm.

Haskell, mỗi 24 byte

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

để kiểm tra:

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

.

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

để kiểm tra:

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

tiền thưởng, Haskell, 36 byte

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

để kiểm tra:

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

0 cho các nút, 1 cho đèn LED.

C (toán), 32 / 27 26 byte (45 cho thử thách tiền thưởng)

Một số người đã đăng các giải pháp tra cứu bảng khác nhau, nhưng dường như tôi muốn tìm ra cách dễ dàng .. Tôi muốn xem tôi có thể làm tốt như thế nào với các hoạt động toán học thuần túy:

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

Không rõ liệu một chức năng gọi hàm kia có được chấp nhận hay không; nếu không, người ta có thể sử dụng định nghĩa thay thế này của b(i)(33 byte) thay thế:

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

Phần thưởng Thử thách (45 byte):

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

(vượt qua t=0các nút, t=1cho đèn LED)

C, 36 byte mỗi (49 byte cho thử thách tiền thưởng)

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

Tôi xin lỗi ... Tôi không thể giúp nó ... Ok, tôi đặt một giải pháp thực sự ngay bây giờ.

Phần thưởng thử thách, 49 byte

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

Sử dụng f(button,0)và f(pin,1).

Bản demo trực tiếp tại Ideone.

Bản gốc:

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 mỗi

Cơ sở mã hóa mảng.

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

Cái cuối cùng thực sự là mười hai byte trừ khi tôi không thể viết trở lại xe ngựa để tôi thoát khỏi nó.

Bộ kiểm tra cho các nút .

Bộ thử nghiệm cho LEDS .

Pyth, Chỉ thưởng: 20 byte

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

param # 2 là 0 cho đèn LED, 1 cho Nút. Để lấy Pin # cho LED4,g4 0

Tôi đã đăng bài này như một bình luận cho mục nhập của Maltysen, nhưng tôi mới bắt đầu, vì vậy thiếu danh tiếng cần thiết. Tôi mới bắt đầu sử dụng PYTH tối nay và thừa nhận rằng tôi đã điều chỉnh một cách hiệu quả phương pháp mã hóa danh sách của anh ấy.

Nếu điều này không phù hợp, lời xin lỗi sâu sắc nhất của tôi và tôi sẽ xóa mục nhập của tôi.

MIPS, 16 byte

Bit dịch chuyển và bitmask. Đầu vào $a0, đầu ra trong $v0.

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

Để nhận thưởng, hãy sử dụng ngay 0xdc87420

F #, 28 + 28 byte

Tôi muốn thử cái này mà không cần bảng tra cứu.

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 mỗi

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 dành cho đèn LED, b/2 là cho các nút.

Tiền thưởng, 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 cho đèn LED, bất cứ điều gì khác cho các nút.

q / k (mỗi 18 byte)

Đơn giản chỉ là một trường hợp lập chỉ mục:

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

Thí dụ:

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

Phần thưởng (1 byte, được xác định L & B)

@

Thí dụ:

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

CJam, mỗi byte 10

Đây là những chức năng ẩn danh. Các liên kết đến trình thông dịch trực tuyến hiển thị sau đó trong một khai thác thử nghiệm nhỏ thực thi chức năng cho tất cả các giá trị đầu vào.

Chức năng 1 (đèn LED):

{5*3|4+3/}

Dùng thử trực tuyến

Chức năng 2 (nút):

{_6|5+*5/}

Dùng thử trực tuyến

Tôi đã viết một chương trình nhỏ tạo và đánh giá các biểu thức này. Đối với cả hai, họ đã tìm thấy một số giải pháp với 8 ký tự (chỉ đếm biểu thức mà không có dấu ngoặc nhọn), nhưng không có giải pháp nào với ít hơn.

Javascript (ES6), 26/27 byte

Đèn LED:

a=>`0   
`.charCodeAt(a)

Nút:

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

Nếu ở trên không chạy (có khả năng), đây là một 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)|

Tôi không thể có cái thứ hai để làm việc với CR thô nên tôi phải sử dụng \r

Tiền thưởng, 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)|

Tham số thứ hai là 0 cho đèn LED và 1 cho nút.

Brainf ** k, 107 byte

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

Đây là chương trình BF được mã hóa đầu tiên của tôi, tôi không nghi ngờ rằng có một số tối ưu hóa được thực hiện. Nhưng nó vẫn tuyệt vời. :)

Tôi không chắc nếu []được tính là có điều kiện, mặc dù ...: /

POWERSHELL - 27-27-72

LED sử dụng 1..6 như 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

nút sử dụng 1..6 như 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 hoặc NÚT sử dụng b 1; l 2; b 6; l 5 vv như 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 byte (thử thách tiền thưởng)

Sử dụng hàm anonuymous:

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

Sau khi xác định chức năng này, hãy gọi chức năng này là ans(x,y), xsố pin / nút ở đâu và ycho biết pin hoặc nút có giá trị 1và 2tương ứng.

Dùng thử trực tuyến

JavaScript 113 74 66 59 52 33 (một chức năng)

Sử dụng dịch chuyển bit để có được giá trị 4 bit. Phải được gọi bằng p (n, 195650864 hoặc 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}

Luân phiên.

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

Perl 4 (37 và 31 byte)

Đèn LED (37 byte):

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

... nhưng nó sử dụng bảng tra cứu.

Các nút (31 byte, không tra cứu):

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

JavaScript (ES6) 18,22,44

Chỉnh sửa ngắn hơn nhưng nhàm chán

// 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 mỗi

Không chính xác sáng tạo hay bất cứ điều gì, nhưng nó hoạt động!

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

Tiền thưởng, 44 byte

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

y nên là 0 cho đèn LED và 1 cho nút.

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)

Đây là những khủng khiếp. tôi thậm chí không biết mình đang làm gì ở đây ...

Nhưng dù sao chúng cũng khá thú vị! : D

Ruby, 45 byte

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

Đầu vào kiểm tra:

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

Forth, 26 byte mỗi, 34 cho tiền thưởng

Tương tự như phiên bản C bởi squeamish.

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

Tiền thưởng:

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

Sử dụng 0 cho đèn LED và 6 cho nút. Và thứ tự tham số không quan trọng

Pyth, 19 byte mỗi

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

Đối với chân và nút tương ứng.