Mostrar palabras usando la pantalla de 7 segmentos

13

Mi primer Puzzles de programación y Golf de código es la pantalla Seven-Slash . Aquí está mi primer desafío, también basado en una pantalla de 7 segmentos.

A menudo pienso, además de los números, en qué tipo de letras puedo mostrar usando una pantalla simple de 7 segmentos. Resulta que se pueden mostrar muchas letras. De hecho, todas menos las letras K, M, V, W, X se pueden mostrar usando una sola pantalla de 7 segmentos. Esto se debe a que puede mostrar minúsculas o mayúsculas de una letra. p.ej

"abcdef" se puede mostrar como

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

Tenga en cuenta que cada carácter es una matriz 3x3 compuesta por !y _.

Por supuesto, la pantalla de 7 segmentos se puede usar para mostrar números y símbolos:

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

Algunas letras pueden tener mayúsculas y minúsculas:

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

Aquí está el conjunto completo de personajes:

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

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

Tenga en cuenta que hay un espacio en blanco ( ), un guión ( -) y un signo de interrogación ( ?). La carta I, OyZ son los mismos que los números 1, 0y 2respectivamente.

En este desafío, escribirá un programa o una función para mostrar una cadena usando el formato de visualización de 7 segmentos anterior.

Reglas

  1. Puedes escribir un programa o una función

  2. Este es el código de golf, gana el código más corto en bytes

  3. Su programa o función debe recibir información de STDIN o como parámetro. Y genera una cadena en STDOUT o como una cadena en 3 líneas sin espacios iniciales pero terminada con nueva línea. Manejar mayúsculas / minúsculas deCHIOU correctamente.

  4. Opcionalmente, puede imprimir espacios en blanco al final

  5. Debe seguir el formato anterior. Usando guión bajo _y signo de exclamación! para formar su pantalla de 7 segmentos.

  6. Debe admitir espacios en blanco ( ), guión ( -) y signo de interrogación ( ?)

  7. Si la cadena contiene caracteres no admitidos (k, m, v, w, x), se muestra un solo carácter de error (línea de 3 horizontes, ver ejemplo). Además de los 5 caracteres no admitidos, puede suponer que la entrada está compuesta solo por un conjunto de caracteres admitidos.

  8. Opté por no tener una letra para L minúscula ( l) debido a confusiones, pero si está tan inclinado, puede mostrarla como 1a la derecha o a la izquierda.

Ejemplos

$./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"
 _
 _
 _
code-golf ascii-art algun usuario
fuente
Sí, puede suponer que no hay símbolos no compatibles. Mi intención es asegurarme de que las cadenas que contienen k, m, v, w, xno se muestren.
algún usuario
1
Relacionado: codegolf.stackexchange.com/questions/9266/…
DavidC
Creo que confundió el retorno de carro (CR \r) con el avance de línea (LF, \n). * nix usa LF y Windows usa CRLF. Solo ciertos sistemas heredados usan CR por sí mismo. Más información aquí: en.wikipedia.org/wiki/Newline
Winny
Tu personaje "8" parece tener una barra "|" en lugar de un signo de exclamación "!". ¿Está destinado?
coredump
1
@ Winny, tienes razón, por supuesto. Era demasiado vago para buscarlo cuando lo escribí.
algún usuario

Respuestas:

7

CJAM, 123 114 112 110 bytes

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

Lo anterior usa notación de intercalación, ya que el código contiene caracteres no imprimibles. Uno de ellos es un byte nulo ( ^@), lo que significa que este código solo se puede ejecutar desde la línea de comandos.

A costa de solo dos bytes más (para un total de 112 ), podemos solucionar esto.

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

Esta vez, todos los personajes son imprimibles. Pruébelo en línea en intérprete de CJam .

Ejecución de ejemplo

$ 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
 _ 
 _ 
 _

Idea (versión imprimible)

Cada personaje se puede mostrar en la pantalla de 9 segmentos

!_!
!_!
!_!

mediante la sustitución de algunos de sus personajes personajes con espacios.

Podemos convertir un carácter específico en un entero reemplazando cada segmento mostrado, en orden de lectura natural, con un 1 , cada segmento no mostrado con un 0 y considerando los dígitos binarios resultantes.

El primer y el tercer segmento nunca se muestran, por lo que esto producirá números enteros en los rangos [0,64) y [128,192) .

Podemos codificar cada uno de estos enteros como un solo byte, pero la mitad dará como resultado caracteres no imprimibles. Por lo tanto, agregamos 64 a cada número entero antes de convertirlos en caracteres, lo que garantiza que los puntos de código estén en los rangos [64,128) y [192,256) .

El único carácter no imprimible en estos dos rangos es DEL (punto de código 127), que corresponde a la siguiente configuración de visualización no utilizada:

!_!
!_!

Podemos revertir la codificación anterior agregando 448 == 512 - 64 a cada punto de código, convirtiendo a la base 2 y eliminando el primer dígito binario.

Todo lo que queda por encontrar es una manera eficiente de asociar estos segmenets codificados con sus caracteres ASCII correspondientes.

Si asignamos los caracteres de " -chiou"a los caracteres de ";=KMVWX"y convertimos toda la entrada a mayúsculas, simplemente podemos almacenar la codificación para todos los caracteres entre 0(punto de código 48) y Z(punto de código 90), dando un rango de 43.

La indexación de matriz es modular en CJam, por lo que si Aes una cadena de longitud 43 A86=, A43=y A0=todos producen los mismos resultados. El carácter con el punto de código 86 es V, por lo que simplemente almacenamos los segmentos codificados de V - Z y 0 - U , en orden.

En el código real, seleccionamos el signo at como carácter de "forma incorrecta", reemplazamos toda la entrada con la cadena "@"si contiene una letra prohibida e invierte los pasos de arriba.

Código (versión imprimible)

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.
Dennis
fuente
2

Perl, 475 469 424 390 280 272 bytes

$_=<>;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
"

multilínea con comentarios:

$_=<>;   # 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
"

Los patrones de bits que codifican los segmentos se almacenan en una cadena (escapando de 3 caracteres no imprimibles usando \xy usando \0para el espacio) y se asignan a los caracteres de entrada usando el operador de transliteración Perl.

Para 5 de los 7 segmentos, un bit a bit y se usa junto con el operador ternario para generar un espacio o el carácter del segmento. Para los dos segmentos inferiores a la izquierda (codificados por 2 y 4 en el conjunto de bits), se utiliza una búsqueda de subcadenas en una cadena de 8 caracteres para guardar 2 bytes.

Gracias a Dom Hastings por sus consejos de golf de Perl.

Versión anterior (usando expresiones regulares para codificar los patrones), 390 bytes:

$_=<>;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"

multilínea con comentarios:

$_=<>;   # 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 cadena se lee y se verifica en busca de caracteres no válidos utilizando una expresión regular, saliendo si se encuentra alguno. Luego, los caracteres en minúscula permitidos se sustituyen por los caracteres no válidos y toda la cadena se convierte en minúsculas.

Las filas se generan de una en una, con 1 segmento por letra en la primera fila y 3 en las otras dos. Para cada fila, la cadena se procesa un carácter a la vez y el carácter se compara con una expresión regular para cada segmento para verificar si a! o _ debe mostrarse. El uso de una expresión regular significa que para los caracteres en los que el segmento no está configurado, se requieren cero bits por segmento por carácter para codificar si se establece, y para aquellos en los que está, toma un poco menos de 8 bits en promedio porque los rangos de caracteres de expresión regular pueden ser usado. Por lo tanto, resulta en alrededor de 3 o 4 bits por segmento por carácter en el conjunto, o alrededor de 21-24 bits por carácter.

No maneja el ajuste de línea.

samgak
fuente
1
¡Hola @samgak, me alegra ver más amor de Perl! ¡Noté algunas cosas que podrían ayudarlo a eliminar algunos bytes y quería compartirlas! Puede usar algunas de las variables mágicas de Perl para ayudar a reducir esto; ' 'puede ser reemplazado con $"y ' 'puede ser el $"x3que recorta algunos, sus \ns pueden ser literalmente nuevas líneas para deshacerse de algunos más. Tu salida anticipada también se puede acortar, usando morir, para que se if(/[kmvwx]/i){print" -\n"x3;exit}convierta die" - "x3if(/[kmvwx]/i). Con un poco más de fudging también, puede reorganizar el bucle para evitar los corchetes y ¡no debería necesitar $zguardar algunos más!
Dom Hastings
1
Espero que no te ofendas, pero he tratado de reducir más, gist.github.com/dom111/e651b5de8c7e7fc9a6cf . ¡Hasta 323!
Dom Hastings
@DomHastings sin ofender, gracias por los excelentes consejos de golf. He usado tantos como pude en mi respuesta editada, que he cambiado para usar codificación bit a bit en lugar de expresiones regulares para los patrones de segmento. Desafortunadamente, $ z ha vuelto, y no puedo encontrar la manera de deshacerme de él. Además, $_=lc<>no funciona, porque el código no puede discriminar entre mayúsculas y minúsculas CHIOU
samgak
1

Lisp común, 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)))

Ejemplo

Con "abcdefg'hijklnopqrstuz"impresiones:

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

Observaciones

Los caracteres y sus representaciones están codificados en este número en la base 36:

IL884OIVFXJY4DCQ0O8DPH8MOMR2DSLPP3O4ESYHS234A9HEQYSV8IBDBZI6Z3C3MCVR77OYD3QN5G6CX2UQWGL4UY5R9PKYI1JQ5Y6DC27MQQGUZSCGI8Q9JCYP9N1L4YYKRWM1ZNMSVTSB4792UUWV6Z3906VSP981WCCBMDNJ02

La representación binaria de este dígito se divide en grupos de 17 bits.

Por ejemplo, el último grupo de 17 bits es 110000111101010, que se descompone aquí en dos partes:

  1. 110000, el código de carácter del personaje 0

  2. 111101010, una codificación del dibujo, mejor representada de la siguiente manera:

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

    Los bits en la primera y última "columna" son para los !personajes, los de la columna central para el _personaje. Cuando es necesario, se almacenan las versiones en mayúsculas y minúsculas de un personaje.

La función itera tres veces sobre la cadena de entrada, una para cada línea de salida, busca un carácter coincidente en la tabla (o el valor predeterminado es 146, también conocido como tres barras) e imprime la representación en la fila actual.

volcado de memoria
fuente
Gracias por participar en el desafío. Noté que su 'K' se muestra como 'L' en su salida. Es posible que haya entendido mal el requisito de que el carácter no compatible no se puede imprimir junto con otro carácter válido. Además, veo que agregaste el 'personaje, lo cual es bueno; sin embargo, se mostrará fuera de lo que puede hacer una pantalla de 7 segmentos. Si mueve la línea !hacia abajo 1 línea, sería perfecto.
algún usuario
Actualizaré el 'carácter y editaré la pregunta Kporque, de hecho, puse el Klugar incorrecto en la cadena de entrada ("... jlKn ...") ;-) Puedes ver las barras triples (error) solo después de la L. Gracias por notarlo.
coredump
1

JavaScript (ES6), 380 352 324 bytes

( Nota: el código utiliza la notación de intercalación, ya que contiene algunos caracteres no imprimibles. Para obtener el código original, haga clic aquí y seleccione los datos sin procesar. Y no, hno es un programa 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}

Llamado d("7-seg display") o similar. Funciona en Firefox 40, pero puede que no en otros navegadores. Por alguna razón, el fragmento HTML / JS no guarda los no imprimibles, pero puede copiar y pegar los datos sin procesar desde aquí .

Sin golf:

( Nota: g y hse han rellenado con espacios para que coincida con 8, -, ÿy spacecon sus correspondientes valores Unicode).

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

Explicación:

Inmediatamente noté que los 7 segmentos, convertidos en 0/ 1bits, irían bien con los primeros 128 caracteres Unicode. El problema con esta idea es que 1/4 de estos caracteres son caracteres de control no imprimibles. Usarlos en mi código lo haría ver increíblemente desordenado (o increíblemente inteligente; no he decidido cuál). Para resolver esto manteniendo el resto del código simple, se me ocurrió esta idea:

Con la excepción de -, espacio , y el error , ninguno de los personajes que faltaban los dos segmentos verticales inferiores. Así que para asegurarnos de que todos esos personajes permanecieron entre 0020y007f , simplemente asigné los 64 y 32 bits a estos segmentos, así:

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

Los números de los otros 5 segmentos no son demasiado importantes; podrían organizarse de cualquier otra manera y seguir teniendo los mismos caracteres "dentro de los límites".

Como ejemplo, aquí está la versión codificada 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 = {

Luego rellené la versión codificada de cada personaje de 7 seg h. Sin embargo, 8resultó en 007f(el código de control de eliminación ; constante sin importar cómo estén organizados los segmentos), el espacio resultó en 0000(el código nulo ; también constante), -resultó 0002y el error resultó 0007. Puedo copiar-pegar los bytes sin procesar en la posición correcta para 8, -y el error ; el espacio se logró fácilmente con \0.

Después de toda esta codificación, todo lo que tuve que hacer fue usarlo para decodificar la cadena y generarla en un formato legible de 7 seg. He utilizado una de bucle y tres variables ( x, y, y z, cada uno correspondiente a una línea de salida) para ir a través de cada carácter en la cadena y añadir su equivalente 7-seg a la salida. Elegí ÿel carácter de error porque AFAIK, no está en ningún teclado, y es el último carácter en el u+0000-u+00ffrango. Quizás podría haber sido ingenioso y elegido Ξ(letra griega xi) en su lugar ...;)

Editar 1: ahorrado un montón de espacio mediante la creación de mini-funciones para determinar si !, _o se necesita.

Edición 2: ahorré un montón más de espacio usando los trucos que aprendí desde la última vez que visité esta publicación.

Como siempre, ¡las sugerencias son muy apreciadas!

ETHproductions
fuente