Pinos do conector DVI

23

Supõe-se que este seja um desafio para o código de golfe no extremo mais simples do espectro. Mas achei que poderia ser bom trazer aqui algumas micro-otimizações.

Existem três tipos básicos de conectores DVI : DVI-A (analógico), DVI-D (digital) e DVI-I (integrado). Além disso, existem versões de link único e link duplo dos conectores DVI-D e DVI-I. Cada um desses cinco conectores diferentes usa um conjunto diferente de pinos.

Dado um dos A, D1, D2, I1, I2como um identificador para o tipo de conector, imprimir a representação ASCII correspondente de pinos do conector:

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

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

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

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

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

(As X:linhas não fazem parte da saída, você deve imprimir apenas 3 linhas.)

Você pode escrever um programa ou função, recebendo entradas via STDIN, ARGV ou argumento de função. A saída deve ser impressa em STDOUT, com uma alimentação de linha móvel opcional.

Você pode ou não incluir espaços à direita na segunda linha do Aconector. Você não deve usar espaços iniciais ou finais adicionais em nenhum outro lugar.

Isso é código de golfe, então a resposta mais curta (em bytes) vence.

code-golf ascii-art kolmogorov-complexity Martin Ender
fonte
Posso exigir que a entrada esteja entre aspas, por exemplo, em "I1"vez de I1?
21414 Claudiu
São permitidos espaços à direita em outras linhas?
gone_native
1
@ Claudiu Não, desculpe.
Martin Ender
@gone_native Também não, desculpe (adicionará isso à postagem).
Martin Ender

Respostas:

3

CJam, 79 70 bytes

Inspirado na resposta de nutki . Isso também garante que não haja espaços em branco à direita (exceto a segunda linha)

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

Use este link para copiar o código, pois o SE remove caracteres não imprimíveis.

Existem 5 caracteres no intervalo ASCII não imprimível, mas dentro de um byte (código ASCII 255)

Como funciona :

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

Experimente online aqui

Optimizer
fonte
16

Perl - 100 91 (incluindo 1 sinalizador)

Usa as idéias de nutki de usar -pe reduzir espaços duplos. Eliminação também simplificada dos espaços à direita.

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

A entrada vem do stdin e deve conter apenas o tipo de conector sem nova linha final.

Anterior:

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

Aceita um argumento de linha de 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
ido_nativo
fonte
2
Idéia engenhosa para manipular o parâmetro. Você ainda pode salvar 2 bytes adicionando $x=shift|" qb"e substituindo 3 ocorrências de espaço duplo por bno modelo. Também alterar o processamento de entrada para '-p' fornece 7 extras (menos o sinalizador): $x=$_|""e não há necessidade de final say.
nutki
@nutki - Obrigado, eu perdi isso!
gone_native
@ MartinBüttner - Todas as 3 linhas têm espaços à direita, embora eu tenha percebido que posso consertar a primeira e a terceira linhas facilmente convertendo o caractere final nessas linhas de xpara #. Mas a segunda linha ainda tem espaços à direita em todos os casos. Pois A, o espaço se estende além da final #das outras linhas (que eu suponho que seja tecnicamente permitido). Mas, para a I1, I2, etc. casos, ainda há um espaço à direita que precisa ser cuidado. Acho que posso jogar mais alguns personagens com isso.
gone_native
@gone_native oh, você está certo.
Martin Ender
9

Python, 168 caracteres

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

Parece ser uma nova abordagem. Eu tenho a string:

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

Substituo o G, He com 2base na entrada.

Claudiu
fonte
5

J, 153 121 119 caracteres

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

Uma terceira abordagem: agrupe todos os  'e #' em um número inteiro enorme como bits. Adicione os =depois. Ainda assim, não utiliza a simetria de muitas das variantes de conectores.

Desminificado 
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. <
Minificado (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.<

Também como uma função. Este usa uma codificação binária de comprimento variável, calculando as binárias e separando por zeros. 0 significa uma linha  , 1 significa #, 2 significa =, 3 significa nova linha e 4 significa separar as cinco cadeias uma da outra.

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

Marbelous, 281 bytes / caracteres

Minificado:

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

Isso leva D1, D2, I1, I2ou Aa partir de STDIN. Trailing newlines na entrada é opcional. A saída é para STDOUT.

Este programa chama sub-quadros que imprimem partes de conectores, preenchendo #s ou deixando espaços, dependendo das entradas.

Tente esta resposta aqui ; placas cilíndricas são necessárias.

com Comentários:

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 (incluindo 1 sinalizador)

Mais uma solução Perl. Usa stdin para o parâmetro

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

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

Saída:

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

J, 198194157 caracteres

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

Implementado como uma função. Observe que a função é um trem, o que significa que seria necessário cercá-la entre parênteses ou atribuí-la a um nome para usá-la (talvez eu deva contar os parênteses como parte da função, mesmo que tecnicamente não sejam).

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

A idéia é armazenar a parte comum da sequência separadamente dos caracteres que diferem entre os tipos de conectores. S1armazena os caracteres únicos e S2atua como um padrão x, atuando como espaços reservados para preencher.

FireFly
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

Editar Com 7 blocos básicos, use a base 7 da
maneira correta, usando a construção de strings com replace e 7 blocos de construção.
Saída para stdout usando alerta conforme solicitado pelo OP.
Agora vou tentar algumas micro-otimizações ...

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

Teste no console do FireFox / FireBug - removendo 'alerta' para simplificar o teste

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

Saída

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

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

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

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

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

Teste:

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

Mostrar snippet de código

O código é rápido e sujo, mas faz o trabalho. Principalmente, os #espaços e os espaços são colocados em binário e depois na base 36. Estou procurando uma solução mais elegante e, esperançosamente, mais curta.

NinjaBearMonkey
fonte
Quando clico em Executar o snippet de código , não vejo nada.
AL
Provavelmente porque usa as funções de seta do ECMAScript 6, que são suportadas apenas nas versões recentes do Firefox.
NinjaBearMonkey
Eu testei com a última versão do Firefox e nada acontece. Há algo a fazer para testar esta função?
AL
1
Oh, porque é apenas uma função. Vou adicionar uma maneira de testá-lo.
NinjaBearMonkey
você pode editar o código para torná-lo executável como um snippet (use um segundo bloco de código para manter o código original) ou remova o renderizador do snippet.
AL
1

Perl 5-150 (149 + 1 para n)

Golfe:

@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

Entrada de STDIN, saída para STDOUT. Funciona preenchendo determinados caracteres com #ou dependendo da entrada.

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