Pines del conector DVI

23

Se supone que este es un desafío de código de golf en el extremo más simple del espectro. Pero pensé que podría ser bueno sacar algo de micro-optimización aquí.

Hay tres tipos básicos de conectores DVI : DVI-A (analógico), DVI-D (digital) y DVI-I (integrado). Además, hay versiones de enlace simple y enlace doble de los conectores DVI-D y DVI-I. Cada uno de esos cinco conectores diferentes utiliza un conjunto diferente de pines.

Dada una de A, D1, D2, I1, I2como un identificador para el tipo de conector, imprimir la correspondiente representación ASCII de los terminales del conector:

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

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

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

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

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

(Las X:líneas no son parte de la salida, solo debe imprimir 3 líneas).

Puede escribir un programa o función, tomando entrada a través de STDIN, ARGV o argumento de función. La salida debe imprimirse en STDOUT, con un avance de línea final opcional.

Puede incluir o no espacios finales en la segunda línea del Aconector. No debe utilizar espacios iniciales o finales adicionales en ningún otro lugar.

Este es el código de golf, por lo que gana la respuesta más corta (en bytes).

code-golf ascii-art kolmogorov-complexity Martin Ender
fuente
¿Puedo requerir que la entrada esté entre comillas, por ejemplo, en "I1"lugar de I1?
Claudiu
¿Se permiten espacios finales en otras líneas?
gone_native
1
@ Claudiu No, lo siento.
Martin Ender
@gone_native También no, lo siento (lo agregaré a la publicación).
Martin Ender

Respuestas:

3

CJam, 79 70 bytes

Inspirado en la respuesta de nutki . Esto también asegura que no haya espacios en blanco al final (excepto la segunda línea)

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

Use este enlace para copiar el código ya que SE elimina los caracteres no imprimibles.

Hay 5 caracteres en el rango ASCII no imprimible pero dentro de un byte (código ASCII 255)

Cómo 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";

Pruébalo en línea aquí

Optimizador
fuente
16

Perl - 100 91 (incluyendo 1 bandera)

Utiliza las ideas de nutki de usar -py reducir espacios dobles. Eliminación también simplificada de espacios finales.

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

La entrada proviene de stdin y debe contener solo el tipo de conector sin nueva línea final.

Anterior:

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

Toma un argumento de línea de comandos. Sin golf:

# 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
fuente
2
Idea ingeniosa para manejar el parámetro. Todavía puede guardar 2 bytes agregando $x=shift|" qb"y reemplazando 3 ocurrencias de doble espacio con ben la plantilla. También cambiar el procesamiento de entrada a '-p' da 7 adicionales (menos el indicador): $x=$_|""y no es necesario el final say.
nutki
@nutki - ¡Gracias, me lo perdí!
gone_native
@ MartinBüttner: las 3 líneas tienen espacios finales, aunque me di cuenta de que puedo arreglar la primera y la tercera líneas fácilmente al convertir el carácter final en esas líneas de xa #. Pero la segunda línea todavía tiene espacios finales en todos los casos. Para A, el espacio se extiende más allá del final #de las otras líneas (que supongo que está técnicamente permitido). Pero para el I1, I2, etc. casos, todavía hay un espacio final que debe ser atendido. Sin embargo, creo que puedo jugar un par de personajes más.
gone_native
@gone_native oh, tienes razón.
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 un nuevo enfoque. Tengo la cadena:

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

Puedo reemplazar el G, Hy 2en base a la entrada.

Claudiu
fuente
5

J, 153121119 caracteres

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 tercer enfoque: empacar todos  y cada uno #en un número entero enorme como bits. Agregue el ='s después. Sin embargo, todavía no hace uso de la simetría de muchas de las variantes de conector.

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

También como una función. Éste usa una codificación binaria de longitud variable, al contar las que están en binario y separarlas por ceros. 0 unidades seguidas significa  , 1 una significa #, 2 unidades significa =, 3 unidades significa nueva línea y 4 unidades separan las cinco cadenas entre sí.

Sin golf 
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. <
Luciérnaga
fuente
4

Maravilloso, 281 bytes / caracteres

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

Esto lleva D1, D2, I1, I2o Ade STDIN. Las nuevas líneas finales en la entrada son opcionales. La salida es STDOUT.

Este programa llama a subpaneles que imprimen partes de conectores, rellenando #s o dejando espacios dependiendo de las entradas.

Prueba esta respuesta aquí ; Se necesitan tableros cilíndricos.

con comentarios:

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

Perl 5: 105 (incluyendo 1 bandera)

Otra solución más de Perl. Utiliza stdin para el parámetro.

#!perl -p
@x=map$_?'#':$",!/D/,-/2/,!/A/,1,0;$_='040 33311233
=====433311222
040 33211233';s/\d/$x[$&] /g;s/ $//mg
nutki
fuente
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/.*://

Salida:

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

J, 198194157 caracteres

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

Implementado como una función. Tenga en cuenta que la función es un tren, lo que significa que uno tendría que rodearla entre paréntesis o asignarle un nombre para usarla (tal vez debería contar los padres como parte de la función, aunque técnicamente no lo son).

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

La idea es almacenar la parte común de la cadena por separado de los caracteres que difieren entre los tipos de conector. S1almacena los caracteres únicos y S2actúa como un patrón con xlos que actúan como marcadores de posición para completar.

Luciérnaga
fuente
3

Pitón - 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
fuente
3

JavaScript (ES6) 178 186

Editar Teniendo 7 bloques de base, use la base 7 de
manera recta, usando la construcción de cadenas con reemplazo y 7 bloques de construcción.
Salida a stdout usando alerta según lo solicitado por OP.
Ahora intentaré algunas micro optimizaciones ...

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

Prueba en la consola FireFox / FireBug - eliminando 'alerta' para simplificar la prueba

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

Salida

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

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

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

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

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

Prueba:

      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
fuente
@ MartinBüttner: whoops, arreglado
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 fragmento de código

El código es rápido y sucio, pero hace el trabajo. En su mayoría, los #espacios y los espacios se colocan en binario y luego en base 36. Estoy buscando una solución más elegante y con suerte más corta.

NinjaOsoMono
fuente
Cuando hago clic en Ejecutar fragmento de código , no veo nada.
AL
Probablemente sea porque usa las funciones de flecha ECMAScript 6, que solo son compatibles con las versiones recientes de Firefox.
NinjaBearMonkey
Probé con la última versión de Firefox y no pasa nada. ¿Hay algo que hacer para probar esta función?
AL
1
Oh, eso es porque es solo una función. Agregaré una forma de probarlo.
NinjaBearMonkey
puede editar el código para que sea ejecutable como un fragmento (use un segundo bloque de código para mantener el código original) o elimine el procesador de fragmentos.
AL
1

Perl 5 - 150 (149 + 1 para n)

Golfizado:

@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, salida a STDOUT. Funciona rellenando ciertos caracteres con #o dependiendo de la entrada.

Sin golf:

@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
fuente