डीवीआई कनेक्टर पिंस

23

यह स्पेक्ट्रम के सरल छोर पर एक कोड गोल्फ चुनौती माना जाता है। लेकिन मुझे लगा कि यहाँ कुछ माइक्रो-ऑप्टिमाइज़ेशन करना अच्छा हो सकता है।

हैं डीवीआई कनेक्टर्स के तीन बुनियादी प्रकार डीवीआई-ए (एनालॉग), डीवीआई-डी (डिजिटल) और डीवीआई-आई (एकीकृत):। इसके अलावा, डीवीआई-डी और डीवीआई-आई कनेक्टर के एकल-लिंक और दोहरे-लिंक संस्करण हैं। उन पांच अलग-अलग कनेक्टर्स में से प्रत्येक पिन के एक अलग सेट का उपयोग करता है।

में से एक को देखते हुए 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
@ कलुआडु नोप, सॉरी।
— मार्टिन एंडर
@gone_native इसके अलावा नहीं, क्षमा करें (पोस्ट में जोड़ देगा)।
— मार्टिन एंडर

जवाबों:

3

CJam, 79 70 बाइट्स

नटकी के उत्तर से प्रेरित । यह भी सुनिश्चित करता है कि कोई सफेद जगह नहीं है (दूसरी पंक्ति को छोड़कर)

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

कोड को कॉपी करने के लिए इस लिंक का उपयोग एसई स्ट्रिप्स गैर-मुद्रण योग्य वर्णों के रूप में करें।

गैर-मुद्रण योग्य ASCII सीमा में 5 वर्ण हैं लेकिन एक बाइट (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

पर्ल - 100 91 (1 ध्वज सहित)

-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
पैरामीटर को संभालने के लिए सरल विचार। आप अभी भी टेम्पलेट के $x=shift|" qb"साथ डबल स्थान की 3 घटनाओं को जोड़कर और बदलकर 2 बाइट्स बचा सकते हैं b। इनपुट प्रोसेसिंग को '-p' में बदलने से 7 अतिरिक्त (माइनस द फ्लैग) मिलते हैं: $x=$_|""और फाइनल की कोई आवश्यकता नहीं है say।
— नटकी
@ कुटकी - धन्यवाद, मुझे वह याद आया!
— ३_१० बजे
@ MartinBüttner - सभी 3 लाइनों रिक्त स्थान अनुगामी है, हालांकि मुझे एहसास हुआ कि मैं से उन पंक्तियों में अंतिम चार में कनवर्ट करके आसानी से पहले और तीसरे लाइनों को ठीक कर सकते xकरने के लिए #। लेकिन दूसरी पंक्ति में अभी भी सभी मामलों में अनुगामी स्थान हैं। इसके लिए A, अंतरिक्ष #अन्य रेखाओं के फाइनल से परे फैली हुई है (जो मुझे लगता है कि तकनीकी रूप से अनुमति है)। लेकिन के लिए I1, I2, आदि। मामलों में, अभी भी एक अनुगामी स्थान है जिसका ध्यान रखने की आवश्यकता है। मुझे लगता है कि मैं कुछ और पात्रों को इसमें से बाहर निकाल सकता हूं।
— ३_१३ बजे ३
@gone_native ओह, आप सही कह रहे हैं।
— मार्टिन एंडर
9

अजगर, 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इनपुट के आधार पर।

— Claudiu
स्रोत
5

जे, 153 121 119 चार

minified 
('='(;/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या Astdin से। इनपुट में अनुगामी newlines वैकल्पिक है। आउटपुट 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
— es1024
स्रोत
4

पर्ल 5: 105 (1 ध्वज सहित)

फिर भी एक और पर्ल समाधान। पैरामीटर के लिए स्टड का उपयोग करता है।

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

जे, 198 194 157 चार्ट

minified 
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 को गिनना चाहिए, भले ही तकनीकी रूप से वे नहीं हैं)।

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

जावास्क्रिप्ट (ईएस 6) 178 186

7 बेस ब्लॉक्स वाले एडिट करें , बेस 7
का उपयोग करें । स्ट्रेट बिल्डिंग को रिप्लेस और 7 बिल्डिंग ब्लॉक्स के साथ उपयोग करें।
ओपी के अनुरोध के अनुसार सतर्कता का उपयोग करते हुए आउटपुट को रोकें।
अब मैं कुछ सूक्ष्म अनुकूलन की कोशिश करूँगा ...

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

एपीएल (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: ओह, तय
— मारीनस
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'))

कोड स्निपेट दिखाएं

कोड त्वरित और गंदा है, लेकिन यह काम हो जाता है। ज्यादातर, #'s और रिक्त स्थान को बाइनरी में और फिर बेस 36 में रखा गया है। मैं अधिक सुरुचिपूर्ण और उम्मीद से कम समाधान में देख रहा हूं।

— NinjaBearMonkey
स्रोत
जब मैं रन कोड स्निपेट पर क्लिक करता हूं तो मुझे कुछ भी दिखाई नहीं देता है।
— AL
ऐसा शायद इसलिए है क्योंकि यह ECMAScript 6 एरो फ़ंक्शंस का उपयोग करता है, जो केवल हाल के फ़ायरफ़ॉक्स संस्करणों में समर्थित हैं।
— निन्जाबियरमॉन्की
मैंने फ़ायरफ़ॉक्स के अंतिम संस्करण के साथ परीक्षण किया और कुछ भी नहीं हुआ। क्या इस फ़ंक्शन का परीक्षण करने के लिए कुछ करना है?
— AL
1
ओह, यह क्योंकि यह केवल एक समारोह है क्योंकि यह है। मैं इसका परीक्षण करने का एक तरीका जोड़ूंगा।
— निन्जाबियरमॉन्की
आप इसे स्निपेट के रूप में चलाने योग्य बनाने के लिए कोड को संपादित कर सकते हैं (मूल कोड रखने के लिए दूसरे कोड ब्लॉक का उपयोग करें) या स्निपेट रेंडरर को हटा दें।
— AL
1

पर्ल 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 Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.