Transforme el número en un patrón de visualización de 7 segmentos

28

Dados dos números arbitrarios A, B. Imprima el número B como un patrón LED digital donde A es la escala.

entrada:

1 2320451640799518

salida:

 _  _  _  _     _     _     _  _  _  _  _     _ 
 _| _| _|| ||_||_   ||_ |_|| |  ||_||_||_   ||_|
|_  _||_ |_|  | _|  ||_|  ||_|  |  |  | _|  ||_|

entrada:

2 23

salida:

 __  __
   |   | 
 __| __|
|      |
|__  __|

Reglas:

  • Use STDIN / STDOUT para entrada / salida

  • Código con más votos positivos. En caso de empate, se aceptará el código más corto

  • La respuesta más votada será aceptada el 01/02/2014 ( esta respuesta fue aceptada con los 12 votos más altos)

Wasi
fuente
2
Algunas preguntas relacionadas, para el robo de código / inspiración: " Emular una pantalla de 7 segmentos " y " Números y letras LED ".
Darren Stone el
@Wasi Gracias. Vi tu edición que me la aclaró.
C0deH4cker
Su 9 debe tener el guión bajo en la última línea, para ser como el 6 invertido.
Tomás
1
@ Tomás Gracias por la sugerencia. Pero, ya tenemos 13 respuestas, por lo que será injusto cambiarlo aún más :-)
Wasi
OK Wasi, pero espero que no te importe que use mi forma preferida 9en mi respuesta , ya que me gusta más :-)
Tomas

Respuestas:

20

Commodore 64 BÁSICO

Reglas de arte PETSCII :)

LISTA

Salida:

CORRER

Danko Durbić
fuente
3
¿Qué pasó con el dígito 4? oO
Timwi
Así es como escribo el número 4, pero está bien, lo arreglé :)
Danko Durbić
2
Fascinante: ¿también lo escribes a mano? ¿Es eso común en Suecia, o de donde sea que provengas originalmente?
stand
Haría +100 si pudiera.
Michael Kohl
12

Pitón 3, 286 282 280

Sí, jugué golf con este. Buen desafío!

n,x=input().split()
n=int(n)
l=lambda s:"".join(s)+"\n"
h=lambda s:s.replace(*"! ")*~-n+s.replace(*"!_")
print(l(" "+"_ "[c in"14"]*n+" "for c in x)+h(l("| "[c in"1237"]+n*"! "[c in"017"]+"| "[c in"56"]for c in x))+h(l(" |"[c in"0268"]+n*"! "[c in"1479"]+"| "[c=="2"]for c in x)))



Además, ¡aquí hay una versión de Python 2 que pesa solo 273 bytes!

No actualizar esto más con más fuentes originales de golf. Esto se creó cuando la fuente original era de 282 bytes (versión Python 3).

exec'eJxdzE0OgjAQhuE9pxhn1VIlFhHUpCdRQlAx1NShAYwsOLzgD4irSd758tC8UWX6SDTZe824V1mju+uQ0lQz4o5RJr0dzylUO0TvWmhiFRd4IHTy8VV5ZWZNesqYizNA7jJaSC4mOUHu2LJjwTAEFJgA7k+gCWWAsUuii5eihD5Bw0XOul07bPxVhLGgl/9OS9mXcbIOMf4BPgK037kfbv4EGUTbgVAK/SnwBAs+TpU='.decode('base64').decode('zip')

Esto puede ser trampa, así que lo agrego por separado. Déjame saber si esto se considera válido o no.

C0deH4cker
fuente
6

Haskell (389 caracteres)

La solución utiliza 7 matrices, una para cada segmento de la matriz, utilizando los nombres de esta imagen:

Pantalla de 8 segmentos

. El valora !! 4 será el carácter que debe mostrarse en esa posición para el número 4.

Los valores se multiplican por la escala donde sea apropiado (usando r y rppara la replicación), y finalmente se imprimen.

El código

a="_ __ _____"
b="|||||  |||"
c="|| |||||||"
d="_ __ __ _ "
e="| |   | | "
f="|   ||| ||"
g="  _____ __"
r=replicate
cm=concatMap
s=(' ':).(++" ")
dd w n=[[t n],rp$m f b n,[o g f b n],rp$m e c n,[o d e c n]] where
 rp=r$w-1
 t=cm(s.r w.(a!!))
 q f s x y=cm(\n->x!!n:r w(f s n)++[y!!n])
 o=q(!!) 
 m=q const ' '
go a=unlines$concat$dd(read$a!!0)$map(read.(:[]))$a!!1
main=interact$go.words

Ejemplo de uso

echo '1 2320451640799518' | runhaskell ./digit_led.hs
 _  _  _  _     _     _     _  _  _  _  _     _ 
 _| _| _|| ||_||_   ||_ |_|| |  ||_||_||_   ||_|
|_  _||_ |_|  | _|  ||_|  ||_|  |  |  | _|  ||_|
David Miani
fuente
6

C, 249 226 caracteres

Solución de golf en C:

int x,y,g,s,q;main(){char*c,i[99];for(scanf("%d %98s",&s,i);y<2*s+1;++y,puts(""))for(c=i;*c;++c)for(x=0;x<s+2;++x)q=(y+s-1)/s*3+(x+s-1)/s,g=(x%(s+1))*(y%s)?7:q<3?~q%2*7:q-2,putchar("_|_||_| "["zG<lMfvH~N"[*c-48]+1>>g&1?g:7]);}

Con espacios en blanco agregados:

int x, y, g, s, q;

main() {
  char *c, i[99];
  for (scanf("%d %98s", &s, i); y < 2 * s + 1; ++y, puts(""))
    for (c = i; *c; ++c)
      for (x = 0; x < s + 2; ++x)
        q = (y + s - 1) / s * 3 + (x + s - 1) / s,
        g = (x % (s + 1)) * (y % s)
          ? 7
          : q < 3
            ? ~q % 2 * 7
            : q - 2,
        putchar("_|_||_| "["zG<lMfvH~N"[*c - 48] + 1 >> g & 1 ? g : 7]);
}

Notas:

  • Como máximo se imprimen 99 dígitos
  • El comportamiento es indefinido si la entrada no está bien formada (por ejemplo, no contiene dígitos o la escala es <1)
  • Debe ser el código legal C89

Proporcionaré una explicación de cómo funciona, si a alguien le importa.

reima
fuente
1
Por lo que leí en esta página sobre lo que está "OK en C" , no es necesario que lo incluya #include <stdio.h>(ya que se compilará sin él). También puede poner un int main(), por ejemplo main(x), recortar 1 byte, aunque no es válido firma y poner scanfdentro for: for(scanf("%d %98s", &s, &i); …)afeitado de uno más. - Mira aquí .
Runium
@Sukminder Estas son sugerencias muy útiles, ¡gracias! Quité el #include, movido el scanfinterior del for, eliminado el innecesaria &en &i, y poner las intvariables que en el ámbito global de explotar la estática 0 inicialización. El código ahora debería ser legal C89, pero no lo revisé a fondo. Creo poniendo una inten la mainque no es legal, por lo que me fui a cabo.
reima
Renunciar al cumplimiento estándar puede ayudar mucho. Por ejemplo, puede omitir intlas variables globales. También %98spuede ser %s(para cadenas más largas fallas de todos modos, ¿importa de qué manera?)
Ugoren
¡Bueno! Usé "una especie de" filosofía similar, pero más simple - 187 caracteres en PERL
Tomás
5

Ruby 2.0

Implementación rápida y (no tan) ingenua de rubí.

V,H = ' |',' _'
l = gets.split
s = l[0].to_i
o = Array.new 1+s*2, ''
l[1].each_char {|c|
  m = "{H=mNgwI\x7FO"[c.to_i].ord
  o[0] += " #{H[m[0]]*s} "
  o[s] += "#{V[m[1]]}#{H[m[2]]*s}#{V[m[3]]}"
  o[s*2] += "#{V[m[4]]}#{H[m[5]]*s}#{V[m[6]]}"
}
(s-1).times { |i|
  o[i+1] = o[s].gsub '_', ' '
  o[s+i+1] = o[s*2].gsub '_', ' '
}
o.each {|r| puts r}

Explicación rápida:

Primero declaro las cadenas que representan dígitos de encendido y apagado para barras horizontales y verticales.
Luego leí la escala y los dígitos.
Luego declaro una matriz del tamaño necesario para almacenar suficientes líneas para la escala dada. La cadena extraña es en realidad una asignación de valores de 7 bits que representa qué LED encender para cada dígito.
A continuación, para cada dígito, lleno la matriz de salida de arriba a abajo, teniendo en cuenta la escala horizontal.
El bucle final es llenar las filas que solo tienen barras verticales, que solo se pueden generar a partir de las filas medias e inferiores eliminando las barras horizontales.
¡Finalmente, imprimo la matriz de salida!

SirDarius
fuente
¿Puedes explicar lo que está pasando aquí?
Michael Stern el
5

Python 2.6 sin importaciones. Yo diría que el atractivo de esta solución es el uso de plantillas. Desafortunadamente, creo que es por eso que me costó tanto compactarlo.

def numbers(scale, number):

    def single(yay, wall, digit):
        walls = ('1110111', '0010010', '1011101', '1011011',
                 '0111010', '1101011', '1101111',
                 '1010010', '1111111',
                 '1111010')
        return yay if int(walls[digit][wall]) else ' '

    def expand_one(char, digit):
        characters = '_||_||_'
        translated = single(characters[char], char, digit)
        if char % 3:
            return translated
        return translated * scale

    def expand_template(template, digit):
        out = ''
        for c in template:
            if c == '.':
                out += ' ' * scale
            elif c == ' ':
                out += c
            else:
                out += expand_one(int(c), digit)
        return out

    def repeated_expand_template(template, n):
        print ''.join(expand_template(template, int(d)) for d in n)

    repeated_expand_template(' 0 ', number)
    for _ in range(scale - 1):
        repeated_expand_template('1.2', number)
    repeated_expand_template('132', number)
    for _ in range(scale - 1):
        repeated_expand_template('4.5', number)
    repeated_expand_template('465', number)


scale, number = raw_input().split()
numbers(int(scale), number)

Y un poco más corto (308 caracteres):

s,n=raw_input().split();s=int(s)
for e in('0 0 ','11.2','0132','14.5','0465'):print '\n'.join(''.join(''.join(([' ','_||_||_'[int(c)]][int(bin(1098931065668123279354)[7*int(d)+int(c)+2])]*(s,1,1)[int(c)%3])if ord(c)>46 else c for c in e[1:].replace('.',' '*s))for d in n) for _ in range((1,s-1)[int(e[0])]))
toodooloo
fuente
Fyi, se supone que la parte superior de los dígitos es '_' (guiones bajos) y no hay espacios entre los dígitos. Estaba confundido al principio jaja
C0deH4cker
5

(Editar: esta solución ahora no es válida porque la semántica de la instrucción ha cambiado. No me di cuenta de que ya había hecho uso de la instrucción cuando la cambié. Sin embargo, puede arreglar este programa simplemente cambiándolo a la nueva instrucción )

Sclipting - 85 caracteres

겠合글坼銻標⓷가殲갰復묽땸민뫝뜵깉걈밂⓶各가⓵겐上⓷감嚙긇밌⓶掘⓶감嚙눖밂⓶掘⓷合⓶감嚙긇밌⓶掘⓷合⓸⓸替❶終⓶丟終❶눠替눐終①貶復⓶⓷終丟併눐替글①復終눠替뇰①復終⓶丟

Entrada:

1 1024856359701

Salida:

    _  _     _  _  _  _  _  _  _  _    
  || | _||_||_||_ |_  _||_ |_|  || |  |
  ||_||_   ||_| _||_| _| _|  |  ||_|  |

Entrada:

2 47474747

Salida:

     __      __      __      __ 
|  |   ||  |   ||  |   ||  |   |
|__|   ||__|   ||__|   ||__|   |
   |   |   |   |   |   |   |   |
   |   |   |   |   |   |   |   |

Timwi
fuente
¿Puedes arreglar el programa? Dejar todo el trazo posterior es bastante feo.
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ 18/0614
Por supuesto, podría cambiar el a , pero eso haría que esta entrada engañara porque se inventó después de que se publicó este desafío.
Timwi
No creo que sea un gran problema. No hago su programa más corto de todos modos.
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ 18/0614
1
No, pero violaría una regla importante de esta comunidad.
Timwi
Ya no infringe una regla: P
Solo ASCII
4

C # ( 480 443 caracteres)

namespace System{using z=String;using w=Console;class P{static void Main(){var t=w.ReadLine().Split(' ');var s=int.Parse(t[0]);z b="17",d=b+23,e=b+3459,f="56",g=e+2680;Action<z,z,z,int>q=(l,m,r,n)=>{for(int i=1;i<n;i++){foreach(var c in t[1]){h(c,l);for(int j=0;j<s;j++)h(c,m,"_");h(c,r);}w.Write("\n");}};q(g,"14",g,2);q(d,g,f,s);q(d,b+0,f,2);q(e,g,"2",s);q(e,b+49,"2",2);}static void h(char x,z m,z y="|"){w.Write(m.Contains(""+x)?" ":y);}}}

Versión extendida:

using System;
using System.Linq;

namespace Segments
{
    internal class Program
    {
        static void Main()
        {
            var scale = int.Parse(Console.ReadLine());
            var input = Console.ReadLine();

            PrintLine(input, "", "14", "", 2);
            PrintLine(input,"1237", "", "56", scale);
            PrintLine(input,"1237", "170", "56", 2);
            PrintLine(input,"134579", "", "2", scale);
            PrintLine(input,"134579", "147", "2", 2);
        }

        static void PrintLine(string input, string leftMatch, string middleMatch, string rightMatch, int scale)
        {
            for (int i = 1; i < scale; i++)
            {
                foreach (var c in input)
                {
                    PrintDigitLine(c, leftMatch, '|', 1);
                    PrintDigitLine(c, middleMatch, "_", scale);
                    PrintDigitLine(c, rightMatch, '|', 1);
                }
                Console.Write("\n");
            }
        }

        private static void PrintDigitLine(char digit, string match, char charToPrint, int)
        {
            for (int i = 0; i < n; i++) Console.Write(match.Contains(digit) || match == "" ? ' ' : charToPrint);
        }
    }
}

Mi idea era dividir la tarea en 5 líneas horizontales, que a su vez se dividen en una parte izquierda, derecha y media para cada personaje.

Rik
fuente
Tal vez lo copié mal, pero intenté ejecutar esto en ideone y me dio un error. ideone.com/gQ6LH7
C0deH4cker
probablemente sea mi culpa, déjame ver
Rik
1
@ C0deH4cker Tomé la entrada en dos ReadLines separadas. Este funciona: ideone.com/4jTxeu
Rik
1
@ C0deH4cker Hice una versión que toma la entrada como se especifica, y deja caer la parte inferior del 9. La entrada toma tantos caracteres, el 9 cuesta 1 extra.
Rik el
1
Tienes un redundante ;allí (480); puedes escribir Action<z,z,z,int>q=(l,m,r,n)=>{...};(470); puedes hacer el primer parámetro de ha chary hacer el ""+inside h(467); y finalmente, puede declarar y reutilizar z d="134579",b="1237"(465). Eso es lo más pequeño que pude llegar hasta ahora
Timwi
3

Supongo que hay soluciones muy cortas, pero como esto no es código golf, ¡estoy bastante satisfecho!

Este script PHP tomará dos números a, bdesde STDIN y echo ben formato LED, a atamaño.

fscanf(STDIN, "%d %d", $a, $b); //Didn't test this line, but it should be ok.
$space=str_repeat("&nbsp;", $a);

$top = $topLeft = $topRight = $mid = $botLeft = $botRight = $bot = array();
for ($i=0; $i<count($b); $i++) {
    $top[$i] = $topLeft[$i] = $topRight[$i] = $mid[$i] = $botLeft[$i] = $botRight[$i] = $bot[$i] = true;
switch ($b[$i]) {
    case 0:
        $mid[$i] = false;
    break;
    case 1:
        $top[$i] = $topLeft[$i] = $mid[$i] = $botLeft[$i] = $bot[$i] = false;
        break;
    case 2:
        $topLeft[$i] = $botRight[$i] = false;
        break;
    case 3:
        $topLeft[$i] = $botLeft[$i] = false;
        break;
    case 4:
        $top[$i] = $botLeft[$i] = $bot[$i] = false;
        break;
    case 5:
        $topRight[$i] = $botLeft[$i] = false;
        break;
    case 6:
        $topRight[$i] = false;
        break;
    case 7:
        $topLeft[$i] = $mid[$i] = $botLeft[$i] = $bot[$i] = false;
        break;
    case 9:
        $botLeft[$i] = false;
        break;
    }
}

horizontal($top);
vertical($topLeft, $topRight);
horizontal($mid);
vertical($botLeft, $botRight);
horizontal($bot);

function horizontal($position) {
    global $a, $b, $space;
    for ($i=0;$i<count($b);$i++) {
        if ($position[$i])
            echo "&nbsp;".str_repeat("-", $a)."&nbsp;";
        else
            echo "&nbsp;".$space."&nbsp;";
    }
    echo "<br />";
}

function vertical($positionLeft, $positionRight) {
    global $a, $b, $space;
    for ($j=0;$j<$a;$j++) {
        for ($i=0;$i<count($b);$i++) {
            if ($positionLeft[$i]) {
                echo "|".$space;
                if ($positionRight[$i])
                    echo "|;";
                else
                    echo "&nbsp;";
            }
            else {
                echo "&nbsp;".$space;
                if ($positionRight[$i])
                    echo "|";
                else
                    echo "&nbsp;";
            }
        }
        echo "<br />";
    }
}

EDITAR: Mirando el ejemplo de salida anterior, supuse erróneamente que el espacio entre dígitos debería ser tan grande como el atamaño. Esto se ha solucionado con la declaración del OP de que no se necesita espacio.

Vereos
fuente
En realidad, no debería haber espacios entre los dígitos. La única razón por la que se ve así para la muestra es porque los espacios son donde el '|' estaría en un 8 por ejemplo. Me tomó un tiempo descubrirlo
C0deH4cker
¡Oh, tienes razón! Gracias :)
Vereos
2

C #, 435 359 473 bytes

EDICIONES:

  • Se eliminó el código redundante. Tamaño de byte reducido de las comparaciones.
  • Convertido a una aplicación autónoma usando entrada estándar para entrada.

Aquí está el código de golf (con saltos de línea y espacios en blanco agregados):

using C=System.Console;
class P{
    static void Main(){
        var a=C.ReadLine().Split(' ');
        D(int.Parse(a[0]),a[1]);
    }
    static void D(int r,string n){
        int i,j;
        string s="",v="|",w=" ",x=new string('_',r),y=new string(' ',r),z="\n";
        foreach(var c in n)s+=w+(F(0,c)?x:y)+w+w;
        for(j=1;j<6;j+=3)
            for(i=r;i-->0;){
                s+=z;
                foreach(var c in n)s+=(F(j,c)?v:w)+(i<1&&F(j+1,c)?x:y)+(F(j+2,c)?v:w)+w;
            }
        C.Write(s+z);
    }
    static bool F(int i,char c){
        return(new[]{1005,881,892,927,325,365,1019}[i]&1<<(int)c-48)>0;
    }
}
Hand-E-Food
fuente
Son funciones válidas de C #. Nunca se dijo que debería ser un programa independiente. Sin embargo, no utiliza estándar en.
Hand-E-Food
@Timwi, editado para cumplir ...
Hand-E-Food
1
¡¡Bien hecho!! Lo he jugado un poco más y lo reduje a 425 (caracteres; 432 bytes en UTF-8), lo que lo hace más corto que la otra respuesta de C #. using System;using S=System.String;class P{static void Main(){Action<S[]>D=n=>{var r=int.Parse(n[0]);Func<int,int,bool>F=(i,c)=>("ϭͱͼΟŅŭϻ"[i]&1<<c-48)>0;S s="",v="|",w=" ",x=new S('_',r),y=new S(' ',r);foreach(var c in n[1])s+=w+(F(0,c)?x:y)+w+w;for(int j=1;j<6;j+=3)for(int i=r;i-->0;){s+="\n";foreach(var c in n[1])s+=(F(j,c)?v:w)+(i<1&&F(j+1,c)?x:y)+(F(j+2,c)?v:w)+w;}Console.Write(s);};D(Console.ReadLine().Split(' '));}}
Timwi
1
Usar la otra idea de respuesta de C # de poner todo en el Systemespacio de nombres lo lleva a 423
Timwi
2

C ( 561 492 bytes)

El autor es frmar. Me envió su respuesta la semana pasada (todavía no ha creado su cuenta).

492 bytes pero un poco más ofuscado:

#include<stdio.h>
#include<ctype.h>
#include<stdlib.h>
#define C(x) ((_[*n-'0'])>>s)&m&x
#define P putchar
unsigned _[]={476,144,372,436,184,428,492,148,508,188};
void p(int a,char*n,unsigned m,int s)
{for(;isdigit(*n);++n){P(C(1)?'|':' ');
for(int i=0;i<a;++i)P(C(4)?'_':' ');
P(C(2)?'|':' ');}
P('\n');}
void l(int a,char*b){p(a,b,7,0);int i=1;
for(;i<a;++i)p(a,b,3,3);p(a,b,7,3);i=1;
for(;i<a;++i)p(a,b,3,6);p(a,b,7,6);}
int main(int c,char**v){l(c>1?atoi(v[1]):1,c>2?v[2]:"0123456789");}

Versión anterior con 561 bytes:

#include<stdio.h>
#include<ctype.h>
#define C(x) ((((*n-'0')[_])>>s)&m&x)
const unsigned _[]={476,144,372,436,184,428,492,148,508,188};
void p(int a,const char*n,unsigned m,int s)
{
 for(;isdigit(*n);++n) {
  putchar(C(1)?'|':' ');
  const char c=C(4)?'_':' ';
  for(int i=0;i<a;++i) putchar(c);
  putchar(C(2)?'|':' ');
 }
 putchar('\n');
}
void l(int a,const char*b)
{
 p(a,b,7,0);
 for(int i=1;i<a;++i)p(a,b,3,3);p(a,b,7,3);
 for(int i=1;i<a;++i)p(a,b,3,6);p(a,b,7,6);
}
#include<stdlib.h>
int main(int c,char**v){l(c>1?atoi(v[1]):1,c>2?v[2]:"0123456789");}

Versión original de frmar (623 bytes):

#include<stdio.h>
#include<ctype.h>
const unsigned int _[]={476,144,372,436,184,428,492,148,508,188};
void p(int a,const char*n,unsigned int m,int s)
{
  for(;isdigit(*n);++n) {
#define C(x) ((((*n-'0')[_])>>s)&m&x)
    putchar(C(1)?'|':' ');
    const char c=C(4)?'_':' ';
    for(int i=0;i<a;++i) putchar(c);
    putchar(C(2)?'|':' ');
  }
  putchar('\n');
}
void print_as_led(int a,const char*b)
{
  p(a,b,7,0);
  for(int i=1;i<a;++i)p(a,b,3,3);p(a,b,7,3);
  for(int i=1;i<a;++i)p(a,b,3,6);p(a,b,7,6);
}
#include<stdlib.h>
int main(int argc,char**argv){print_as_led(argc>1?atoi(argv[1]):1,argc>2?argv[2]:"0123456789");}

Compilacion:

$ gcc -std=c99 -Wall print_as_led.c

Ejemplos que usan un 0123456789número predeterminado pero diferentes tamaños:

$ ./a.out
 _     _  _     _  _  _  _  _
| |  | _| _||_||_ |_   ||_||_|
|_|  ||_  _|  | _||_|  ||_|  |

$ ./a.out 2
 __      __  __      __  __  __  __  __
|  |   |   |   ||  ||   |      ||  ||  |
|  |   | __| __||__||__ |__    ||__||__|
|  |   ||      |   |   ||  |   ||  |   |
|__|   ||__  __|   | __||__|   ||__|   |

$ ./a.out 3
 ___       ___  ___       ___  ___  ___  ___  ___
|   |    |    |    ||   ||    |        ||   ||   |
|   |    |    |    ||   ||    |        ||   ||   |
|   |    | ___| ___||___||___ |___     ||___||___|
|   |    ||        |    |    ||   |    ||   |    |
|   |    ||        |    |    ||   |    ||   |    |
|___|    ||___  ___|    | ___||___|    ||___|    |

Otros ejemplos:

$ ./a.out 1 42
    _
|_| _|
  ||_

$ ./a.out 2 42
     __
|  |   |
|__| __|
   ||
   ||__

$ ./a.out 3 42
      ___
|   |    |
|   |    |
|___| ___|
    ||
    ||
    ||___

Tamaños más grandes:

$ ./a.out 4 42
       ____
|    |     |
|    |     |
|    |     |
|____| ____|
     ||
     ||
     ||
     ||____
$ ./a.out 5 42
        _____
|     |      |
|     |      |
|     |      |
|     |      |
|_____| _____|
      ||
      ||
      ||
      ||
      ||_____
olibre
fuente
1

Perl + FIGlet + BRA * : 54 caracteres

while(<>){($n,$x)=split;print(`figlet -f 7seg$n $x`);}

Pensé que esto sería bastante fácil de hacer con FIGlet , pero no parecía haber ninguna fuente adecuada para este propósito. Entonces hice algunos :-)

Así es como se ve en la terminal:

$ perl ./led.pl
1 234
 _  _    
 _| _||_|
|_  _|  |
2 345
 __      __ 
   ||  ||   
 __||__||__ 
   |   |   |
 __|   | __|
3 456
      ___  ___ 
|   ||    |    
|   ||    |    
|___||___ |___ 
    |    ||   |
    |    ||   |
    | ___||___|

* BRA: abuso de reglas flagrantes

ossifrage aprensivo
fuente
No entiendo por qué hay un voto negativo para eso. Buen truco con las fuentes!
VisioN
No estaba downvoting, pero me gustaría entender que el uso de un programa en lugar de realmente hacer el programa es hacer trampa.
Tomás
1

PERL   261 244 187   166 caracteres

Un poco de filosofía de codificación bit a bit rulez :-)

($n,$a)=split/ /;sub c{$_=$a;y/0-9/Gl+%<UWm7=/;s/./(substr"   _ _|_| |_  |",2*ord($&)>>$_[0]&$_[1],3)=~s|.\K.|$&x$n|er/ge;print y/_/ /r x($n-1).$_}c 0,2;c 4,14;c 1,14

Código con espacio en blanco agregado:

($n,$a)=split/ /;

sub c{
$_=$a;
y/0-9/Gl+%<UWm7=/;
s/./(substr"   _ _|_| |_  |",2*ord($&)>>$_[0]&$_[1],3)=~s|.\K.|$&x$n|er/ge;
print y/_/ /r x($n-1).$_
}

c 0,2;
c 4,14;
c 1,14

Perl tiene que ser invocado con -n:

$ perl -n digitize.zoom.pl
1 12304597
     _   _   _       _   _   _
  |  _|  _| | | |_| |_  |_|   |
  | |_   _| |_|   |  _|   |   |
2 0784
 __   __   __
|  |    | |  | |  |
|  |    | |__| |__|
|  |    | |  |    |
|__|    | |__|    |
3 789
 ___   ___   ___
    | |   | |   |
    | |   | |   |
    | |___| |___|
    | |   |     |
    | |   |     |
    | |___|     |

Notas:

  • Todo sobre cómo se muestran los dígitos está codificado en la cadena Gl+%<UWm7= :-) Un carácter corresponde a un dígito, codificado son 3 posiciones de 3 caracteres consecutivos dentro del" _ _|_| |_ |" cadena.
  • Los números se construyen en 3 líneas, línea por línea. Cada una de las 3 líneas corresponde a una llamada a subrutinac , que también realiza el zoom vertical para la segunda y tercera línea.
  • El zoom horizontal se realiza al final de la subrutina c.

Mi sedprograma no puede ampliar, pero se ve mucho mejor, ¿no? :-)

s/./\0 /g
h
s/[14]/   /g
s/[2305-9]/ _ /g
p
g
s/[17]/  |/g
s/[23]/ _|/g
s/[489]/|_|/g
s/[56]/|_ /g
s/0/| |/g
p
g
s/[147]/  |/g
s/2/|_ /g
s/[359]/ _|/g
s/[680]/|_|/g

Más o menos la idea que usa mi script PERL, pero en PERL es mucho más feo. Tenga en cuenta que para mi programa sed preferí usar el 9que tiene el guión bajo en la última línea, que es como el reverso 6.

Tomás
fuente
Me preguntaba si podría explicar cómo funciona la escala, estoy tratando de implementar mi propia versión en Perl. Pero parece que no puede obtener la escala vertical y horizontal correcta.
Hunter McMillen
0

C #, 386 382 364 caracteres / 374 bytes (UTF-8) y (¿mucho?) Margen de mejora ...

using System.Linq;using C=System.Console;class P{static void Main(string[] args){var s=C.ReadLine();for(int l=0;l<5;l++){for(int j=0;j<s.Length;j++)C.Write(string.Join("",Enumerable.Range(0,3).Select(i=>{var x=l*3+i;return((x&1)>0?((((System.Text.Encoding.Unicode.GetBytes("⑷浝欮╻潿")[(byte)s[j]-48]>>x/2)&1)==1)?(x-1%3>0?"|":"-"):" "):" ");}))+" ");C.WriteLine();}}}

EDITAR basura ... Me perdí la parte de "escala"MIERDA

Le daré otra oportunidad si lo consigo ...

RobIII
fuente
Sí, la parte de la escala da miedo.
cjfaure
0

J - 147 95 caracteres

Se agregó la escala requerida:

1!:2&2,./(([1 s 0 s=:1 :(':';'y#"(2-m)~(m{$y)$1,x'))"2(3 :'(y{(5 3$&,0&,.)"1@#:l)}d')@"."0@":)/".]1!:1]1[l=:>:a.i.'v#\Z9jnQ~z'[d=:' ',:5 3$' - | |'

Versión anotada:

NB. Digit array (2 x 5 x 3) first is blank, second is filled.
d=:' ',:5 3$' - | |'
NB. Bits to selector (taking into account that all "usefull" bits are separated with 0 bits, looking at the 5 x 3 grid)
bts =: 5 3 $&, (0&,.)
NB. list of character bits.
l=: 119 36 93 91 58 107 111 82 127 123
NB. golfing using ascii range
l=: >:a.i.'v#\Z9jnQ~z'

NB. scaling function
NB. scaling in 1 direction involves inserting copies of the middle segments:
NB. from y, copy the middle segments, 1 x 1 x 1 for rank 2 and 1 x 1 for rank 1
NB. Usage: scale (rank s) segment
s=: 1 : (':';'y#"(2-m)~(m{$y)$1,x')
NB. scale first along columns, then along rows, apply only to rank 2 (planes)
b=:([1 s 0 s)"2

NB. Get one number by using amend with a selection array (0 is blank, 1 is filled)
NB. get the y'th plane from the array of 10 x 5 x 3 selector bits, use those to index d with.
g=: 3 : '(y { (bts"1 #: l)) } d'
NB. from right to left: read stdin, convert number string to numbers,
NB. use the left for scaling, and split the right in digits,then apply g,
NB. then paste them together so the numbers appear next to each other.
NB. Put this result on stdout
1!:2&2,./(b g@"."0@":)/".]1!:1]

Ejemplo:

1 0123456789
 -     -  -     -  -  -  -  - 
| ||    |  || ||  |    || || |
       -  -  -  -  -     -  - 
| ||  |    |  |  || |  || |  |
 -     -  -     -  -     -  - 

2 123
     --  -- 
|      |   |
|      |   |
     --  -- 
|   |      |
|   |      |
     --  -- 
jpjacobs
fuente
¿Cómo responde esto a la pregunta?
Wasi
Tienes toda la razón ... lo arreglaré
jpjacobs
Tu ejemplo es incorrecto. Mira la pregunta.
Tomás
0

Ruby, 126 caracteres ASCII

->n,x{(n*2).downto(0){|i|x.bytes{|c|z='u"ik:[]b}{'[c-48].ord+2>>i/n*3&7
print' |'[z/2%2],(z%2>i%n ??_:' ')*n,' |'[z/4]}
puts}}

Cada dígito se codifica como un mapa de bits en tercios, por lo tanto, con cada tercio representado por un dígito octal.

|_| 8^2 (left and right never used! only the 1's bit used!)  
|_| 8^1 (4*right+2*left+1*bottom)
|_| 8^0 (4*right+2*left+1*bottom)

Como todos los dígitos tienen el bit de 64 o el bit de 32 establecido, el rango es de 044 octal a 177 octal. Desafortunadamente, 177 es el carácter DEL no imprimible, por lo que la cadena mágica contiene los números 2 debajo del código de mapa de bits requerido, y tenemos que agregar 2 nuevamente en la función.

Sin golf en el programa de prueba

f=->n,x{
  (n*2).downto(0){|i|                               #1 top line, n middle lines, n bottom lines
    x.bytes{|c|                                     #iterate through bytes
      z='u"ik:[]b}{'[c-48].ord+2>>i/n*3&7           #find octal code for current 1/3 digit
      print' |'[z/2%2],(z%2>i%n ??_:' ')*n,' |'[z/4]#print left,right and bottom
    }                                               #z%2>i%n only true on bottom row of 3rd where i%n=0 (print _'s) and octal code has 1's bit set
    puts                                            #print a newline to finish line 
  }
}

n=gets.to_i  #size
x=gets.chop  #number taken in string form
f[n,x]

Salida

C:\Users\steve>ruby 7seg.txt
4
0123456789
 ____        ____  ____        ____  ____  ____  ____  ____
|    |     |     |     ||    ||     |          ||    ||    |
|    |     |     |     ||    ||     |          ||    ||    |
|    |     |     |     ||    ||     |          ||    ||    |
|    |     | ____| ____||____||____ |____      ||____||____|
|    |     ||          |     |     ||    |     ||    |     |
|    |     ||          |     |     ||    |     ||    |     |
|    |     ||          |     |     ||    |     ||    |     |
|____|     ||____  ____|     | ____||____|     ||____| ____|
Level River St
fuente
0

Perl 6, 284 241 237

my (\a,\n)=split " ",slurp.trim;my @p=n.comb;sub g(\b,\c){for @p {my $h=:36(b);$h+>=3*$_;for ^3 {my \e=$_==1;print " |_".substr($h%2&&(c+!e)&&1+e,1)x a**e;$h+>=1}};say ""};for <52N98I 0 HMTVAD 1 AZRXEV 1> ->\s,\q{g(s,0)for 2..a*q;g(s,1)}

Soluciones anteriores:

my (\a,\n)=slurp.trim.split: " ";my @p=n.comb;sub g(\b,\c){for @p {my $h=b;$h+>=3*$_;for ^3 {my \e=$_==1;print " |_".substr($h%2&&(c+!e)&&1+e,1)x a**e;$h+>=1}};say ""};for 306775170,0,1066270117,1,664751335,1 ->\s,\q{g(s,0)for 2..a*q;g(s,1)}
my (\a,\n)=slurp.trim.split: " ";my @p=n.comb;my &f={print $^b.substr(3*$_,1)~($^c??$b.substr(3*$_+1,1)!!" ")x a~$b.substr(3*$_+2,1)for @p;say ""};for (" _     _  _    "~" _ "x 5,0,"| |  | _| _||_||_ |_   ||_||_|",1,"|_|  ||_  _|  | _||_|  ||_|  |",1) ->\s,\q{f(s,0)for 2..a*q;f(s,1)}
bb94
fuente