DVI разъемы

23

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

Существует три основных типа разъемов DVI : DVI-A (аналоговый), DVI-D (цифровой) и DVI-I (встроенный). Кроме того, существуют одноканальные и двухканальные версии разъемов DVI-D и DVI-I. Каждый из этих пяти различных разъемов использует свой набор контактов.

Учитывая один из A, D1, D2, I1, в I2качестве идентификатора типа разъема, распечатайте соответствующий ASCII представление его контактов:

A:
#   #  # # #       # #
=====  # # #          
#   #  # #         # #

D1:
       # # #     # # #
=====  # # #     # # #
       # # #     # # #

D2:
       # # # # # # # #
=====  # # # # # # # #
       # # # # # # # #

I1:
#   #  # # #     # # #
=====  # # #     # # #
#   #  # # #     # # #

I2:
#   #  # # # # # # # #
=====  # # # # # # # #
#   #  # # # # # # # #

( X:Строки не являются частью вывода, вы должны напечатать только 3 строки.)

Вы можете написать программу или функцию, используя ввод через STDIN, ARGV или аргумент функции. Выходные данные должны быть распечатаны в STDOUT с дополнительным переводом строки в конце.

Вы можете включать или не включать конечные пробелы во второй строке Aсоединителя. Вы не должны использовать дополнительное ведение или конечные пробелы где-либо еще.

Это код гольф, поэтому самый короткий ответ (в байтах) выигрывает.

code-golf  ascii-art  kolmogorov-complexity 
— Мартин Эндер
источник
Могу ли я потребовать, чтобы ввод был "I1"заключен в кавычки, например вместо I1?
— Клавдиу
Разрешены ли пробелы в других строках?
— ушел
1
@Claudiu Нет, прости.
— Мартин Эндер
@gone_native Также нет, извините (добавлю это в пост).
— Мартин Эндер

Ответы:

3

CJam, 79 70 байт

Вдохновленный ответом Нутки . Это также гарантирует, что нет пробелов (за исключением второй строки)

"VF­wGC}*D"176b6b" DG1A="f=r'1+2<"  "aer{_s" ="&\"# "?}%s23/Wf<N*

Используйте эту ссылку чтобы скопировать код, поскольку SE удаляет непечатные символы.

Есть 5 символов в непечатаемом диапазоне ASCII, но в пределах байта (код ASCII 255)

Как это работает :

"VF­wGC}*D"176b6b" DG1A="f=              "This effectively results into this string:"
                                        "D  D GGG11AGG=====  GGG11AAAD  D GGA11AGG";
r'1+2<                                  "Read the input, convert A to A1";
      "  "er                            "Replace the occurrences of above two characters"
                                        "with double space '  '";
            {_s" ="&\"# "?}%s           "Convert every non = and space character to '# '";
                             23/        "Divide the string into parts of 23 characters";
                                Wf<     "String last character from above parts";
                                   N*   "Join with new line";

Попробуйте это онлайн здесь

— оптимизатор
источник
16

Perl - 100 91 (включая 1 флаг)

Использует идеи Nutki об использовании -pи сокращении двойных пробелов. Также упрощено устранение замыкающих пробелов.

#!perl -p
$x=$_|" qb";$_="dbd xxxqqqax#
=====bxxxqqqaaa!dbd xxaqqqax#";s/[$x]/  /g;s/\w/# /g;s/ !/
/

Входные данные поступают из стандартного ввода и должны содержать только тип соединителя без завершающей строки.

Предыдущая:

$x=shift|" q";$_="d  d xxxqqqaxx
=====  xxxqqqaaa
d  d xxaqqqaxx";s/[$x]/  /g;s/\w/# /g;s/ $//mg;say

Принимает аргумент командной строки. Ungolfed:

# Read argument, transform A->aq, I1->iq, I2->is, D1->dq, D2->ds
$x=shift|" q";

# String compacted
$_ = "d  d xxxqqqaxx
=====  xxxqqqaaa
d  d xxaqqqaxx";

# Clear any pins with matching char in input
s/[$x]/  /g;
# Convert rest to '#'
s/\w/# /g;
# Eliminate trailing spaces
s/ $//mg;
say
— gone_native
источник
2
Гениальная идея для обработки параметра. Вы все еще можете сохранить 2 байта, добавив $x=shift|" qb"и заменив 3 вхождения двойного пробела bна в шаблоне. Кроме того, изменение обработки ввода на «-p» дает 7 дополнительных (без флага): $x=$_|""и нет необходимости в финале say.
— Nutki
@nutki - Спасибо, я пропустил это!
— ушел
@ MartinBüttner - Все 3 строки имеют завершающие пробелы, хотя я понял, что могу легко исправить первую и третью строки, преобразовав последний символ в этих строках из xв #. Но во второй строке все еще есть пробелы во всех случаях. Ибо Aпространство выходит за пределы финала #других строк (что, я полагаю, технически разрешено). Но для I1, I2и т. Д. В некоторых случаях по-прежнему есть место, за которым нужно позаботиться. Я думаю, что смогу сыграть еще пару персонажей.
— ушел
@ gone_native о, ты прав.
— Мартин Эндер
9

Python, 168 символов

t=raw_input()*2
Q="G   G  # # # 2 2 H # #\n=====  # # # 2 2 H H H\nG   G  # # H 2 2 H # #"
for A,B,N in('G0A','H0D','212'):Q=Q.replace(A,' #'[t[int(B)]in'I'+N])
print Q

Похоже, новый подход. У меня есть строка:

G   G  # # # 2 2 H # #
=====  # # # 2 2 H H H
G   G  # # H 2 2 H # #

Я заменить G, Hи 2на основе входных данных.

— Клаудиу
источник
5

J 153 121 119 символов

Минимизированный 
('='(;/1,.i.5)}"_1' #'{~5 3 22$#:128#.32x-~3 u:'dt*`J%Q5"xjuH%Jv2uJ!H5 t*`J%@5Jp*uH%Jv2p*!H dp"')echo@{~I1`I2`D1`D2 i.<

Третий подход: упаковать все   и #в огромное целое в виде битов. Добавьте =потом. Тем не менее, по-прежнему не используется симметрия многих вариантов разъема.

Unminified 
n =. 128 #. 32x -~ 3 u: 'dt*`J%Q5"xjuH%Jv2uJ!H5 t*`J%@5Jp*uH%Jv2p*!H dp"'
f =. ('=' (;/1,.i.5)}"_1 ' #' {~ 5 3 22 $ #: n) echo@{~ I1`I2`D1`D2 i. <
Минимизированный (153) 
[:echo@>({&(' #=',LF)&.:>;._2#;._1#:96#.32x-~3 u:' (0%dziqrDwbh5Ds6[gEl)_xkBS6?61m$1ne/v(]!&yW?_{K.S^X#Yn_d%O71KqXEw=I;meH>@eG2|2/gcR0'){~D1`D2`I1`I2 i.<

Также как функция. Этот использует двоичное кодирование переменной длины, подсчитывая их в двоичном коде и разделяя нулями. 0 один ряд означает  , 1 один означает #, 2 один означает= , 3 один означает новую и 4 один отделяют пять строк друг от друга.

Ungolfed 
s =. ' (0%dziqrDwbh5Ds6[gEl)_xkBS6?61m$1ne/v(]!&yW?_{K.S^X#Yn_d%O71KqXEw=I;meH>@eG2|2/gcR0'
f =. [: echo@> ({&(' #=',LF)&.:>;._2 #;._1 #: 96 #. 32x -~ 3 u:s) {~ D1`D2`I1`I2 i. <
— Светляк
источник
4

Marbelous, 281 байт / символы

уменьшенная:

00
]]
GG]]
IIJJJJ
:G
}0
++
>>
>X{0
/\{<{>
:H
}0
-Z
>E-2
-C//
{0
:I
23232003002023}023
LLMMMMNNRROOMMRRLL
0003
0300
NNNN
:J
}0}1
HH-2
KKKK
:K
}1}0
}1}0}0
PPPPQQ
:L
}020
}0202020
:M
20}020}020}0
:N
}0
}020
+W20
:O
3D3D3D3D3D}0
:P
}023}1230A
LLMMNNMM
:Q
2023}0230A
OOMMNNMM
:R
}0
\/0A

Это происходит D1, D2, I1, I2илиA из STDIN. Завершать переводы строк во входных данных необязательно. Выход на STDOUT.

Эта программа вызывает подпункты, которые печатают части соединителей, либо заполняя # s, либо оставляя пробелы в зависимости от входных данных.

Попробуйте этот ответ здесь ; нужны цилиндрические доски.

с комментариями:

00 .. ..
]] .. .. # get A/D/I
Gt ]] .. # pass into Gt; call PA if A or PrDI if D/I
PA Pr DI

# If 'A' is passed, a marble is emitted down
# Otherwise, marbles are sent left/right
# The value of the marble outputted is (I+1)/2, which creates a difference of 3
#   between D and I, the difference between a space and a #
:Gt
}0 .. ..
++ .. ..
>> .. ..
>X {0 ..
/\ {< {>

# Returns 0 if '1' is passed, and 3 if '2' is passed
:Ff
}0 ..
-Z ..
>E -2
-C //
{0 ..

# Prints connector A 
# Calls made: P1(23) P2(23) P2(20) P3(03) LF(00) P4(20) P2(23) LF(}0) P1(23)
#   P3(03) P3(00) P3(00) P3(03)
:PA
23 23 20 03 00 20 23 }0 23
P1 P2 P2 P3 LF P4 P2 LF P1
00 03 .. .. .. .. .. .. ..
03 00 .. .. .. .. .. .. ..
P3 P3 .. .. .. .. .. .. ..

# Prints connectors D0/D1/I0/I1
# }0 is either '1' or '2'
# }1 is either 32 or 35 (for D or I)
:PrDI
}0 }1
Ff -2
Li DI

# Helper for PrDI
# Calls made: L1(}1, }0) L2(}0) L1(}1, }0)
:LiDI
}1 }0 ..
}1 }0 }0
L1 L1 L2

# Prints '#   # ' (}0 = 0x23) or '      ' (}0 = 0x20)
:P1
}0 20 .. ..
}0 20 20 20

# Prints ' # # #' (}0 = 0x23) or '      ' (}0 = 0x20)
:P2
20 }0 20 }0 20 }0

# Prints ' # #' (}0 = 0x03) or '    ' (}0 = 0x00)
:P3
}0 ..
}0 20
+W 20

# Prints '===== ', }0 must be 0x20
:P4
3D 3D 3D 3D 3D }0

# Prints the top/bottom line of D/I connectors + newline
# Calls made: P1(}0) P2(23) P3(}1) P2(23) 
:L1
}0 23 }1 23 0A
P1 P2 P3 P2 ..

# Prints the middle line of D/I connectors + newline
# Calls made: P4(20) P2(23) P3(}0) P2(23)
:L2
20 23 }0 23 0A
P4 P2 P3 P2 ..

# Emits a newline (0x0A) regardless of input
:LF
}0 ..
\/ 0A
— es1024
источник
4

Perl 5: 105 (включая 1 флаг)

Еще одно решение Perl. Использует стандартный ввод для параметра.

#!perl -p
@x=map$_?'#':$",!/D/,-/2/,!/A/,1,0;$_='040 33311233
=====433311222
040 33211233';s/\d/$x[$&] /g;s/ $//mg
— nutki
источник
4

GNU sed, 116 байт

s/.*/&:#   #  33322433\n=====  33322444\n#   #  33422433/
/A/s/[42]/  /g
/1/s/2/  /g
/D/s/#/ /g
s/[2-4]/ #/g
s/.*://

Выход:

$ echo "A
D1
D2
I1
I2"|sed -f dvi.sed
#   #   # # #       # #
=====   # # #          
#   #   # #         # #
        # # #     # # #
=====   # # #     # # #
        # # #     # # #
        # # # # # # # #
=====   # # # # # # # #
        # # # # # # # #
#   #   # # #     # # #
=====   # # #     # # #
#   #   # # #     # # #
#   #   # # # # # # # #
=====   # # # # # # # #
#   #   # # # # # # # #
$
— Цифровая травма
источник
3

J, 198 194 157 символов

Минимизированный 
3 22 echo@$'x   x  # # # x x x # #=====  # # # x x x x xx   x  # # x x x x # #'('x'I.@:=])}~(5 16$(#' #'$~#)"."0'4123212128262126290901824'){~D1`D2`I1`I2 i.<

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

Ungolfed 
S1 =. (#' #'$~#)"."0'4123212128262126290901824'
S2 =. 'x   x  # # # x x x # #=====  # # # x x x x xx   x  # # x x x x # #'
f  =. 3 22 echo@$ S2 ('x'I.@:=])}~ (5 16$S1) {~ D1`D2`I1`I2 i. <

Идея состоит в том, чтобы хранить общую часть строки отдельно от символов, которые отличаются между типами соединителей. S1хранит уникальные символы и S2действует как шаблон с xзаполнителями в качестве заполнителей.

— Светляк
источник
3

Питон - 167 166 164 161 159

C=raw_input()
a=["#   # "," "*6]["D"in C]
r=" #"
b="A"in C
i=3-b
d=(r*[i,5][C[1:]>"1"]).rjust(10)
t=r*3
print a+t+d+"\n===== "+t+d*~-len(C)+"\n"+a+r*i+"  "*b+d
— Фалько
источник
3

JavaScript (ES6) 178 186

Править Имея 7 базовых блоков, используйте базовый 7
прямой путь, используя строение строк с заменой и 7 строительных блоков.
Вывод на стандартный вывод с использованием оповещения в соответствии с запросом OP.
Сейчас попробую несколько микрооптимизаций ...

F=t=>alert(
  {A:21349062249,D1:538695058296,D2:534740169498,I1:151139015296,I2:147184126498}[t]
  .toString(7).replace(/./g,c=>'\n0#   # 0===== 0 # # #0 # #0      0    '.split(0)[c])
)

Тестирование в консоли FireFox / FireBug - удаление предупреждения для упрощения теста

;['A','D1','D2','I1','I2'].forEach(i=>console.log(F(i)))

Выход

#   #  # # #       # #
=====  # # #
#   #  # #         # #

       # # #     # # #
=====  # # #     # # #
       # # #     # # #

       # # # # # # # #
=====  # # # # # # # #
       # # # # # # # #

#   #  # # #     # # #
=====  # # #     # # #
#   #  # # #     # # #

#   #  # # # # # # # #
=====  # # # # # # # #
#   #  # # # # # # # #
— edc65
источник
2

APL (115)

V←3 22⍴''⋄V[2;⍳5]←'='⋄V[⍳3;(2=⍴I)/(6+2×⍳8)~14 16/⍨'1'∊I]←V[⍳2;12]←V[⍳3;8 10]←V[R/1 3;1 5 20 22/⍨R←∨/'AI'∊I←⍞]←'#'⋄V

Тест:

      V←3 22⍴''⋄V[2;⍳5]←'='⋄V[⍳3;(2=⍴I)/(6+2×⍳8)~14 16/⍨'1'∊I]←V[⍳2;12]←V[⍳3;8 10]←V[R/1 3;1 5 20 22/⍨R←∨/'AI'∊I←⍞]←'#'⋄V
A
#   #  # # #       # #
=====  # # #          
#   #  # #         # #
      V←3 22⍴''⋄V[2;⍳5]←'='⋄V[⍳3;(2=⍴I)/(6+2×⍳8)~14 16/⍨'1'∊I]←V[⍳2;12]←V[⍳3;8 10]←V[R/1 3;1 5 20 22/⍨R←∨/'AI'∊I←⍞]←'#'⋄V
D1
       # # #     # # #
=====  # # #     # # #
       # # #     # # #
      V←3 22⍴''⋄V[2;⍳5]←'='⋄V[⍳3;(2=⍴I)/(6+2×⍳8)~14 16/⍨'1'∊I]←V[⍳2;12]←V[⍳3;8 10]←V[R/1 3;1 5 20 22/⍨R←∨/'AI'∊I←⍞]←'#'⋄V
D2
       # # # # # # # #
=====  # # # # # # # #
       # # # # # # # #
      V←3 22⍴''⋄V[2;⍳5]←'='⋄V[⍳3;(2=⍴I)/(6+2×⍳8)~14 16/⍨'1'∊I]←V[⍳2;12]←V[⍳3;8 10]←V[R/1 3;1 5 20 22/⍨R←∨/'AI'∊I←⍞]←'#'⋄V
I1
#   #  # # #     # # #
=====  # # #     # # #
#   #  # # #     # # #
      V←3 22⍴''⋄V[2;⍳5]←'='⋄V[⍳3;(2=⍴I)/(6+2×⍳8)~14 16/⍨'1'∊I]←V[⍳2;12]←V[⍳3;8 10]←V[R/1 3;1 5 20 22/⍨R←∨/'AI'∊I←⍞]←'#'⋄V
I2
#   #  # # # # # # # #
=====  # # # # # # # #
#   #  # # # # # # # #
— Мэринус
источник
@ MartinBüttner: упс, исправлено
— marinus
2

JavScript ES6, 186 байт

f=c=>(b=(c[0]=='D'?'      ':'#   # '))+(e=(g=r=>parseInt(r,36).toString(2).replace(/./g,n=>' '+[' ','#'][n]))((o=c[1])?(o-1?73:'6f'):'6b'))+'\n===== '+(o?e:' # # #')+'\n'+b+(o?e:g('5f'))

Показать фрагмент кода

Код быстрый и грязный, но он выполняет свою работу. В основном, числа #и пробелы помещаются в двоичный код, а затем в базу 36. Я ищу более элегантное и, надеюсь, более короткое решение.

— NinjaBearMonkey
источник
Когда я нажимаю Запустить фрагмент кода, я ничего не вижу.
— AL
Это, вероятно, потому что он использует функции стрелок ECMAScript 6, которые поддерживаются только в последних версиях Firefox.
— NinjaBearMonkey
Я тестировал с последней версией Firefox и ничего не происходит. Что-то нужно сделать, чтобы проверить эту функцию?
— AL
1
О, это потому что это только функция. Я добавлю способ проверить это.
— NinjaBearMonkey
Вы можете отредактировать код, чтобы сделать его работоспособным как фрагмент (используйте второй блок кода, чтобы сохранить исходный код) или удалить средство визуализации фрагмента.
— AL
1

Perl 5 - 150 (149 + 1 для n )

Golfed:

@b=split//;$_='0   0 ###112##
===== ###11222
0   0 ##2112##';
@c=(@b[0]eq D,@b[1]ne 2,@b[0]eq A);@d=('#',$");s/([#12])/ \1/g;s/(\d)/$d[$c[$1]]/ge;say

Ввод из STDIN, вывод в STDOUT. Работает, заполняя определенные символы с# или зависимости от ввода.

Ungolfed:

@b=split//; # char array from input
$_='0   0 ###112##
===== ###11222
0   0 ##2112##';

@c=(@b[0] eq 'D',@b[1] ne '2',@b[0] eq 'A');
@d=('#',' ');

s/([#12])/ \1/g; # add spaces
s/(\d)/$d[$c[$1]]/ge; # replace numbers with appropriate character
say $_;
— es1024
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.