Đây được coi là một thử thách golf mã ở đầu đơn giản hơn của quang phổ. Nhưng tôi cho rằng nó có thể tốt để đưa ra một số tối ưu hóa vi mô ở đây.

Có ba loại đầu nối DVI cơ bản : DVI-A (analog), DVI-D (kỹ thuật số) và DVI-I (tích hợp). Hơn nữa, có các phiên bản liên kết đơn và liên kết kép của các đầu nối DVI-D và DVI-I. Mỗi trong số năm đầu nối khác nhau sử dụng một bộ chân khác nhau.

Với một trong những A, D1, D2, I1, I2như một định danh cho các loại đầu nối, in ASCII đại diện tương ứng của chân của connector:

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

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

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

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

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

(Các X:dòng không phải là một phần của đầu ra, bạn chỉ nên in 3 dòng.)

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào thông qua STDIN, ARGV hoặc đối số hàm. Đầu ra phải được in thành STDOUT, với nguồn cấp dữ liệu theo dõi tùy chọn.

Bạn có thể hoặc không bao gồm các dấu cách trong dòng thứ hai của trình Akết nối. Bạn không được sử dụng thêm không gian hàng đầu hoặc dấu ở bất kỳ nơi nào khác.

Đây là mã golf, vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

CJam, 79 70 byte

Lấy cảm hứng từ câu trả lời của nutki . Điều này cũng đảm bảo rằng không có khoảng trắng ở cuối (ngoại trừ dòng thứ hai)

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

Sử dụng liên kết này để sao chép mã dưới dạng các dải ký tự SE không in được.

Có 5 ký tự trong phạm vi ASCII không in được nhưng cũng nằm trong một byte (mã ASCII 255)

Cách thức hoạt động :

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

Dùng thử trực tuyến tại đây

Perl - 100 91 (bao gồm 1 cờ)

Sử dụng ý tưởng của nutki về việc sử dụng -pvà giảm không gian đôi. Cũng đơn giản hóa loại bỏ không gian dấu.

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

Đầu vào đến từ stdin và chỉ chứa loại kết nối không có dòng mới.

Trước:

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

Đưa ra một đối số dòng lệnh. Ung dung:

# 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

Con trăn, 168 ký tự

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

Xuất hiện là một cách tiếp cận mới. Tôi có chuỗi:

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

Tôi thay thế G, Hvà 2dựa trên đầu vào.

J, 153 121 119 ký tự

('='(;/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.<

Cách tiếp cận thứ ba: đóng gói tất cả  và #một số nguyên lớn dưới dạng bit. Thêm =sau đó. Mặc dù vậy, vẫn không sử dụng tính đối xứng của nhiều biến thể kết nối.

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

[: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.<

Cũng như một chức năng. Cái này sử dụng mã hóa nhị phân có độ dài thay đổi, bằng cách kiểm đếm mã nhị phân và phân tách bằng số không. Có nghĩa là 0 cái liên tiếp  , 1 nghĩa là #2, nghĩa là 2 =, 3 nghĩa là newline và 4 cái tách năm chuỗi với nhau.

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

Tuyệt vời, 281 byte / ký tự

Giảm thiểu:

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

Này có D1, D2, I1, I2hoặc Atừ STDIN. Trailing newlines trong đầu vào là tùy chọn. Đầu ra là STDOUT.

Chương trình này gọi các bảng con in các phần của đầu nối, hoặc điền vào # s hoặc để lại khoảng trắng tùy thuộc vào đầu vào.

Hãy thử câu trả lời này ở đây ; bảng hình trụ là cần thiết.

với nhận xét:

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

Perl 5: 105 (bao gồm 1 cờ)

Một giải pháp Perl khác. Sử dụng stdin cho tham số.

#!perl -p
@x=map$_?'#':$",!/D/,-/2/,!/A/,1,0;$_='040 33311233
=====433311222
040 33211233';s/\d/$x[$&] /g;s/ $//mg

GNU sed, 116 byte

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

Đầu ra:

$ echo "A
D1
D2
I1
I2"|sed -f dvi.sed
#   #   # # #       # #
=====   # # #          
#   #   # #         # #
        # # #     # # #
=====   # # #     # # #
        # # #     # # #
        # # # # # # # #
=====   # # # # # # # #
        # # # # # # # #
#   #   # # #     # # #
=====   # # #     # # #
#   #   # # #     # # #
#   #   # # # # # # # #
=====   # # # # # # # #
#   #   # # # # # # # #
$ 

J, 198 194 157 ký tự

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

Thực hiện như một chức năng. Lưu ý rằng hàm là một tàu, có nghĩa là người ta sẽ phải bao quanh nó bằng dấu ngoặc đơn hoặc gán nó cho một tên để sử dụng nó (có lẽ tôi nên tính các parens là một phần của hàm, mặc dù về mặt kỹ thuật chúng không có).

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

Ý tưởng là lưu trữ phần chung của chuỗi riêng biệt với các ký tự khác nhau giữa các loại trình kết nối. S1lưu trữ các ký tự duy nhất và S2hoạt động như một mẫu vớix vai trò giữ chỗ để điền vào.

Con trăn - 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

JavaScript (ES6) 178 186

Chỉnh sửa Có 7 khối cơ sở, sử dụng cơ sở 7
Cách thẳng, sử dụng xây dựng chuỗi với thay thế và 7 khối xây dựng.
Xuất ra thiết bị xuất chuẩn bằng cảnh báo theo yêu cầu của OP.
Bây giờ tôi sẽ thử một số tối ưu hóa vi mô ...

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

Kiểm tra trong bảng điều khiển FireFox / FireBug - xóa 'cảnh báo' để đơn giản hóa kiểm tra

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

Đầu ra

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

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

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

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

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

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

Kiểm tra:

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

JavScript ES6, 186 byte

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

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'))
alert(f(prompt()))

Mã này nhanh và bẩn, nhưng nó hoàn thành công việc. Hầu hết, các #không gian và không gian được đưa vào nhị phân và sau đó là cơ sở 36. Tôi đang tìm kiếm một giải pháp ngắn gọn và thanh lịch hơn.

Perl 5 - 150 (149 + 1 cho n )

Chơi gôn

@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

Đầu vào từ STDIN, đầu ra đến STDOUT. Hoạt động bằng cách điền vào một số ký tự với #hoặc tùy thuộc vào đầu vào.

Ung dung:

@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 $_;