Broches de connecteur DVI

23

Ceci est censé être un défi de golf de code à l'extrémité la plus simple du spectre. Mais je pensais que ce serait bien de faire ressortir une micro-optimisation ici.

Il existe trois types de connecteurs DVI de base : DVI-A (analogique), DVI-D (numérique) et DVI-I (intégré). De plus, il existe des versions à liaison simple et à double liaison des connecteurs DVI-D et DVI-I. Chacun de ces cinq connecteurs différents utilise un jeu de broches différent.

Compte tenu de l' un des A, D1, D2, I1, I2comme identificateur pour le type de connecteur, imprimer la représentation ASCII correspondant des broches du connecteur:

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

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

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

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

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

(Les X:lignes ne font pas partie de la sortie, vous ne devez imprimer que 3 lignes.)

Vous pouvez écrire un programme ou une fonction, en prenant une entrée via STDIN, ARGV ou un argument de fonction. La sortie doit être imprimée sur STDOUT, avec un saut de ligne en option.

Vous pouvez ou non inclure des espaces de fin dans la deuxième ligne du Aconnecteur. Vous ne devez pas utiliser d’ espaces de début ou de fin supplémentaires ailleurs.

Il s'agit du code golf, donc la réponse la plus courte (en octets) l'emporte.

code-golf  ascii-art  kolmogorov-complexity 
— Martin Ender
source
Puis-je exiger que les entrées soient entourées de guillemets, par exemple "I1"au lieu de I1?
— Claudiu
Les espaces de fin sur d'autres lignes sont-ils autorisés?
— gone_native
1
@Claudiu Nope, désolé.
— Martin Ender
@gone_native Aussi non, désolé (ajoutera cela au message).
— Martin Ender

Réponses:

3

CJam, 79 70 octets

Inspiré de la réponse de Nutki . Cela garantit également qu'il n'y a pas d'espaces blancs à la fin (sauf pour la deuxième ligne)

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

Utilisation ce lien pour copier le code pendant que SE supprime les caractères non imprimables.

Il y a 5 caractères dans la plage ASCII non imprimable mais bien dans un octet (code ASCII 255)

Comment ça marche :

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

Essayez-le en ligne ici

— Optimiseur
source
16

Perl - 100 91 (dont 1 drapeau)

Utilise les idées d'utilisation de nutki -p et de réduire les espaces doubles. Élimination également simplifiée des espaces de fuite.

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

L'entrée provient de stdin et doit contenir uniquement le type de connecteur sans nouvelle ligne de fin.

Précédent:

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

Prend un argument de ligne de commande. Non 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
— gone_native
source
2
Idée ingénieuse pour gérer le paramètre. Vous pouvez toujours enregistrer 2 octets en ajoutant $x=shift|" qb"et en remplaçant 3 occurrences d'espace double avec bdans le modèle. Changer également le traitement d'entrée en «-p» donne 7 supplémentaires (moins l'indicateur): $x=$_|""et pas besoin de final say.
— nutki
@nutki - Merci, j'ai raté ça!
— gone_native
@ MartinBüttner - Les 3 lignes ont des espaces de fin, bien que je me sois rendu compte que je peux réparer les première et troisième lignes facilement en convertissant le caractère final dans ces lignes de xà #. Mais la deuxième ligne a toujours des espaces de fin dans tous les cas. Car A, l'espace s'étend au-delà de la finale #des autres lignes (ce qui, je suppose, est techniquement autorisé). Mais pour le I1, I2, etc. Dans certains cas, il reste un espace de fuite qui doit être pris en charge. Je pense que je peux jouer au golf avec quelques personnages supplémentaires.
— gone_native
@gone_native oh, vous avez raison.
— Martin Ender
9

Python, 168 caractères

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

Semble être une nouvelle approche. J'ai la chaîne:

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

Je remplace le G, Het 2basé sur l'entrée.

— Claudiu
source
5

J, 153 121 119 caractères

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

Une troisième approche: regrouper tous les  'et #' dans un énorme entier sous forme de bits. Ajouter le= s par la suite. Cependant, ne fait toujours pas usage de la symétrie de la plupart des variantes de connecteurs.

Non minifié 
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. <
Minifié (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.<

Aussi en fonction. Celui-ci utilise un codage binaire de longueur variable, en comptant ceux en binaire et en les séparant par des zéros. 0 un dans une rangée signifie  , 1 un signifie #, 2 un signifie= , 3 uns signifie nouvelle ligne et 4 uns séparent les cinq chaînes les unes des autres.

Non 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. <
— Luciole
source
4

Marbelous, 281 octets / caractères

Minifié:

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

Cela prend D1, D2, I1,I2 ou Ade STDIN. Les sauts de ligne en entrée sont facultatifs. La sortie est vers STDOUT.

Ce programme appelle des sous-cartes qui impriment des parties de connecteurs, soit en remplissant # s ou en laissant des espaces en fonction des entrées.

Essayez cette réponse ici ; des planches cylindriques sont nécessaires.

avec commentaires:

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

Perl 5: 105 (dont 1 drapeau)

Encore une autre solution Perl. Utilise stdin pour le paramètre.

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

GNU sed, 116 octets

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

Sortie:

$ echo "A
D1
D2
I1
I2"|sed -f dvi.sed
#   #   # # #       # #
=====   # # #          
#   #   # #         # #
        # # #     # # #
=====   # # #     # # #
        # # #     # # #
        # # # # # # # #
=====   # # # # # # # #
        # # # # # # # #
#   #   # # #     # # #
=====   # # #     # # #
#   #   # # #     # # #
#   #   # # # # # # # #
=====   # # # # # # # #
#   #   # # # # # # # #
$
— Traumatisme numérique
source
3

J, 198 194 157 caractères

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

Mis en œuvre en tant que fonction. Notez que la fonction est un train, ce qui signifie qu'il faudrait l'entourer de parenthèses ou l'attribuer à un nom pour l'utiliser (peut-être devrais-je compter les parens dans le cadre de la fonction, même si techniquement ils ne le sont pas).

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

L'idée est de stocker la partie commune de la chaîne séparément des caractères qui diffèrent entre les types de connecteurs. S1stocke les caractères uniques et S2agit comme un modèle avec x's agissant comme des espaces réservés à remplir.

— Luciole
source
3

Python - 167 166 164 161 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
source
3

JavaScript (ES6) 178 186

Modifier Ayant 7 blocs de base, utilisez la base 7 de
façon directe, en utilisant la construction de chaînes avec replace et 7 blocs de construction.
Sortie vers stdout en utilisant une alerte comme demandé par OP.
Je vais maintenant essayer quelques micro-optimisations ...

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

Tester dans la console FireFox / FireBug - supprimer «alerte» pour simplifier le test

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

Sortie

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

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

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

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

#   #  # # # # # # # #
=====  # # # # # # # #
#   #  # # # # # # # #
— edc65
source
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

Tester:

      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
source
@ MartinBüttner: whoops, fixe
— marinus
2

JavScript ES6, 186 octets

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

Afficher l'extrait de code

Le code est rapide et sale, mais il fait le travail. Généralement, les #et les espaces sont mis en binaire puis en base 36. Je cherche une solution plus élégante et, espérons-le, plus courte.

— NinjaBearMonkey
source
Lorsque je clique sur Exécuter l'extrait de code, je ne vois rien.
— AL
C'est probablement parce qu'il utilise les fonctions de flèche ECMAScript 6, qui ne sont prises en charge que dans les versions récentes de Firefox.
— NinjaBearMonkey
J'ai testé avec la dernière version de Firefox et rien ne se passe. Y a-t-il quelque chose à faire pour tester cette fonction?
— AL
1
Oh, c'est parce que ce n'est qu'une fonction. Je vais ajouter un moyen de le tester.
— NinjaBearMonkey
vous pouvez modifier le code pour le rendre exécutable en tant qu'extrait (utilisez un deuxième bloc de code pour conserver le code d'origine) ou supprimez le rendu d'extrait.
— AL
1

Perl 5-150 (149 + 1 pour n )

Golfé:

@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

Entrée depuis STDIN, sortie vers STDOUT. Fonctionne en remplissant certains caractères avec# ou fonction de l'entrée.

Non 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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.