Эта проблема была вдохновлена ​​программированием микроконтроллера Arduino. У меня есть 6 светодиодов и 6 кнопок, подключенных к различным контактам на плате. В коде каждой кнопке и индикатору присваивается идентификационный номер (1-6). Номера выводов (в диапазоне 0-13), соответствующие номерам ID, ищутся с помощью switchоператора. Чисто для развлечения, мне было интересно, switchможно ли их обойти с помощью арифметической / другой функции просто для того, чтобы ужаснуть будущих разработчиков кода.

Соревнование

Укажите функцию / функции, которые принимают идентификационный номер (целое число) в качестве параметра и возвращают номер контакта (целое число) для 6 светодиодов и / или 6 кнопок без использования условных операторов (нет if, нет switchи нет троичного).

Возвращаемые значения для светодиодов:

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

Возвращаемые значения для кнопок:

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

Бонус вызов

Обеспечьте единственную функцию, которая принимает идентификационный номер (целое число) и второй параметр (любой тип), указывающий, запрашиваются ли контакты светодиодов или кнопок, и возвращает соответствующий вывод (целое число).

правила

Это не специфичная для Arduino проблема. Используйте любой язык , делайте что хотите.

Изменить: по предложению steveverril , это теперь вызов кода гольф .

Удачи!

(Если вы все еще читаете: хотя это явно абсурдно и произвольно по стандартам программирования, сопоставления основаны на распиновке Arduino Micro. Выводы 0 и 1 зарезервированы для последовательной связи, светодиоды назначены на 6 выводов с наименьшим номером, способных к ШИМ. кнопки назначены оставшимся контактам)

C, 28 байтов каждый

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

Это в основном то же самое, что и ответ kirbyfan64sos, но использует массив символов вместо целых и имеет фиктивный первый байт, поэтому нет необходимости вычитать 1 из параметра функции.

Haskell, 24 байта каждый

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

Проверять:

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

,

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

Проверять:

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

бонус, Haskell, 36 байт

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

Проверять:

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

0 для кнопок, 1 для светодиодов.

С (математика), 32 / 27 26 байт (45 для бонусного вызова)

Несколько человек опубликовали различные решения для поиска в таблицах, но мне показалось, что я выбрал легкий путь ... Я хотел посмотреть, насколько хорошо я могу справиться с чисто математическими операциями:

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

Было неясно, была ли одна функция, вызывающая другую, приемлемой или нет; в противном случае b(i)вместо этого можно использовать это альтернативное определение (33 байта):

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

Bonus Challenge (45 байт):

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

(пропуск t=0для кнопок, t=1для светодиодов)

C, 36 байтов каждый (49 байтов для бонусного вызова)

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

Извините ... Я просто не мог с этим поделать ... Хорошо, сейчас я нашел реальное решение.

Бонусный вызов, 49 байт

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

Используйте f(button,0)и f(pin,1).

Живая демоверсия в Ideone.

Оригиналы:

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 байтов каждый

База кодирует массив.

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

Последний на самом деле составляет двенадцать байтов, за исключением того, что я не могу написать возврат каретки, поэтому я избежал его.

Тестовый набор для кнопок .

Тестовый пакет для светодиодов .

Пит, Бонус только: 20 байт

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

параметр # 2 равен 0 для светодиодов, 1 для кнопок. Чтобы получить пин-код для LED4,g4 0

Я бы опубликовал это как комментарий к записи Maltysen, но я только начал, поэтому мне не хватает необходимой репутации. Я только сегодня начал использовать PYTH и признаю, что бесстыдно адаптировал его метод эффективного кодирования списка.

Если это неуместно, приношу свои глубочайшие извинения, и я удалю свою запись.

MIPS, 16 байтов

Сдвиг и битовая маска. Вход в $a0, выход в$v0 .

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

Для бонуса используйте немедленный 0xdc87420

F #, 28 + 28 байт

Я хотел попробовать это без справочной таблицы.

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-Пролог, 34 байта каждый

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 для светодиодов, b/2 для кнопок.

Бонус, 66 байт

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 для светодиодов, все остальное для кнопок.

q / k (18 байт каждый)

Просто случай индексации:

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

Пример:

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

Бонус (1 байт, с учетом L & B)

@

Пример:

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

CJam, 10 байтов каждый

Это анонимные функции. Затем ссылки на онлайн-интерпретатор отображаются в небольшом тестовом жгуте, который выполняет функцию для всех входных значений.

Функция 1 (светодиоды):

{5*3|4+3/}

Попробуйте онлайн

Функция 2 (кнопки):

{_6|5+*5/}

Попробуйте онлайн

Я написал небольшую программу, которая генерирует и оценивает эти выражения. Для них обоих было найдено несколько решений с 8 символами (считая выражение только без фигурных скобок), но ни одно с меньшим.

Javascript (ES6), 26/27 байт

светодиоды:

a=>`0   
`.charCodeAt(a)

Кнопки:

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

Если вышеупомянутое не работает (что вероятно), вот 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)|

Я не мог заставить второй работать с сырым CR, поэтому мне пришлось использовать \r

Бонус, 41 байт

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

Второй параметр - 0 для светодиодов и 1 для кнопок.

Brainf ** k, 107 байт

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

Это моя первая написанная вручную программа BF, я не сомневаюсь, что есть несколько вариантов оптимизации. Но это все еще круто. :)

Я не уверен, если []считается условным, хотя ...: /

POWERSHELL - 27-27-72

LED используют 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

Кнопка использовать 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 или КНОПКА используют b 1; l 2; б 6; л 5 и т. д. как аргументы

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

Октава, 40 байт (бонусный вызов)

Используя анонимную функцию:

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

После определения этой функции, вызовите эту функцию как ans(x,y), где номер xштыря / кнопки и yуказывает штырь или кнопку со значениями 1и 2соответственно.

Попробуйте онлайн

JavaScript 113 74 66 59 52 33 (одна функция)

Использование битового сдвига для получения 4-битных значений. Должен быть вызван с p (n, 195650864 или 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}

Alternate.

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

Perl 4 (37 и 31 байт)

Светодиоды (37 байт):

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

... но он использует таблицу поиска.

Кнопки (31 байт, без поиска):

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

JavaScript (ES6) 18,22,44

Редактировать Короче но скучно

// 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 байт каждый

Не совсем творческий или что-то, но это работает!

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

Бонус, 44 байта

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

y должно быть 0 для светодиодов и 1 для кнопок.

Python, 60 + 58 = 118 байт

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)

Это ужасно я даже не знаю, что я здесь делаю ...

Но они довольно интересные, тем не менее! : D

Рубин, 45 байт

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

Тестовые входы:

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

Далее 26 байтов каждый, 34 для бонуса

Похоже на версию C от squeamish.

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

Бонус:

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

Используйте 0 для светодиодов и 6 для кнопок. И порядок параметров не имеет значения

Pyth, 19 байтов каждый

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

Для пинов и кнопок соответственно.