Pin del connettore DVI

23

Questa dovrebbe essere una sfida al golf del codice all'estremità più semplice dello spettro. Ma ho pensato che potesse essere bello mettere in evidenza un po 'di micro-ottimizzazione qui.

Esistono tre tipi base di connettori DVI : DVI-A (analogico), DVI-D (digitale) e DVI-I (integrato). Inoltre, ci sono versioni single-link e dual-link dei connettori DVI-D e DVI-I. Ognuno di questi cinque connettori diversi utilizza un diverso set di pin.

Dato uno A, D1, D2, I1, I2come un identificatore per il tipo di connettore, stampare la rappresentazione ASCII corrispondente piedini del connettore:

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

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

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

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

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

(Le X:righe non fanno parte dell'output, è necessario stampare solo 3 righe.)

È possibile scrivere un programma o una funzione, prendendo input tramite STDIN, ARGV o argomento della funzione. L'output deve essere stampato su STDOUT, con un avanzamento riga finale opzionale.

È possibile includere o meno spazi finali nella seconda riga del Aconnettore. Non è necessario utilizzare spazi iniziali o finali aggiuntivi altrove.

Questo è il golf del codice, quindi vince la risposta più breve (in byte).

code-golf  ascii-art  kolmogorov-complexity 
— Martin Ender
fonte
Posso richiedere che l'input sia racchiuso tra virgolette, ad es. "I1"Anziché I1?
— Claudiu,
Sono consentiti spazi finali su altre linee?
— gone_native
1
@Claudiu No, scusa.
— Martin Ender,
@gone_native Inoltre no, scusa (lo aggiungerò al post).
— Martin Ender,

Risposte:

3

CJam, 79 70 byte

Ispirato dalla risposta di Nutki . Questo assicura anche che non vi siano spazi bianchi finali (ad eccezione della seconda riga)

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

Utilizzare questo collegamento per copiare il codice poiché SE non rimuove i caratteri non stampabili.

Ci sono 5 caratteri nell'intervallo ASCII non stampabile ma ben all'interno di un byte (codice ASCII 255)

Come funziona :

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

Provalo online qui

— Optimizer
fonte
16

Perl - 100 91 (inclusa 1 bandiera)

Utilizza le idee di nutki sull'uso -pe la riduzione dei doppi spazi. Eliminazione semplificata anche degli spazi finali.

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

L'input proviene da stdin e deve contenere solo il tipo di connettore senza newline finale.

Precedente:

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

Accetta un argomento da riga di comando. 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
fonte
2
Idea geniale per la gestione del parametro. Puoi comunque salvare 2 byte aggiungendo $x=shift|" qb"e sostituendo 3 occorrenze di doppio spazio con bnel modello. Anche la modifica dell'elaborazione dell'input in '-p' dà 7 extra (meno il flag): $x=$_|""e non c'è bisogno di final say.
— Nutki,
@nutki - Grazie, mi sono perso!
— gone_native
@ MartinBüttner - Tutte e 3 le linee hanno spazi finali, anche se ho capito che posso correggere facilmente la prima e la terza riga convertendo il carattere finale in quelle righe da xa #. Ma la seconda riga ha ancora spazi finali in tutti i casi. Perché A, lo spazio si estende oltre il finale #delle altre linee (che suppongo sia tecnicamente consentito). Ma per il I1, I2, ecc. casi, c'è ancora uno spazio finale che deve essere curato. Penso di poter giocare a golf un altro paio di personaggi, però.
— gone_native
@gone_native oh, hai ragione.
— Martin Ender,
9

Python, 168 caratteri

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

Sembra essere un nuovo approccio. Ho la stringa:

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

Sostituisce la G, He 2in base ai contributi.

— Claudiu
fonte
5

J, 153 121 119 caratteri

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

Un terzo approccio: impacchettare tutti  e tutti #in un intero numero intero come bit. Aggiungi il =dopo. Tuttavia, non fa ancora uso della simmetria di molte varianti del connettore.

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

Anche come una funzione. Questo utilizza una codifica binaria di lunghezza variabile, calcolando quelli binari e separandoli per zero. 0 uno di fila significa  , 1 uno significa #, 2 uno significa =, 3 uno significa newline e 4 uno separano le cinque stringhe l'una dall'altra.

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. <
— Lucciola
fonte
4

Marbelous, 281 byte / caratteri

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

Questo richiede D1, D2, I1, I2o Ada STDIN. Il trascinamento di nuove righe nell'input è facoltativo. L'uscita è su STDOUT.

Questo programma chiama schede secondarie che stampano parti dei connettori, riempiendo #se lasciando spazi a seconda degli input.

Prova questa risposta qui ; sono necessarie tavole cilindriche.

con commenti:

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

Perl 5: 105 (inclusa 1 bandiera)

Ancora un'altra soluzione Perl. Utilizza stdin per il parametro.

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

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/.*://

Produzione:

$ echo "A
D1
D2
I1
I2"|sed -f dvi.sed
#   #   # # #       # #
=====   # # #          
#   #   # #         # #
        # # #     # # #
=====   # # #     # # #
        # # #     # # #
        # # # # # # # #
=====   # # # # # # # #
        # # # # # # # #
#   #   # # #     # # #
=====   # # #     # # #
#   #   # # #     # # #
#   #   # # # # # # # #
=====   # # # # # # # #
#   #   # # # # # # # #
$
— Trauma digitale
fonte
3

J, 198 194 157 caratteri

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

Implementato come una funzione. Si noti che la funzione è un treno, il che significa che si dovrebbe circondarlo tra parentesi o assegnarlo a un nome per usarlo (forse dovrei contare i genitori come parte della funzione, anche se tecnicamente non lo sono).

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

L'idea è di memorizzare la parte comune della stringa separatamente dai caratteri che differiscono tra i tipi di connettore. S1memorizza i personaggi unici e S2funge da modello con xla funzione di segnaposto da compilare.

— Lucciola
fonte
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
fonte
3

JavaScript (ES6) 178 186

Modifica Avendo 7 blocchi base, usa base 7
La via diritta, usando la costruzione di stringhe con sostituzione e 7 blocchi.
Uscita allo stdout usando l'avviso come richiesto dall'OP.
Ora proverò alcune micro-ottimizzazioni ...

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 nella console FireFox / FireBug: rimozione di "alert" per semplificare il test

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

Produzione

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

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

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

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

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

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

Mostra snippet di codice

Il codice è veloce e sporco, ma fa il lavoro. Principalmente, gli #spazi e gli spazi vengono messi in binario e poi in base 36. Sto cercando una soluzione più elegante e, si spera, più breve.

— NinjaBearMonkey
fonte
Quando faccio clic su Esegui snippet di codice non vedo nulla.
— AL
Questo probabilmente perché utilizza le funzioni freccia ECMAScript 6, che sono supportate solo nelle recenti versioni di Firefox.
— NinjaBearMonkey,
Ho provato con l'ultima versione di Firefox e non succede nulla. C'è qualcosa da fare per testare questa funzione?
— AL
1
Oh, perché è solo una funzione. Aggiungerò un modo per testarlo.
— NinjaBearMonkey
puoi modificare il codice per renderlo eseguibile come snippet (usa un secondo blocco di codice per conservare il codice originale) o rimuovere il renderer dello snippet.
— AL
1

Perl 5-150 (149 + 1 per 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

Ingresso da STDIN, uscita a STDOUT. Funziona completando alcuni caratteri con #o in base all'input.

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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.