Mon tout premier programme de puzzles de programmation et de golf de code est l' affichage à sept barres obliques . Voici mon premier défi, également basé sur un affichage à 7 segments.

En plus des chiffres, je pense souvent au type de lettres que je peux afficher à l'aide d'un simple affichage à 7 segments. Il s'avère que beaucoup de lettres peuvent être affichées. En fait, toutes les lettres sauf les lettres K, M, V, W, X peuvent être affichées à l'aide d'un seul affichage à 7 segments. En effet, vous pouvez afficher les minuscules ou les majuscules d'une lettre. par exemple

"abcdef" peut être affiché comme

 _     _     _  _
!_!!_ !   _!!_ !_ 
! !!_!!_ !_!!_ !  

Notez que chaque caractère est une matrice 3x3 composée de !et _.

Bien sûr, l'affichage à 7 segments peut être utilisé pour afficher des chiffres et des symboles:

 _     _  _  _           _  _     _    
  ! _ !_ !_ !      _!  !!_ !_!!  !_!!_!
  !    _!!_ !_!   !_!  ! _!!  !_ ! ! _!

Certaines lettres peuvent avoir des majuscules et des minuscules:

 _                 _          
!   _ !_!!_   !   ! ! _ ! !   
!_ !_ ! !! !  !  !!_!!_!!_!!_!

Voici l'ensemble complet des personnages:

 _     _  _     _  _  _  _  _                       _
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !  

 _     _     _  _  _                 _  _  _     _           _ 
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! !!_! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_! _!!_ 

Faites attention à la présence d'un espace blanc ( ), d'un tiret ( -) et d'un point d'interrogation ( ?). La lettre I, Oet Zsont les mêmes que les numéros 1, 0et 2respectivement.

Dans ce défi, vous allez écrire un programme ou une fonction pour afficher une chaîne en utilisant le format d'affichage à 7 segments ci-dessus.

Règles

1. Vous pouvez écrire un programme ou une fonction

2. C'est le code-golf, le code le plus court en octets gagne

3. Votre programme ou fonction doit recevoir des données de STDIN ou en tant que paramètre. Et génère une chaîne vers STDOUT ou sous forme de chaîne sur 3 lignes sans espace de début mais terminée par un saut de ligne. Manipulez CHIOUcorrectement le boîtier supérieur / inférieur .

4. Vous pouvez éventuellement imprimer des espaces blancs à la fin

5. Vous devez suivre le format ci-dessus. Utilisation du trait de soulignement _et du point d'exclamation !pour former votre affichage à 7 segments.

6. Vous devez prendre en charge les espaces blancs ( ), les tirets ( -) et les points d'interrogation ( ?)

7. Si la chaîne contient des caractères non pris en charge (k, m, v, w, x), un seul caractère d'erreur (3 ligne d'horizon, voir exemple) s'affiche. Outre les 5 caractères non pris en charge, vous pouvez supposer que l'entrée est composée uniquement d'un jeu de caractères pris en charge.

8. J'ai choisi de ne pas avoir de lettre pour L ( l) minuscule en raison de confusions mais si vous êtes si enclin, vous pouvez l'afficher comme un 1à droite ou à gauche.

Exemples

$./a.out Start
 _     _    
!_ !_ !_! _ !_
 _!!_ ! !!  !_
$./a.out "7-seg dIsplay"
 _     _  _  _           _  _     _ 
  ! _ !_ !_ !      _!  !!_ !_!!  !_!!_!
  !    _!!_ !_!   !_!  ! _!!  !_ ! ! _!
$./a.out "0123456789 chiou-?"
 _     _  _     _  _  _  _  _                       _
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !
$./a.out "ABCDEFGHIJLNOPQRSTUZ"
 _     _     _  _  _                 _  _  _     _        _
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! ! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_!!_
$./a.out "abcdefghijlnopqrstuz"
 _           _  _  _                    _  _     _        _
!_!!_  _  _!!_ !_ !  !_      !!   _  _ !_!!_! _ !_ !_     _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_!!_
$./a.out "Bad Form"
 _
 _
 _
$./a.out "Hello"
    _       
!_!!_ !  !   _
! !!_ !_ !_ !_!
$./a.out "World"
 _
 _
 _

CJAM, 123 114 112 110 octets

Qq_eu";=KMVWX":T&"@"@?" -chiou"Tereu{i"^A^W^G;^Þ¯     ^Þ^Û9³·^É¿»
^@
^P
^Ü^Ò½7¦^_¶´§=   ^O^V&5^U¯¼¹^T³6/"=i2b9Ue[3/"!_!"f.{S?}.+}/N*

Ce qui précède utilise la notation caret, car le code contient des caractères non imprimables. L'un d'eux est un octet nul ( ^@), ce qui signifie que ce code ne peut être exécuté qu'à partir de la ligne de commande.

Au prix de seulement deux octets supplémentaires (pour un total de 112 ), nous pouvons résoudre ce problème.

Qq_eu";=KMVWX":T&"@"@?" -chiou"Tereu{i"AWG{ÞïIÞÛyó÷Éÿû
@
P
ÜÒýwæ_öôç}IOVfuUïüùTóvo"=i448+2b1>3/"!_!"f.{S?}.+}/N*

Cette fois, tous les caractères sont imprimables. Essayez-le en ligne dans l' interpréteur CJam .

Exemple d'exécution

$ LANG=en_US
$ xxd -ps -r > 7seg.cjam <<< 51715f6575223b3d4b4d565758223a5426224022403f22202d6368696f752254657265757b69220117073b9eaf099e9b39b3b789bfbb0a000a100a9c92bd37a61fb6b4a73d090f16263515afbcb914b3362f223d6932623955655b332f22215f2122662e7b533f7d2e2b7d2f4e2a
$ wc -c 7seg.cjam 
110 7seg.cjam
$ echo -n '0123456789 chiou-?' | cjam 7seg.cjam; echo
 _     _  _     _  _  _  _  _                       _ 
! !  ! _! _!!_!!_ !_   !!_!!_!    _ !_     _     _  _!
!_!  !!_  _!  ! _!!_!  !!_! _!   !_ ! !  !!_!!_!   !  
$ echo -n 'ABCDEFGHIJLNOPQRSTUYZ' | cjam 7seg.cjam; echo
 _     _     _  _  _                 _  _  _     _           _ 
!_!!_ !   _!!_ !_ !  !_!  !  !!   _ ! !!_!!_! _ !_ !_ ! !!_! _!
! !!_!!_ !_!!_ !  !_!! !  !!_!!_ ! !!_!!    !!   _!!_ !_! _!!_ 
$ echo -n 'World' | cjam 7seg.cjam; echo
 _ 
 _ 
 _

Idée (version imprimable)

Chaque caractère peut être affiché sur l'affichage à 9 segments

!_!
!_!
!_!

en remplaçant certains de ses caractères par des espaces.

Nous pouvons transformer un caractère spécifique en un entier en remplaçant chaque segment affiché, dans l'ordre de lecture naturel, par un 1 , chaque segment non affiché par un 0 et en considérant les chiffres binaires résultants.

Le premier et le troisième segment ne sont jamais affichés, cela produira donc des entiers dans les plages [0,64) et [128,192) .

Nous pouvons coder chacun de ces entiers comme un seul octet, mais la moitié d'entre eux entraînera des caractères non imprimables. Ainsi, nous ajoutons 64 à chaque entier avant de transtyper en caractère, ce qui garantit que les points de code sont dans les plages [64,128) et [192,256) .

Le seul caractère non imprimable dans ces deux plages est DEL (point de code 127), ce qui correspond à la configuration d'affichage suivante, non validée:

!_!
!_!

Nous pouvons inverser le codage ci-dessus en ajoutant 448 == 512 - 64 à chaque point de code, en convertissant en base 2 et en supprimant le premier chiffre binaire.

Il ne reste plus qu'à trouver un moyen efficace d'associer ces segmenets encodés à leurs caractères ASCII correspondants.

Si nous mappons les caractères de " -chiou"aux caractères de ";=KMVWX"et convertissons l'intégralité de l'entrée en majuscules, nous pouvons simplement stocker le codage pour tous les caractères entre 0(point de code 48) et Z(point de code 90), ce qui donne une plage de 43.

L'indexation des tableaux est modulaire dans CJam, donc si Aest une chaîne de longueur 43 A86=, A43=et A0=tous donnent les mêmes résultats. Le caractère avec le point de code 86 est V, donc nous stockons simplement les segments codés de V - Z et 0 - U , dans l'ordre.

Dans le code réel, nous sélectionnons le signe at comme caractère "de mauvaise forme", remplaçons l'entrée entière par la chaîne "@"si elle contient une lettre interdite et inversons les étapes ci-dessus.

Code (version imprimable)

Q            e# Push an empty array for posterior concatenation.
q            e# Read from STDIN.
_eu          e# Copy the input and convert is to uppercase.
";=KMVWX":T& e# Intersect the result with with T := ";=KMVWX".
"@"@?        e# Select "@" if truthy and the input if falsy.
" -chiou"Ter e# Perform transliteration.
eu           e# Convert everything to uppercase.
{            e# For each character in the modified input:
  i          e#   Push its code point.
  "…"=       e#   Select the corresponding character from the string.
  i448+      e#   Push that character's code point and add 448.
  2b1>       e#   Convert to base 2 and discard the first digit.
  3/         e#   Group into triplets of digits (rows).
  "!_!"      e#   Push that string.
  f.{        e#   For each group of digits:
    S?       e#     Select the corresponding char of "!_!" for 1 and " " for 0.
  }          e#
  .+         e#   Concatenate along the rows with the previous results.
}/           e#
N*           e# Join, separating by linefeeds.

Perl, 475 469 424 390 280 272 octets

$_=<>;die" -
"x3if/[kmvwx]/i;y/chiou/kmvwx/;$_=lc;while(/(.)/g){$z=ord($1=~y/a-z0-9\-\? /{v\x17nWS7z(.F\x16rb?[yBuV> f&|O?(Omxuw)\x7f}@K\0/r);$i.=$z&1?' _ ':$"x3;$m.=($z&16?'!':$").($z&64?'_':$").($z&8?'!':$");$p.=substr("  !  _!_",$z&6,2).($z&32?'!':$")}print"$i
$m
$p
"

multiligne avec commentaires:

$_=<>;   # accept input
die" -   # check for invalid chars
"x3if/[kmvwx]/i;
y/chiou/kmvwx/;$_=lc;   # substitute invalid chars, convert to lowercase
while(/(.)/g)   # loop over each character
    # lookup character from string using transliteration and convert to
    # number using ord() for bit checking:
    {$z=ord($1=~y/a-z0-9\-\? /{v\x17nWS7z(.F\x16rb?[yBuV> f&|O?(Omxuw)\x7f}@K\0/r);
    $i.=$z&1?' _ ':$"x3;    # first row
    $m.=($z&16?'!':$").($z&64?'_':$").($z&8?'!':$");   # second row
    $p.=substr("  !  _!_",$z&6,2).($z&32?'!':$")}    # third row
# print result:
print"$i
$m
$p
"

Les modèles de bits codant les segments sont stockés dans une chaîne (échappant à 3 caractères non imprimables utilisant \xet utilisant \0pour l'espace) et sont mappés aux caractères d'entrée à l'aide de l'opérateur de translittération Perl.

Pour 5 des 7 segments, un bit et est utilisé avec l'opérateur ternaire pour sortir un espace ou le caractère de segment. Pour les deux segments en bas à gauche (codés par 2 et 4 dans le jeu de bits), une recherche de sous-chaîne dans une chaîne de 8 caractères est utilisée pour enregistrer 2 octets.

Merci à Dom Hastings pour ses conseils de golf Perl.

Ancienne version (utilisant des expressions rationnelles pour coder les modèles), 390 octets:

$_=<>;if(/[kmvwx]/i){print" -\n"x3;exit}y/chiou/kmvwx/;$_=lc;while(/(.)/g){$z=$1;$i.=($z=~/[acefgopqsz\?0235-9]/?' _ ':'   ');$m.=($z=~/[abce-hlmopqstuy045689]/?'!':' ').($z=~/[abdefhkmnp-twyz\-\?2-689]/?'_':' ').($z=~/[adhijopquyz\?0-4789]/?'!':' ');$p.=($z=~/[a-hj-prtuwxz\?0268]/?'!':' ').($z=~/[b-egjklostuw-z0235689]/?'_':' ').($z=~/[abdg-jmnoqsu-y013-9]/?'!':' ')}print"$i\n$m\n$p\n"

multiligne avec commentaires:

$_=<>;   # accept input
if(/[kmvwx]/i){print" -\n"x3;exit}   # check for invalid chars
y/chiou/kmvwx/;$_=lc;   # substitute invalid chars, convert to lowercase
while(/(.)/g)
{$z=$1;$i.=($z=~/[acefgopqsz\?0235-9]/?' _ ':'   '); # first row
$m.=($z=~/[abce-hlmopqstuy045689]/?'!':' ').
($z=~/[abdefhkmnp-twyz\-\?2-689]/?'_':' ').
($z=~/[adhijopquyz\?0-4789]/?'!':' '); # second row
$p.=($z=~/[a-hj-prtuwxz\?0268]/?'!':' ').
($z=~/[b-egjklostuw-z0235689]/?'_':' ').
($z=~/[abdg-jmnoqsu-y013-9]/?'!':' ')} # third row
print"$i\n$m\n$p\n" # print result

La chaîne est lue et vérifiée pour les caractères non valides à l'aide d'une expression régulière, se fermant si aucun n'est trouvé. Ensuite, les caractères minuscules autorisés sont remplacés par les caractères non valides et la chaîne entière est convertie en minuscules.

Les lignes sont générées une à la fois, avec 1 segment par lettre sur la première ligne et 3 sur les deux autres. Pour chaque ligne, la chaîne est traitée un caractère à la fois et le caractère est comparé à une expression régulière pour chaque segment pour vérifier si un! ou _ doit être affiché. L'utilisation d'une expression régulière signifie que pour les caractères où le segment n'est pas défini, il faut zéro bit par segment par caractère pour coder s'il faut le définir, et pour ceux où il l'est, cela prend un peu moins de 8 bits en moyenne car les plages de caractères d'expression régulière peuvent être utilisé. Cela représente donc environ 3 ou 4 bits par segment par caractère dans l'ensemble, ou environ 21-24 bits par caractère.

Il ne gère pas le retour à la ligne.

Lisp commun, 488 416

(lambda(z)(dotimes(r 3)(map()(lambda(c)(do((i 0(+ 17 i))n)((or(and(> i 901)(setf n 146))(=(char-code c)(ldb(byte 8 9)(setf n(ldb(byte 17 i)#36RIL884OIVFXJY4DCQ0O8DPH8MOMR2DSLPP3O4ESYHS234A9HEQYSV8IBDBZI6Z3C3MCVR77OYD3QN5G6CX2UQWGL4UY5R9PKYI1JQ5Y6DC27MQQGUZSCGI8Q9JCYP9N1L4YYKRWM1ZNMSVTSB4792UUWV6Z3906VSP981WCCBMDNJ02)))))(loop for v from(* 3 r)for d across"!_!"do(format t"~:[ ~;~A~]"(logbitp v n)d)))))z)(terpri)))

Exemple

Avec "abcdefg'hijklnopqrstuz", imprime:

 _           _  _  _  _           _           _  _     _        _ 
!_!!_  _  _!!_ !_ !   _ !_   !  ! _ !   _  _ !_!!_! _ !_ !_     _!
! !!_!!_ !_!!_ !  !_! _ ! !  !!_! _ !_ ! !!_!!    !!   _!!_ !_!!_ 

Remarques

Les caractères et leurs représentations sont encodés dans ce numéro en base 36:

IL884OIVFXJY4DCQ0O8DPH8MOMR2DSLPP3O4ESYHS234A9HEQYSV8IBDBZI6Z3C3MCVR77OYD3QN5G6CX2UQWGL4UY5R9PKYI1JQ5Y6DC27MQQGUZSCGI8Q9JCYP9N1L4YYKRWM1ZNMSVTSB4792UUWV6Z3906VSP981WCCBMDNJ02

La représentation binaire de ce chiffre est divisée en groupes de 17 bits.

Par exemple, le dernier groupe de 17 bits est 110000111101010 , qui est décomposé ici en deux parties:

1. 110000, le char-code de caractère 0

2. 111101010, un codage du dessin, mieux représenté comme suit:

   010 (bits 0-2)         _ 
   101 (bits 3-5)   =>   ! !
   111 (bits 6-8)        !_!
   

   Les bits dans la première et la dernière "colonne" sont pour les !caractères, ceux dans la colonne du milieu pour le_ caractère. Si nécessaire, les versions majuscules et downcase d'un caractère sont stockées.

La fonction parcourt trois fois la chaîne d'entrée, une pour chaque ligne de sortie, recherche un caractère correspondant dans le tableau (ou par défaut 146, alias trois barres) et imprime la représentation à la ligne actuelle.

JavaScript (ES6), 380 352 324 octets

( Remarque: le code utilise la notation caret, car il contient des caractères non imprimables. Pour obtenir le code original, cliquez ici et sélectionnez les données brutes. Et non, ce hn'est pas un programme CJam.;)

d=s=>{a=' ',u=n=>r>>n&1?'!':a,v=n=>r>>n&1?'_':a,g='ABCDEFGHIJLNOPQRSTUYZabcdefghijlnopqrstuyz0123456789-? ÿ',h='{vUnWSuz(lTb}[;B7V|>O{vFnWSur lTbf[;B7Vd>O}(O/:7w)^??^BK^0^G',x=y=z='';for(i=0;i<s.length;x+=a+v(0)+a,y+=u(4)+v(1)+u(3),z+=u(6)+v(2)+u(5)){q=g.indexOf(s[i++]);if(q<0)return d`ÿ`;r=h.charCodeAt(q)}return x+`
${y}
`+z}

Appelé comme d("7-seg display")ou similaire. Fonctionne dans Firefox 40, mais peut-être pas dans d'autres navigateurs. Pour une raison quelconque, l'extrait HTML / JS n'enregistre pas les éléments non imprimables, mais vous pouvez copier-coller les données brutes d' ici .

Non golfé:

( Note: g et hont été complétées par des espaces pour correspondre 8, -, ÿet spaceavec leurs valeurs Unicode correspondantes.)

d = function (s) {
  t = function (n) { return Math.floor(n) % 2; };
  g = 'ABCDEFGHIJLNOPQRSTUYZabcdefghijlnopqrstuyz012345679? 8      -      ÿ      space ';
  h = '{vUnWSuz(lTb}[;B7V|>O{vFnWSur lTbf[;B7Vd>O}(O/:7w)?K \u007f \u0002 \u0007 \u0000';
  x = y = z = '';
  for(var i = 0; i < s.length; i++) {
    q = g.indexOf(s.charAt(i));
    if (q < 0)          // if g does not contain the character
      return d('ÿ');    // ÿ is equivalent to the error character, '\u0007'
    r = h.charCodeAt(q);
    x += ' ' + (r % 2 === 1 ? '_' : ' ') + ' ';
    y += (t(r / 16) === 1 ? '!' : ' ') + (t(r / 2) === 1 ? '_' : ' ') + (t(r / 8) === 1 ? '!' : ' ');
    z += (t(r / 64) === 1 ? '!' : ' ') + (t(r / 4) === 1 ? '_' : ' ') + (t(r / 32) === 1 ? '!' : ' ');
  }
  return x + '\n' + y + '\n' + z;
}

Explication:

J'ai tout de suite remarqué que les 7 segments, convertis en 0/1 bits, iraient bien avec les 128 premiers caractères Unicode. Le problème avec cette idée est que 1/4 de ces caractères sont des caractères de contrôle non imprimables. Les utiliser dans mon code donnerait un aspect incroyablement désordonné (ou incroyablement intelligent; je n'ai pas décidé lequel). Pour résoudre ce problème tout en gardant le reste du code simple, j'ai eu cette idée:

A l'exception de -, l' espace , et l' erreur , aucun des personnages , il manquait les deux segments verticaux inférieurs. Donc, pour m'assurer que tous ces caractères sont restés entre 0020et 007f, j'ai simplement mappé les 64 et 32 bits à ces segments, comme ceci:

     1
    ---
16 |   | 8
  2 ---
64 |   | 32
    ---
     4

Les numéros des 5 autres segments ne sont pas trop importants; ils pourraient être arrangés de toute autre manière et avoir toujours les mêmes caractères "entrants".

À titre d'exemple, voici la version codée de A :

     1
    ---
16 |   | 8
  2 ---
64 |   | 32

Dec: 64 + 32 + 16 + 8 + 2 + 1 = 123
Hex: 40 + 20 + 10 + 8 + 2 + 1 = 7B = u+007B = {

J'ai ensuite bourré la version codée de chaque caractère à 7 segments h. Cependant, il en est 8résulté 007f(le code de contrôle de suppression ; constant, peu importe la façon dont les segments sont disposés), l' espace a entraîné 0000(le code nul ; également constant), il en est -résulté 0002et une erreur s'est produite 0007. Je copie-collé les octets bruts dans la position correcte pour 8, -et l' erreur ; l'espace a été facilement atteint avec \0.

Après tout cet encodage, tout ce que j'avais à faire était de l'utiliser pour décoder la chaîne et la sortir dans un format lisible en 7 segments. J'utilisé un de boucle et trois variables ( x, y, et z, chacun correspondant à une ligne de sortie) de passer par chaque caractère dans la chaîne de caractères et ajouter l'équivalent de 7-seg à la sortie. J'ai choisi ÿle caractère d' erreur car AFAIK, ce n'est sur aucun clavier et c'est le dernier caractère de la u+0000-u+00ffgamme. J'aurais peut-être pu être Ξplutôt spirituel et choisi (lettre grecque xi) à la place ....;)

Edit 1: sauvé un tas d'espace en créant des mini-fonctions pour déterminer si !, _ou est nécessaire.

Edit 2: économisé beaucoup d'espace en utilisant les astuces que j'ai apprises depuis ma dernière visite sur ce post.

Comme d'habitude, les suggestions sont grandement appréciées!