DVI-Anschlussstifte

23

Dies soll eine Code-Golf-Herausforderung am einfacheren Ende des Spektrums sein. Aber ich dachte, es könnte schön sein, hier eine Mikrooptimierung herauszubringen.

Es gibt drei grundlegende Arten von DVI-Anschlüssen : DVI-A (analog), DVI-D (digital) und DVI-I (integriert). Darüber hinaus gibt es Single-Link- und Dual-Link-Versionen der DVI-D- und DVI-I-Anschlüsse. Jeder dieser fünf verschiedenen Anschlüsse verwendet einen anderen Satz von Stiften.

Angesichts einer von A, D1, D2, I1, I2als eine Kennung für die Art des Verbinders, drucken die entsprechenden ASCII - Darstellung der Stifte des Steckers:

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

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

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

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

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

(Die X:Zeilen sind nicht Teil der Ausgabe, Sie sollten nur 3 Zeilen drucken.)

Sie können ein Programm oder eine Funktion schreiben und Eingaben über STDIN, ARGV oder Funktionsargument vornehmen. Die Ausgabe muss mit einem optionalen Zeilenvorschub nach STDOUT gedruckt werden.

Sie können nachgestellte Leerzeichen in die zweite Zeile des AConnectors einfügen oder nicht . Sie dürfen an keiner anderen Stelle zusätzliche führende oder nachfolgende Leerzeichen verwenden.

Dies ist Codegolf, daher gewinnt die kürzeste Antwort (in Bytes).

code-golf ascii-art kolmogorov-complexity Martin Ender
quelle
Kann ich verlangen, dass Eingaben in Anführungszeichen stehen, z. B. "I1"statt I1?
Claudiu
Sind Leerzeichen in anderen Zeilen zulässig?
gone_native
1
@Claudiu Nein, sorry.
Martin Ender
@gone_native Auch nein, tut mir leid (fügt das dem Beitrag hinzu).
Martin Ender

Antworten:

3

CJam, 79 70 Bytes

Inspiriert von Nutkis Antwort . Dies stellt auch sicher, dass keine nachgestellten Leerzeichen vorhanden sind (außer in der zweiten Zeile).

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

Verwenden Sie diesen Link, um den Code zu kopieren, während SE nicht druckbare Zeichen entfernt.

Es gibt 5 Zeichen im nicht druckbaren ASCII-Bereich, jedoch innerhalb eines Bytes (ASCII-Code 255).

Wie es funktioniert :

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

Probieren Sie es hier online aus

Optimierer
quelle
16

Perl - 100 91 (einschließlich 1 Flagge)

Nutzt Nutkis Ideen zur Verwendung -pund Reduzierung von Doppelspalten. Vereinfachte Eliminierung von Leerzeichen.

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

Die Eingabe stammt von stdin und darf nur den Connector-Typ ohne nachfolgende Newline enthalten.

Bisherige:

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

Übernimmt ein Befehlszeilenargument. 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
quelle
2
Geniale Idee für den Umgang mit dem Parameter. Sie können immer noch 2 Bytes sparen, $x=shift|" qb"indem Sie 3 Vorkommen von doppeltem Leerzeichen bin der Vorlage hinzufügen und durch ersetzen . Wenn Sie die Eingabeverarbeitung auf '-p' ändern, erhalten Sie zusätzlich 7 (abzüglich des Flags): $x=$_|""und es ist kein final erforderlich say.
Nutki
@nutki - Danke, das habe ich verpasst!
gone_native
@ MartinBüttner - Alle 3 Zeilen haben nachgestellte Leerzeichen, obwohl ich erkannt habe, dass ich die erste und dritte Zeile leicht reparieren kann, indem ich das letzte Zeichen in diesen Zeilen von xnach konvertiere #. Die zweite Zeile enthält jedoch immer noch Leerzeichen. Denn Ader Raum erstreckt sich über das Finale #der anderen Zeilen hinaus (was ich technisch zulasse). Aber für die I1, I2usw. In einigen Fällen gibt es noch einen nachgestellten Bereich, für den gesorgt werden muss. Ich denke, ich kann ein paar weitere Charaktere herausgolfen.
gone_native
@gone_native oh, du hast recht.
Martin Ender
9

Python, 168 Zeichen

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

Scheint ein neuer Ansatz zu sein. Ich habe die Zeichenfolge:

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

Ich ersetze das G, Hund 2auf der Grundlage der Eingabe.

Claudiu
quelle
5

J, 153 121 119 Zeichen

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

Ein dritter Ansatz: Packe alle  und alle #in eine riesige ganze Zahl als Bits. Fügen Sie die ='s danach hinzu. Nutzt aber immer noch nicht die Symmetrie vieler Steckervarianten.

Uneingeschränkt 
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. <
Minimiert (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.<

Auch als Funktion. Diese verwendet eine binäre Kodierung mit variabler Länge, indem Einsen in Binärzahlen zusammengefasst und durch Nullen getrennt werden. 0 Einsen in einer Reihe bedeuten  , 1 #Einsen bedeutet , 2 Einsen bedeuten =, 3 Einsen bedeuten Zeilenvorschub und 4 Einsen trennen die fünf Saiten voneinander.

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. <
FireFly
quelle
4

Marbelous, 281 Bytes / Zeichen

Minimiert:

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

Dies geschieht D1, D2, I1, I2oderA von STDIN. Das Verfolgen von Zeilenumbrüchen in der Eingabe ist optional. Die Ausgabe erfolgt nach STDOUT.

Dieses Programm ruft Unterplatinen auf, die Teile von Steckverbindern drucken und diese ausfüllen # und je nach s oder Leerzeichen lassen.

Versuchen Sie diese Antwort hier ; Es werden zylindrische Platten benötigt.

mit Kommentaren:

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

Perl 5: 105 (einschließlich 1 Flag)

Noch eine Perl-Lösung. Verwendet stdin für den Parameter.

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

GNU sed, 116 Bytes

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

Ausgabe:

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

J, 198, 194, 157 Zeichen

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

Als Funktion implementiert. Beachten Sie, dass es sich bei der Funktion um einen Zug handelt, dh, Sie müssen ihn in Klammern setzen oder einem Namen zuweisen, um ihn zu verwenden (möglicherweise sollte ich die Parens als Teil der Funktion zählen, auch wenn dies technisch nicht der Fall ist).

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

Die Idee ist, den gemeinsamen Teil der Zeichenfolge getrennt von den Zeichen zu speichern, die sich zwischen den Anschlusstypen unterscheiden. S1speichert die eindeutigen Zeichen und S2fungiert als Muster, wobei x's als Platzhalter zum Ausfüllen fungiert.

FireFly
quelle
3

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
Falko
quelle
3

JavaScript (ES6) 178 186

Bearbeiten Wenn Sie 7 Basisblöcke haben, verwenden Sie die Basis 7
Der direkte Weg, indem Sie Zeichenfolgen mit Ersetzen und 7 Bausteine ​​erstellen.
Ausgabe auf Standardausgabe mit Alarm, wie vom OP angefordert.
Jetzt werde ich einige Mikrooptimierungen versuchen ...

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

Test in der FireFox / FireBug-Konsole - Entfernen der Warnmeldung, um den Test zu vereinfachen

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

Ausgabe

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

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

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

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

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

Prüfung:

      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
#   #  # # # # # # # #
=====  # # # # # # # #
#   #  # # # # # # # #
Marinus
quelle
@ MartinBüttner: whoops, fixed
marinus
2

JavScript ES6, 186 Bytes

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

Code-Snippet anzeigen

Der Code ist schnell und schmutzig, aber er erledigt die Arbeit. Meistens werden die #s und Leerzeichen in binäre und dann in Basis 36 gesetzt. Ich suche nach einer eleganteren und hoffentlich kürzeren Lösung.

NinjaBearMonkey
quelle
Wenn ich auf Code-Snippet ausführen klicke , wird nichts angezeigt.
AL
Dies liegt wahrscheinlich daran, dass ECMAScript 6-Pfeilfunktionen verwendet werden, die nur in neueren Firefox-Versionen unterstützt werden.
NinjaBearMonkey
Ich habe mit der letzten Version von Firefox getestet und nichts passiert. Gibt es etwas zu tun, um diese Funktion zu testen?
AL
1
Oh, das liegt daran, dass es nur eine Funktion ist. Ich werde einen Weg hinzufügen, um es zu testen.
NinjaBearMonkey
Sie können den Code so bearbeiten, dass er als Snippet ausgeführt werden kann (verwenden Sie einen zweiten Codeblock, um den ursprünglichen Code beizubehalten) oder den Snippet-Renderer entfernen.
AL
1

Perl 5 - 150 (149 + 1 für n )

Golf gespielt:

@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

Eingabe von STDIN, Ausgabe an STDOUT. Füllt bestimmte Zeichen mit# oder abhängig von der Eingabe aus.

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
quelle