Verwandle die Zahl in ein 7-Segment-Anzeigemuster

28

Bei zwei willkürlichen Zahlen A, B. Drucken Sie Nummer B als digitales LED-Muster, wobei A die Skala ist.

Eingang:

1 2320451640799518

Ausgabe:

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

Eingang:

2 23

Ausgabe:

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

Regeln:

  • Verwenden Sie STDIN / STDOUT für die Ein- / Ausgabe

  • Code mit den meisten Up-Votes gewinnt. Im Falle von Unentschieden wird der kürzeste Code akzeptiert

  • Die am häufigsten gewählte Antwort wird am 01.02.2014 angenommen (Hat die Antwort mit den meisten 12 Stimmen angenommen)

War ich
quelle
2
Einige verwandte Fragen zum Stehlen / Inspirieren von Code: " Emulieren einer 7-Segment-Anzeige " und " LED-Zahlen und -Buchstaben ".
Darren Stone
@Wasi Danke. Ich habe deine Bearbeitung gesehen, die sie für mich geklärt hat.
C0deH4cker
Ihre 9 sollte den Unterstrich in der letzten Zeile haben, um wie 6 umgekehrt zu sein.
Tomas
1
@Tomas Danke für den Vorschlag. Aber wir haben bereits 13 Antworten, daher ist es unfair, sie weiter zu ändern :-)
Wasi
OK Wasi, aber ich hoffe es macht dir nichts aus, dass ich meine bevorzugte Form 9in meiner Antwort verwendet habe , da es mir besser gefällt :-)
Tomas

Antworten:

20

Commodore 64 BASIC

PETSCII Kunstregeln :)

LISTE

Ausgabe:

LAUF

Danko Durbić
quelle
3
Was ist mit der Ziffer 4 passiert? oO
Timwi
So schreibe ich Nummer 4, aber OK, ich habe das behoben :)
Danko Durbić
2
Faszinierend - schreiben Sie das auch so von Hand? Ist das in Schweden üblich oder woher Sie ursprünglich kommen?
Stand
Ich würde +100, wenn ich könnte.
Michael Kohl
12

Python 3, 286 282 280

Ja, ich habe diesen Golf gespielt. Schöne Herausforderung!

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



Außerdem gibt es hier eine Python 2-Version mit nur 273 Bytes!

Dieses Update wird nicht mehr mit weiteren Originalquellen aktualisiert. Dies wurde erstellt, als die ursprüngliche Quelle 282 Byte betrug (Python 3-Version).

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

Dies kann ein Betrug sein, also füge ich ihn separat hinzu. Lassen Sie mich wissen, ob dies als gültig angesehen wird oder nicht.

C0deH4cker
quelle
6

Haskell (389 Zeichen)

Die Lösung verwendet 7 Arrays, eines für jedes Segment des Arrays, wobei die Namen aus diesem Bild verwendet werden:

8 Segmentanzeige

. Der Wert a !! 4wird das Zeichen sein, das an dieser Stelle für die Zahl 4 angezeigt werden soll.

Die Werte werden gegebenenfalls mit der Skala multipliziert (unter Verwendung von rund rpfür die Replikation) und schließlich ausgedruckt.

Der Code

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

Anwendungsbeispiel

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

C 249 226 Zeichen

Golf Lösung in 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]);}

Mit zusätzlichen Leerzeichen:

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

Anmerkungen:

  • Es werden maximal 99 Stellen gedruckt
  • Das Verhalten ist undefiniert, wenn die Eingabe nicht korrekt formatiert ist (z. B. enthält sie keine Ziffern oder die Skala ist <1).
  • Sollte legal sein C89-Code

Ich werde erklären, wie es funktioniert, falls es jemanden interessiert.

reima
quelle
1
Nach dem, was ich auf dieser Seite gelesen habe, brauchen Sie "OK in C" nicht einzuschließen #include <stdio.h>(da es ohne C kompiliert wird.) Sie können auch ein int einfügen main(), z. B. main(x)1 Byte aussparen - obwohl es nicht gültig ist unterschreiben und scanfhineinstecken for: noch eine for(scanf("%d %98s", &s, &i); …)rasieren. - Schau mal hier .
Runium
@Sukminder Dies sind sehr hilfreiche Tipps, danke! Ich entfernte die #include, die bewegt scanfinnerhalb der for, entfernt , um die unnötige &in &i, und setzen Sie die intVariablen in globalen Bereich der statischen 0 Initialisierung zu nutzen. Der Code sollte jetzt noch legal sein C89, aber ich habe nicht gründlich geprüft. Ich glaube , setzt man intin mainnicht legal ist, so dass ich diese weggelassen.
Reima
Das Aufgeben der Standardkonformität kann sehr hilfreich sein. Beispielsweise können Sie intfür globale Variablen weglassen . Auch %98ssein kann %s(für längere Strings Sie sowieso nicht, tut es eine Rolle , in welcher Weise?)
ugoren
Gut! Ich habe eine "Art" ähnliche Philosophie verwendet, aber einfacher - 187 Zeichen in PERL
Tomas
5

Ruby 2.0

Schnelle und (nicht so) naive Ruby-Implementierung.

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}

Schnelle Erklärung:

Ich deklariere zuerst die Zeichenfolgen, die Ein-und Aus-Ziffern für horizontale und vertikale Balken darstellen.
Dann lese ich die Skala und die Ziffern.
Ich deklariere dann ein Array mit der erforderlichen Größe, um genügend Zeilen für den angegebenen Maßstab zu speichern. Die seltsame Zeichenfolge ist eigentlich eine Zuordnung von 7-Bit-Werten, die angeben, welche LEDs für jede Ziffer eingeschaltet werden sollen.
Als nächstes fülle ich für jede Ziffer das Ausgabearray von oben nach unten unter Berücksichtigung der horizontalen Skalierung.
Die letzte Schleife besteht darin, die Zeilen zu füllen, die nur vertikale Balken enthalten. Diese können nur aus den mittleren und unteren Zeilen generiert werden, indem horizontale Balken entfernt werden.
Schließlich drucke ich das Ausgabearray!

SirDarius
quelle
Können Sie erklären, was hier los ist?
Michael Stern
5

Python 2.6 ohne Importe. Ich würde sagen, dass die Attraktivität dieser Lösung die Verwendung von Vorlagen ist. Leider glaube ich, dass ich es deshalb so schwer hatte, es zu verdichten.

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)

Und ein bisschen kürzer (308 Zeichen):

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
quelle
Zu Ihrer Information, die Oberseite der Ziffern sollte "_" (Unterstriche) und keine Leerzeichen zwischen den Ziffern sein. Ich war zuerst verwirrt haha
C0deH4cker
5

(Bearbeiten: Diese Lösung ist jetzt ungültig, da sich die Semantik der Anweisung geändert hat. Ich habe nicht bemerkt, dass ich die Anweisung bereits verwendet habe, als ich sie geändert habe. Sie können dieses Programm jedoch korrigieren, indem Sie es einfach in ändern die neuere Anweisung .)

Sclipting - 85 Zeichen

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

Eingang:

1 1024856359701

Ausgabe:

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

Eingang:

2 47474747

Ausgabe:

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

Timwi
quelle
Können Sie das Programm reparieren? Den ganzen Nachstrich wegzulassen ist ziemlich hässlich.
n̴̖̋h̷͉̃a̷̭̿h̷̭̿d̷̰̀ĥ̷̳
Ich könnte natürlich das zu ändern , aber das würde diesen Eintrag zum Schummeln bringen, weil er erfunden wurde, nachdem diese Herausforderung veröffentlicht wurde.
Timwi
Ich denke nicht, dass es so ein Problem ist. Ich mache dein Programm sowieso nicht kürzer.
n̴̖̋h̴̖̋a̷̭̿h̷̭̿d̷̰̀ĥ̷̳
1
Nein, aber es würde eine wichtige Regel dieser Gemeinschaft verletzen.
Timwi
Verstößt nicht mehr gegen eine Regel: P
Nur ASCII
4

C # ( 480 443 Zeichen)

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

Erweiterte Version:

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

Meine Idee war es, die Aufgabe in 5 horizontale Linien aufzuteilen, die wiederum in einen linken, rechten und mittleren Teil für jeden Charakter aufgeteilt sind.

Rik
quelle
Vielleicht habe ich es falsch kopiert, aber ich habe versucht, es auf ideone auszuführen, und es gab einen Fehler. ideone.com/gQ6LH7
C0deH4cker
wahrscheinlich meine Schuld, lassen Sie mich sehen
Rik
1
@ C0deH4cker Ich habe die Eingabe in zwei getrennten ReadLines genommen. Dieser funktioniert: ideone.com/4jTxeu
Rik
1
@ C0deH4cker Ich habe eine Version erstellt, die die Eingabe wie angegeben nimmt und den unteren Teil der 9 löscht. Die Eingabe nimmt so viele Zeichen auf, die 9 kostet 1 extra.
Rik
1
Sie haben eine Redundanz ;(480); du kannst schreiben Action<z,z,z,int>q=(l,m,r,n)=>{...};(470); Sie können den ersten Parameter von ha machen charund das ""+Innere tun h(467); und schließlich können Sie deklarieren und wiederverwenden z d="134579",b="1237"(465). Das ist das kleinste, was ich bisher schaffen konnte
Timwi
3

Ich denke, es gibt sehr kurze Lösungen, aber da dies kein Code-Golf ist, bin ich ziemlich zufrieden!

Der PHP - Skript nimmt zwei Zahlen a, bvon STDIN und Echo bin LED - Format, aGröße.

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

BEARBEITEN: Im vorherigen Ausgabebeispiel habe ich fälschlicherweise angenommen, dass der Abstand zwischen den Ziffern so groß sein sollte wie die aGröße. Dies wurde mit der Erklärung des OP behoben, dass kein Platz benötigt wird.

Vereos
quelle
Eigentlich sollte es keine Leerzeichen zwischen den Ziffern geben. Der einzige Grund, warum das Beispiel so aussieht, sind die Leerzeichen, in denen das '|' wäre zum Beispiel auf einer 8. Ich habe eine Weile
gebraucht, um das
Oh, du hast recht! Vielen Dank :)
Vereos
2

C #, 435 359 473 Bytes

EDITS:

  • Redundanten Code entfernt. Reduzierte Bytegröße von Vergleichen.
  • Konvertiert in eine eigenständige Anwendung unter Verwendung des Standardeingangs.

Hier ist der Golf-Code (mit zusätzlichen Zeilenumbrüchen und Leerzeichen):

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
quelle
Sie sind gültige C # -Funktionen. Es wurde nie behauptet, dass es sich um ein eigenständiges Programm handeln sollte. Es wird jedoch kein Standard verwendet.
Hand-E-Food
@ Timwi, bearbeitet zu entsprechen ...
Hand-E-Food
1
Gut gemacht!! Ich habe etwas mehr Golf gespielt und es auf 425 reduziert (Zeichen; 432 Bytes in UTF-8), was es kürzer macht als die andere C # -Antwort. 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
Wenn Sie die Idee der anderen C # System
-Antwort verwenden
2

C ( 561 492 Bytes)

Autor ist frmar. Er hat mir letzte Woche seine Antwort geschickt (er hat seinen Account noch nicht erstellt).

492 Bytes, aber etwas verschleierter:

#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");}

Vorherige Version mit 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");}

Originalversion von 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");}

Zusammenstellung:

$ gcc -std=c99 -Wall print_as_led.c

Beispiele mit Standardanzahl, 0123456789aber unterschiedlichen Größen:

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

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

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

Andere Beispiele:

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

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

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

Größere Größen:

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

Perl + FIGlet + BRA * : 54 Zeichen

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

Ich dachte, dies wäre mit FIGlet recht einfach , aber es gab anscheinend keine geeigneten Schriftarten für diesen Zweck. Also habe ich welche gemacht :-)

So sieht es am Terminal aus:

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

* BRA: offensichtlicher Regelmissbrauch

zimperliches Ossifrage
quelle
Verstehe nicht, warum es dafür eine Ablehnung gibt. Schöner Trick mit Schriften!
VisioN
Ich habe nicht downvotiert, aber ich würde verstehen, dass das Verwenden eines Programms, anstatt das Programm tatsächlich zu machen , betrügt.
Tomas
1

PERL,   261 244 187   166 Zeichen

Ein bisschen bitweise Kodierungsphilosophie 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

Code mit Leerzeichen hinzugefügt:

($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 muss aufgerufen werden mit -n:

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

Anmerkungen:

  • Alles darüber, wie Ziffern angezeigt werden, ist in der Zeichenfolge kodiert Gl+%<UWm7=:-) Ein Zeichen entspricht einer Ziffer, kodiert sind 3 Stellen von 3 aufeinanderfolgenden Zeichen in der " _ _|_| |_ |"Zeichenfolge.
  • Zahlen werden zeilenweise in 3 Zeilen aufgebaut. Jede der 3 Zeilen entspricht einem Aufruf der Subroutine c, die auch das vertikale Zoomen für die zweite und dritte Zeile ausführt.
  • Das horizontale Zoomen erfolgt am Ende der Subroutine c.

Mein sedProgramm kann nicht zoomen, sieht aber viel besser aus, oder? :-)

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

Ziemlich genau die Idee, die mein PERL-Skript verwendet, aber in PERL ist es viel hässlicher. Beachten Sie, dass ich für mein sed-Programm lieber 9einen Unterstrich in der letzten Zeile verwendet habe, der umgekehrt aussieht 6.

Tomas
quelle
Ich habe mich gefragt, ob Sie erklären können, wie die Skalierung funktioniert. Ich versuche, meine eigene Version in Perl zu implementieren. Kann aber nicht scheinen, die vertikale und horizontale Skalierung richtig zu machen.
Hunter McMillen
0

C #, 386 382 364 Zeichen / 374 Byte (UTF-8) und (viel?) Raum für Verbesserungen ...

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

BEARBEITEN Mist ... Ich habe den Teil "Skala" verpasstCRAP

Ich werde es noch einmal versuchen, wenn ich dazu komme ..

RobIII
quelle
Ja, der Skalenteil macht es beängstigend.
cjfaure
0

J - 147 95 Zeichen

Erforderliche Skalierung hinzugefügt:

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

Kommentierte Version:

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]

Beispiel:

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

2 123
     --  -- 
|      |   |
|      |   |
     --  -- 
|   |      |
|   |      |
     --  -- 
jpjacobs
quelle
Wie beantwortet dies die Frage?
Wasi
Sie haben völlig Recht ... Ich werde es beheben
jpjacobs
Ihr Beispiel ist falsch. Beobachten Sie die Frage.
Tomas
0

Ruby, 126 ASCII-Zeichen

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

Jede Ziffer wird somit als Bitmap in Dritteln codiert, wobei jedes Drittel durch eine Oktalziffer dargestellt wird.

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

Da für alle Ziffern entweder das 64-Bit oder das 32-Bit gesetzt ist, liegt der Bereich zwischen 044 und 177 Oktal. Leider ist 177 das nicht druckbare DEL-Zeichen, daher enthält die magische Zeichenfolge die Zahlen 2 unter dem erforderlichen Bitmap-Code, und wir müssen in der Funktion wieder 2 hinzufügen.

Ungolfed im Testprogramm

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]

Ausgabe

C:\Users\steve>ruby 7seg.txt
4
0123456789
 ____        ____  ____        ____  ____  ____  ____  ____
|    |     |     |     ||    ||     |          ||    ||    |
|    |     |     |     ||    ||     |          ||    ||    |
|    |     |     |     ||    ||     |          ||    ||    |
|    |     | ____| ____||____||____ |____      ||____||____|
|    |     ||          |     |     ||    |     ||    |     |
|    |     ||          |     |     ||    |     ||    |     |
|    |     ||          |     |     ||    |     ||    |     |
|____|     ||____  ____|     | ____||____|     ||____| ____|
Level River St
quelle
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)}

Bisherige Lösungen:

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
quelle