นี่น่าจะเป็นความท้าทายของนักกอล์ฟที่ส่วนท้ายของสเปกตรัม แต่ฉันคิดว่ามันอาจจะดีที่จะนำเอาการเพิ่มประสิทธิภาพขนาดเล็กออกมาที่นี่

มีตัวเชื่อมต่อ 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ตัวเชื่อมต่อ คุณต้องไม่ใช้ช่องว่างนำหน้าหรือต่อท้ายเพิ่มเติมที่อื่น

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุด (เป็นไบต์) ชนะ

CJam, 79 70 ไบต์

แรงบันดาลใจจากคำตอบของ nutki สิ่งนี้ทำให้แน่ใจว่าไม่มีช่องว่างสีขาวต่อท้าย (ยกเว้นบรรทัดที่สอง)

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

ลองออนไลน์ได้ที่นี่

Perl - 100 91 (รวม 1 ธง)

ใช้แนวคิดของ nutki ในการใช้-pและลดช่องว่างสองครั้ง ลดความซับซ้อนของการเว้นช่องว่างท้าย

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

อินพุตมาจาก stdin และต้องมีเฉพาะประเภทตัวเชื่อมต่อที่ไม่มีการขึ้นบรรทัดใหม่

ก่อนหน้านี้:

$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

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อยู่บนพื้นฐานของการป้อนข้อมูล

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

วิธีที่สาม: แพ็คทั้งหมด และ#เป็นจำนวนเต็มขนาดใหญ่เป็นบิต เพิ่ม=หลังจากนั้น ถึงกระนั้นก็ยังไม่ได้ใช้ประโยชน์จากความหลากหลายของคอนเนคเตอร์ที่หลากหลาย

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

ยังเป็นฟังก์ชั่น อันนี้ใช้การเข้ารหัสไบนารี่ไบค์ที่มีความยาวผันแปรได้โดยทำการนับเลขในไบนารี่และแยกด้วยเลขศูนย์ 0 รายการในแถวหมายความว่า 1 หนึ่งหมายถึง#, 2 หมายถึง=3 คนหมายถึงการขึ้นบรรทัดใหม่และ 4 คนแยกห้าสายจากกัน

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

Marbelous, 281 ไบต์ / ตัวอักษร

minified:

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

โปรแกรมนี้เรียกกระดานย่อยซึ่งพิมพ์ส่วนต่าง ๆ ของตัวเชื่อมต่อไม่ว่าจะเป็นการเติมใน#ช่องว่างหรือเว้นช่องว่างทั้งนี้ขึ้นอยู่กับอินพุต

ลองคำตอบนี้ที่นี่ ; จำเป็นต้องมีบอร์ดทรงกระบอก

ด้วยความคิดเห็น:

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 (รวม 1 ธง)

อีกวิธีหนึ่งของ Perl ใช้ stdin สำหรับพารามิเตอร์

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

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

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

ดำเนินการเป็นฟังก์ชั่น โปรดทราบว่าฟังก์ชั่นเป็นรถไฟซึ่งหมายความว่าจะต้องล้อมรอบด้วยวงเล็บหรือกำหนดให้ชื่อเพื่อใช้งาน (บางทีฉันควรนับ parens เป็นส่วนหนึ่งของฟังก์ชั่นแม้ว่าพวกเขาจะไม่ใช้เทคนิค)

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ที่ทำหน้าที่เป็นตัวยึดตำแหน่งให้เติม

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

แก้ไขมี 7 บล็อกฐานใช้ฐาน 7
ทางตรงโดยใช้การสร้างสตริงพร้อมแทนที่และ 7 บล็อกการสร้าง
ส่งออกไปยัง stdout โดยใช้การแจ้งเตือนตามที่ร้องขอโดย 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)))

เอาท์พุต

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

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

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

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

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

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

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

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

รหัสนั้นรวดเร็วและสกปรก แต่ทำให้งานเสร็จ ส่วนใหญ่แล้ว#ช่องว่างของมันจะถูกใส่เข้าไปในรูปแบบฐานสองแล้วตามด้วยเลขฐาน 36 ฉันกำลังมองหาวิธีแก้ปัญหาที่สั้นและสง่างามกว่า

Perl 5 - 150 (149 + 1 สำหรับ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

อินพุตจาก 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 $_;