Piny złącza DVI

23

To ma być wyzwanie golfowe na prostszym końcu spektrum. Uznałem jednak, że fajnie byłoby tutaj wprowadzić mikrooptymalizację.

Istnieją trzy podstawowe typy złączy DVI : DVI-A (analogowe), DVI-D (cyfrowe) i DVI-I (zintegrowane). Ponadto istnieją wersje z jednym i dwoma łączami DVI-D i DVI-I. Każde z tych pięciu różnych złączy wykorzystuje inny zestaw pinów.

Biorąc pod uwagę jeden A, D1, D2, I1, I2jako identyfikator dla danego typu złącza, należy wydrukować odpowiednią reprezentację ASCII pinów złącza za:

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

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

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

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

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

( X:Linie nie są częścią wyniku, powinieneś wydrukować tylko 3 linie.)

Możesz napisać program lub funkcję, przyjmując dane wejściowe przez STDIN, ARGV lub argument funkcji. Wyjście musi zostać wydrukowane do STDOUT, z opcjonalnym przesuwem linii końcowej.

W drugiej linii Ałącznika możesz, ale nie musi, wstawiać spacje . Nie wolno używać dodatkowych spacji wiodących lub końcowych nigdzie indziej.

To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach).

Martin Ender
źródło
Czy mogę wymagać, aby dane wejściowe były otoczone cudzysłowami, np. "I1"Zamiast I1?
Claudiu
Czy dozwolone są spacje na innych liniach?
gone_native
1
@Claudiu Nie, przepraszam.
Martin Ender,
@ gone_native Również nie, przepraszam (doda to do postu).
Martin Ender,

Odpowiedzi:

3

CJam, 79 70 bajtów

Inspirowany odpowiedzią nutki . Zapewnia to również, że nie ma końcowych białych spacji (z wyjątkiem drugiej linii)

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

Użyj tego linku, aby skopiować kod, ponieważ SE usuwa znaki niedrukowalne.

Istnieje 5 znaków w zakresie niedrukowalnym ASCII, ale mieszczącym się w bajcie (kod ASCII 255)

Jak to działa :

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

Wypróbuj online tutaj

Optymalizator
źródło
16

Perl - 100 91 (w tym 1 flaga)

Wykorzystuje pomysły nutki dotyczące używania -pi zmniejszania podwójnych spacji. Uproszczono również eliminację spacji końcowych.

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

Dane wejściowe pochodzą ze standardowego wejścia i muszą zawierać tylko typ złącza bez końca nowej linii.


Poprzedni:

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

Bierze argument wiersza polecenia. Nie golfowany:

# 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
źródło
2
Pomysłowy sposób obsługi parametru. Nadal możesz zapisać 2 bajty, dodając $x=shift|" qb"i zamieniając 3 wystąpienia podwójnej spacji bw szablonie. Również zmiana przetwarzania danych wejściowych na „-p” daje 7 dodatkowych (minus flaga): $x=$_|""i nie ma potrzeby końcowego say.
nutki
@nutki - Dzięki, tęskniłem za tym!
gone_native
@ MartinBüttner - Wszystkie 3 linie mają spacje końcowe, chociaż zdałem sobie sprawę, że mogę łatwo naprawić pierwszą i trzecią linię, konwertując końcowy znak w tych liniach od xdo #. Ale druga linia wciąż ma końcowe spacje we wszystkich przypadkach. Bo Aprzestrzeń rozciąga się poza finał #pozostałych linii (co, jak sądzę, jest technicznie dozwolone). Ale dla I1, I2itp. W niektórych przypadkach należy jeszcze zająć miejsce. Myślę jednak, że mogę zagrać w golfa z kilkoma innymi postaciami.
gone_native
@ gone_native och, masz rację.
Martin Ender,
9

Python, 168 znaków

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

Wydaje się być nowym podejściem. Mam ciąg:

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

Ja wymienić G, Hi 2na podstawie danych wejściowych.

Claudiu
źródło
5

J, 153 121 119 znaków

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

Trzecie podejście: spakuj wszystko  i #do wielkiej liczby całkowitej. =Następnie dodaj . Nadal jednak nie wykorzystuje symetrii wielu wariantów złączy.

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

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

Również jako funkcja. Ten wykorzystuje kodowanie binarne o zmiennej długości, łącząc je w binarne i oddzielając od zera. 0 z rzędu oznacza  , 1 oznacza #, 2 oznacza =, 3 oznacza znak nowej linii, a 4 oddzielają pięć łańcuchów od siebie.

Bez golfa
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. <
Robaczek świętojański
źródło
4

Cudowny, 281 bajtów / znaków

Zminimalizowane:

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

To trwa D1, D2, I1, I2lub Aze standardowego wejścia. Końcowe znaki nowej linii w danych wejściowych są opcjonalne. Dane wyjściowe to STDOUT.

Ten program wywołuje podpłyty, które drukują części złączy, wypełniając je #lub pozostawiając spacje w zależności od danych wejściowych.

Wypróbuj tę odpowiedź tutaj ; potrzebne są deski cylindryczne.

z komentarzami:

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
źródło
4

Perl 5: 105 (w tym 1 flaga)

Jeszcze inne rozwiązanie Perla. Używa stdin dla parametru.

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

GNU sed, 116 bajtów

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

Wydajność:

$ echo "A
D1
D2
I1
I2"|sed -f dvi.sed
#   #   # # #       # #
=====   # # #          
#   #   # #         # #
        # # #     # # #
=====   # # #     # # #
        # # #     # # #
        # # # # # # # #
=====   # # # # # # # #
        # # # # # # # #
#   #   # # #     # # #
=====   # # #     # # #
#   #   # # #     # # #
#   #   # # # # # # # #
=====   # # # # # # # #
#   #   # # # # # # # #
$ 
Cyfrowa trauma
źródło
3

J, 198 194 157 znaków

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

Wdrożony jako funkcja. Zauważ, że funkcja jest pociągiem, co oznacza, że ​​należałoby ją otoczyć nawiasami lub przypisać do nazwy, aby z niej skorzystać (może powinienem policzyć pareny jako część funkcji, chociaż technicznie nie są).

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

Chodzi o to, aby przechowywać wspólną część łańcucha oddzielnie od znaków, które różnią się między typami łączników. S1przechowuje unikalne postacie i S2działa jako wzór z xdziałającymi jako symbole zastępcze do wypełnienia.

Robaczek świętojański
źródło
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
źródło
3

JavaScript (ES6) 178 186

Edytuj Mając 7 bloków podstawowych, użyj podstawy 7
Prosto, używając budowania ciągów z zamiennikiem i 7 bloków konstrukcyjnych.
Wyjście na standardowe wyjście przy użyciu alertu zgodnie z żądaniem OP.
Teraz spróbuję mikrooptymalizacji ...

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

Testuj w konsoli FireFox / FireBug - usunięcie „alertu” w celu uproszczenia testu

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

Wydajność

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

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

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

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

#   #  # # # # # # # #
=====  # # # # # # # #
#   #  # # # # # # # #
edc65
źródło
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

Test:

      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
źródło
@ MartinBüttner: ups, naprawiono
marinus
2

JavScript ES6, 186 bajtów

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

Kod jest szybki i brudny, ale wykonuje zadanie. Przeważnie #liczby i spacje są zapisywane w postaci binarnej, a następnie w bazie 36. Rozglądam się za bardziej eleganckim i miejmy nadzieję krótszym rozwiązaniem.

NinjaBearMonkey
źródło
Po kliknięciu Uruchom fragment kodu nic nie widzę.
AL
Prawdopodobnie dlatego, że używa funkcji strzałek ECMAScript 6, które są obsługiwane tylko w najnowszych wersjach Firefoksa.
NinjaBearMonkey
Testowałem z ostatnią wersją Firefoksa i nic się nie dzieje. Czy jest coś do zrobienia, aby przetestować tę funkcję?
AL,
1
Och, bo to tylko funkcja. Dodam sposób, aby to przetestować.
NinjaBearMonkey
możesz edytować kod, aby działał jako fragment kodu (użyj drugiego bloku kodu, aby zachować oryginalny kod) lub usuń moduł renderujący fragment kodu.
AL
1

Perl 5-150 (149 + 1 za n)

Gra w golfa:

@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

Wejście ze STDIN, wyjście do STDOUT. Działa poprzez wypełnianie niektórych znaków za pomocą #lub w zależności od danych wejściowych.

Nie golfowany:

@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
źródło