Schreiben Sie das kürzeste Programm, das eine Folge von Zahlen (mit einer Länge von bis zu mindestens 20) als Eingabe verwendet, und zeigen Sie die Ausgabe mit den Standardnummern im Digitaluhrstil an. Zum Beispiel für Eingabe 81 würde eine Lösung mit ASCII-Ausgabe ergeben:

 _
|_|  |
|_|  |

Eine grafische Ausgabe ist ebenfalls akzeptabel, wenn dies hilfreich ist.

APL (Dyalog) (45)

{3 3⍴' _|'[1+⍵⊤⍨9⍴3]}¨⎕UCS'ા8धगɯે૙ࣃଏ૽'[1+⍎¨⍞]

Die Zeichenfolge ist ા8धगɯે૙ࣃଏ૽das Unicode-Zeichen 2750 56 2343 2327 623 2759 2777 2243 2831 2813(Sie sollten sie jedoch nur kopieren und einfügen können). Sie kodieren die Zahlen. Das Programm liest eine Zeile von der Tastatur.

Erläuterung:

• 1+⍎¨⍞: Liest eine Zeile von der Tastatur, parst jedes Zeichen als Ziffer und addiert dann 1 zu jeder Zahl (APL-Arrays basieren standardmäßig auf 1).
• ⎕UCS'ા8धगɯે૙ࣃଏ૽'[... ]: Wählen Sie die Zeichen aus, die zu den Ziffern der eingegebenen Zahlen gehören, und suchen Sie die Unicode-Werte.
• {... }¨: Führen Sie für jeden dieser Werte Folgendes aus:
• 1+⍵⊤⍨9⍴3: Ermitteln Sie die ersten 9 Stellen der Basis 3 aus dem in Basis 3 ausgedrückten Wert und addieren Sie 1 (da die Arrays auf 1 basieren).
• ' _|'[... ]: Wählen Sie abhängig von diesen Ziffern ein Leerzeichen, eine horizontale Linie oder eine vertikale Linie aus
• 3 3⍴: Format als 3-mal-3-Box.

Funktion

Nicht wirklich eine Sprache, die zum Golfen geeignet ist ... aber trotzdem habe ich versucht, die Codegröße so klein wie möglich zu halten - eine ganz andere Herausforderung als in "normalen" Sprachen. Dies sind 1555 Zeichen oder 3110 Bytes (wenn als UTF-16 codiert; UTF-8 ist größer).

Hier ist ein Screenshot des laufenden Programms. Es funktioniert wirklich :)

Da dies in StackExchange aufgrund des zusätzlichen Zeilenabstands hässlich aussieht, sollten Sie den folgenden Code in der JavaScript-Konsole Ihres Browsers ausführen, um dies zu beheben: $('pre').css('line-height',1)

     ╓─╖ ╔╗┌─╖   ┌─╖
     ║ʜ║ ║╟┤↔╟┐ ┌┤‼╟┐
     ╙┬╜ ╚╝╘═╝│ │╘╤╝│
╔═╗  ┌┴────┐  │┌┴╖ ┌┴╖
║0║ ┌┴─┐  ┌┴─┐└┤ʜ╟─┤·╟┐
╚╤╝┌┴╖┌┴╖┌┴╖┌┴╖╘╤╝ ╘╤╝│
┌┘┌┤·╟┤ɦ╟┤·╟┤?╟ │  ┌┴╖│
│ │╘╤╝╘╤╝╘╤╝╘╤╝ └──┤‼╟┘
│┌┴╖│ ┌┴╖┌┘╔═╧╗    ╘═╝
└┤?╟┘┌┤?╟┘┌╢10║    ┌─────────┐
 ╘╤╝ │╘╤╝┌┘╚══╝ ┌─┬┘╔══╗┌──╖┌┴╖ ╓─╖
  ┘  └───┘╔════╗│┌┴┐║21╟┤>>╟┤·╟┐║ɦ║
╔════════╗║1005╟┘└┬┘╚══╝╘═╤╝╘╤╝│╙┬╜        ┌─┐
║14073768║╚════╝ ┌┴╖ ┌─╖ ┌┴╖┌┴╖└─┴─────────┘┌┴╖
║7584800 ╟───────┤?╟─┤‼╟─┤ʜ╟┤·╟─────────────┤·╟┐╔═══════╗╔══╗
╚════════╝       ╘╤╝ ╘╤╝ ╘╤╝╘╤╝    ╔══╗┌─╖┌┐╘╤╝│║2097151║║21╟┐
 ╔═══════════════╗│   ┘   │  │     ║48╟┤−╟┤├─┤┌┘╚══╤════╝╚══╝│
 ║140737555464224╟┘  ┌────┘┌┬┘     ╚══╝╘╤╝└┘┌┘│╓─╖ │┌┐┌─╖┌─╖┌┴─╖
 ╚═══════════════╝   │ ┌───┘└─────────┐┌┴─╖ │┌┘║↔║ ├┤├┤‼╟┤↔╟┤>>║
┌────────────┐┌────┐┌┴╖│┌────────────┐├┤<<║ ││ ╙┬╜┌┘└┘╘╤╝╘═╝╘╤═╝
│   ╔══╗╔═══╗├┘╓─╖ └┤·╟┘│   ╔══╗╔═══╗├┘╘╤═╝ │└─┐└─┤╔═╗┌┴╖ ┌──┘
│   ║95║║892║│┌╢‡╟┐ ╘╤╝ │   ║95║║877║│ ┌┘╔══╧═╗│  │║0╟┤?╟┬┘
│   ╚═╤╝╚═╤═╝││╙─╜│  │  │   ╚═╤╝╚═╤═╝│╔╧╗║2097║│  │╚═╝╘╤╝│
│╔══╗┌┴╖┌┐│  ││┌─╖│ ┌┴╖ │╔══╗┌┴╖┌┐│  │║1║║151 ║│  └──────┘
│║32╟┤?╟┤├┤  │└┤‼╟┘┌┤‡║ │║32╟┤?╟┤├┤  │╚═╝╚════╝│
│╚══╝╘╤╝└┘└──┴┐╘╤╝ │╘╤╝ │╚╤═╝╘╤╝└┘└──┴┐      ┌─┘
│    ┌┴╖     ┌┴╖┌─╖│ │ ┌┴╖│  ┌┴╖     ┌┴╖ ┌─╖┌┴╖
│    │‼╟─────┤·╟┤‼╟┘ │┌┤·╟┘  │‼╟─────┤·╟─┤‼╟┤‡║
└┐┌┐ ╘╤╝     ╘╤╝╘╤╝  ││╘╤╝┌┐ ╘╤╝     ╘╤╝ ╘╤╝╘╤╝
 ├┤├┐┌┴╖╔══╗  └──┐┌┐ │└┐├─┤├┐┌┴╖╔══╗  ├──┐└  │
 │└┘└┤?╟╢32║╔═══╗├┤│┌┴╖││ └┘└┤?╟╢32║╔═╧═╗│┌┐┌┴╖╔══╗
╔╧══╗╘╤╝╚══╝║881╟┘│├┤?╟┘│    ╘╤╝╚══╝║325║└┤├┤?╟╢32║
║927║╔╧══╗  ╚═══╝ └┘╘╤╝╔╧═══╗╔╧══╗  ╚═══╝ └┘╘╤╝╚══╝
╚═══╝║124╟───────────┘ ║1019║║124╟───────────┘
     ╚═══╝             ╚════╝╚═══╝

Es könnte wahrscheinlich kleiner sein, wenn ich keinen Fehler gemacht hätte, aufgrund dessen die Ausgabe von hinten nach vorne lief. Ich habe das behoben, indem ich eine zusätzliche Funktion hinzugefügt habe, um die Eingabe umzukehren. Sonst müsste ich wahrscheinlich alles neu schreiben.

Ich habe auch einen weiteren Fehler gemacht (Vertauschen der Operanden in zwei Aufrufen von ‼), der es erforderlich machte, die zusätzliche ‡Funktion zu deklarieren , aber diese ist so klein, dass sie in die Hauptfunktion passt und daher keine Zeichen hinzufügt!

wxpython, viele zeichen

import wx, wx.gizmos as g

class T(wx.Frame):
 def __init__(_):
  wx.Frame.__init__(_, None, size = (800, 60))
  l = g.LEDNumberCtrl(_, -1)
  l.Value = raw_input()

class M(wx.App):
 def OnInit(_):
  T().Show()
  return 1

M().MainLoop()

Prüfung

echo -n 81 | python codegolf-997-wx.py

ps: kein seriöser eintrag, sieht aber so aus, als wäre eine grafische ausgabe auch akzeptabel, also habe ich es einfach mal ausprobiert :-)

Golfscript - 66 Zeichen

"placeholder text for userscript which counts chars             ";

xxd: ( xxd -rzum Zurücksetzen verwenden)

0000000: 332c 7b3a 533b 2e7b 3438 2d22 5e70 285d  3,{:S;.{48-"^p(]
0000010: 7025 d3c4 4ab1 7d4a b8dc 4469 ce41 2222  p%..J.}J..Di.A""
0000020: f303 227b 6261 7365 7d2f 3330 2f53 3d33  .."{base}/30/S=3
0000030: 2f3d 7b22 5f20 7c22 3d7d 257d 256e 407d  /={"_ |"=}%}%n@}
0000040: 2f3b                                     /;

Dies folgt den meisten anderen Antworten, dass es keine Leerzeichen zwischen den Zahlen und Leerzeichen in gehalten werden. Ein Raum zwischen den Zahlen können leicht hinzugefügt werden mit 1+vor {"_ |"=}%. Gepackt in eine Zahl zur Basis 3 und dann als Basis 243 in eine Zeichenfolge.

J, ^{90 , 78,} 68 Zeichen

[ Update: Verwenden der Unicode-Codierung (1 Byte):

,./(10 3 3$((90$3)#:256#.24x-~3&u:'%ė¨ÔW/~º»sy¡ăì<t÷²'){' _|'){~"./.Y
NB. utf characters are: 37 279 168 212 87 47 126 186 187 115 121 161 259 236 60 116 247 178

funktioniert wie bisher:]

,./(10 3 3$((90$3)#:1219424106940570763878862820444729939648410x){' _|'){~"./. '58321'
 _  _  _  _    
|_ |_| _| _|  |
 _||_| _||_   |

Der Schlüssel liegt in der Kodierung von Ziffern als Ganzzahlen zur Basis 3. Null ist zum Beispiel:

:
 _ 
| |
|_|

oder ' _ | ||_|'010202212 ₃ = 2750.

Mathematica 205 209 198 179

i = IntegerDigits; t = Thread; r = Rule;
z@n_ := Row@i@n /. t[r[Range[0, 9], Grid[Partition[ReplacePart[Characters@" _ |_||_|", 
t[r[#, ""]]], 3], Spacings -> 0] & 
/@ (i /@ {5, 24578, 49, 47, 278, 67, 6, 4578, , 78})]]

Verwendung

z@1234567890

JavaScript (145)

148 145

Da JavaScript nicht über die Standardeingabe / -ausgabe verfügt, wird dies als eine Funktion geschrieben, die eine Zeichenfolge verwendet und die Ausgabe als Zeichenfolge zurückgibt.

function r(n){for(i=o="",b=" |_\n|",L=n.length;i<3*L;)o+=b[(c="ǪĠòƲĸƚǚĢǺƺ".charCodeAt(n[i%L])>>(i++/L|0)*3)&1]+b[c&2]+b[c&4]+b[i%L?0:3];return o}

Abgetrennt aus:

function r(n)
{
    for (i = o = "", b = " |_\n|", L = n.length;   i < 3*L;   )
        o += b [ (c = "ǪĠòƲĸƚǚĢǺƺ".charCodeAt(n[i%L]) >> (i++/L|0)*3) & 1 ] +
             b [ c&2 ] +
             b [ c&4 ] +
             b [ i%L ? 0 : 3 ];  // space or newline
    return o
}

So funktioniert das:

• Jede Ziffernform ist in einem Unicode-Zeichen codiert, das aus 9 Bits besteht.

• Die ersten drei Bits sind für die erste Zeile usw.

• In jeder Gruppe von drei Bits gibt das erste an, ob das erste Zeichen |oder ein Leerzeichen ist, das zweite, ob es _oder ein Leerzeichen ist, und das dritte wiederum |oder ein Leerzeichen.

• Diese drei Bits werden abgerufen , wie c&1, c&2und c&4, die dann als Indizes in der Zeichenfolge verwendet b.

• Bei jeder Iteration i%List dies die „x-Koordinate“, dh die Ziffer innerhalb der Eingaben

• Bei jeder Iteration i/List die "y-Koordinate", dh die Zeile, aber wir müssen |0es eine ganze Zahl machen

• Schließlich werden die Leerzeichen zwischen den Ziffern und die Zeilenumbrüche zwischen den Zeilen auch durch Indizieren abgerufen b, wobei das Leerzeichen und die ansonsten nicht verwendete Position 3 in dieser Zeichenfolge erneut verwendet werden! :)

Rubin, 142

' _     _  _     _  _  _  _  _ 
| |  | _| _||_||_ |_   ||_||_|
|_|  ||_  _|  | _||_|  ||_| _|'.lines{|l|puts x.chars.map{|i|l[i.to_i*3,3]}*''}

erwartet eine Eingabe in die Variable x. Beispiele:

x = '321'
#  _  _    
#  _| _|  |
#  _||_   |

x = '42'
#      _ 
#  |_| _|
#    ||_ 

Golfscript - 97 Zeichen

:*{32' _':$@'14'{?~!=}:&~32}%n*{:x' |':|\'1237'&$x'017'&|x'56'&}%n*{:x|\'134579'&$x'147'&|x'2'&}%

Windows PowerShell, 127

$i="$input"[0..99]
'☺ ☺☺ ☺☺☺☺☺','♠☻♥♥♦♣♣☻♦♦','♦☻♣♥☻♥♦☻♦♥'|%{$c=$_
""+($i|%{('···0·_·0··|0·_|0|_|0|_·0|·|'-split0)[$c[$_-48]]})}

Da die Zeichenfolgen einige unangenehm zu schreibende Zeichen enthalten, können Sie einen Hexdump erstellen:

000: 24 69 3D 22 24 69 6E 70 │ 75 74 22 5B 30 2E 2E 39  $i="$input"[0..9
010: 39 5D 0A 27 01 00 01 01 │ 00 01 01 01 01 01 27 2C  9]◙'☺ ☺☺ ☺☺☺☺☺',
020: 27 06 02 03 03 04 05 05 │ 02 04 04 27 2C 27 04 02  '♠☻♥♥♦♣♣☻♦♦','♦☻
030: 05 03 02 03 04 02 04 03 │ 27 7C 25 7B 24 63 3D 24  ♣♥☻♥♦☻♦♥'|%{$c=$
040: 5F 0A 22 22 2B 28 24 69 │ 7C 25 7B 28 27 20 20 20  _◙""+($i|%{('
050: 30 20 5F 20 30 20 20 7C │ 30 20 5F 7C 30 7C 5F 7C  0 _ 0  |0 _|0|_|
060: 30 7C 5F 20 30 7C 20 7C │ 27 2D 73 70 6C 69 74 30  0|_ 0| |'-split0
070: 29 5B 24 63 5B 24 5F 2D │ 34 38 5D 5D 7D 29 7D     )[$c[$_-48]]})}

Fortan 186 175 Zeichen

Neue Version:

: s query parse-word bounds s" D@DD@DDDDDb`ddfFF`fff`Fd`df`f`" bounds do cr 2dup do i c@ '0 - j + c@ 3 0 do dup 3 and s"  _|" drop + 1 type 4 / loop drop loop 10 +loop bye ; s

Dies stört eigentlich auch das Beenden (+3 Zeichen) :). Hier ist die besser lesbare Version. Sie reduziert die LUT-Größe um ein Drittel. Der resultierende Code ist jedoch komplexer, sodass sich keine großen Einsparungen ergeben:

: 7s query parse-word bounds 
    s" D@DD@DDDDDb`ddfFF`fff`Fd`df`f`"
    bounds do 
        cr
        2dup do
            i c@ '0 - j + c@
            3 0 do
                dup 3 and
                s"  _|" drop + 1 type
                4 / \ shorter than an rshift
            loop
            drop
        loop
    10 +loop bye ;
7s

Alte Version:

: s query parse-word bounds s"  _     _  _     _  _  _  _  _ | |  | _| _||_||_ |_   ||_||_||_|  ||_  _|  | _||_|  ||_|  |" bounds do cr 2dup do i c@ '0 - 3 * j + 3 type loop 30 +loop ; s

Dies lässt den Stapel unausgeglichen und macht sich nicht die Mühe, den Interpreter zu verlassen. Hier ist eine übersichtlichere, besser lesbare Version

: 7s query parse-word bounds 
    s"  _     _  _     _  _  _  _  _ | |  | _| _||_||_ |_   ||_||_||_|  ||_  _|  | _||_|  ||_|  |"
    bounds do 
        cr
        2dup do
            i c@ '0 - 3 * j + 3 type
        loop
    30 +loop 2drop bye ;
7s

C # 369 Zeichen

static void Main(string[] a){var b = new[] {123,72,61,109,78,103,119,73,127,111};var g = new[]{" _  ","|","_","| ","|","_","| "};a[0].ToCharArray().SelectMany((x,w)=>g.Select((y,i)=>new{s=((b[x-48]>>i&1)==1)?y:new String(' ',y.Length),j=i,v=w})).GroupBy(z=>(z.j+2)/3).ToList().ForEach(q=>Console.WriteLine(String.Join("", q.OrderBy(l=>l.v).Select(k=>k.s).ToArray())));}

Ich könnte leicht ein paar Zeichen ausschneiden . Es ging mehr darum, LINQ zu missbrauchen :)

Mehr Whitespace-Version:

static void Main(string[] a)
{
    var b = new[] {123, 72, 61, 109, 78, 103, 119, 73, 127, 111};
    var g = new[] { " _  ", "|", "_", "| ", "|", "_", "| " };
    a[0].ToCharArray().SelectMany(
        (x,w)=>g.Select(
           (y,i)=>new{s=((b[x-48]>>i&1)==1)?y:new String(' ',y.Length),j=i,v=w}))
            .GroupBy(z=>(z.j+2)/3).ToList().ForEach(
            q=>Console.WriteLine(
                String.Join("", q.OrderBy(l=>l.v).Select(k=>k.s).ToArray())));
}

Java-Lösung: 585 570 Zeichen

Ich glaube nicht, dass ich in Java noch mehr Golf spielen werde ...

import java.util.*;
public class CG997{public static void main(String[]args){
short[][]lets=new short[][]{{0,1,3,2,0,4,2,1,4},{0,0,3,0,0,4,0,0,4},{0,1,3,0,1,
4,2,1,3},{0,1,3,0,1,4,0,1,4},{0,0,3,2,1,4,0,0,4},{0,1,3,2,1,3,0,1,4},{0,1,3,2,1
,3,2,1,4},{0,1,3,0,0,4,0,0,4},{0,1,3,2,1,4,2,1,4},{0,1,3,2,1,4,0,0,4}};
String[]syms=new String[]{" ","_","|","  ","| "};
String s=new Scanner(System.in).nextLine();
for(int o=0;o<3;o++){for(char c:s.toCharArray()){for(int i =0;i<3;i++)
System.out.print(syms[lets[Short.parseShort(c+"")][i+o*3]]);
}System.out.println();}}}

Python, 218 180 176

b=map(int,raw_input());a=map(int,bin(914290166014670372457936330)[2:]);c=' |_';p=lambda k:''.join(c[a[9*n+k]]+c[2*a[9*n+1+k]]+c[a[9*n+2+k]]for n in b)+'\n';print p(6)+p(0)+p(3)

Mit Zeilenumbrüchen:

b=map(int,raw_input())
a=map(int,bin(914290166014670372457936330)[2:])
p=lambda k:''.join(' |'[a[9*n+k]]+' _'[a[9*n+1+k]]+' |'[a[9*n+2+k]]for n in b)+'\n'
print p(6)+p(0)+p(3)

Bash, 11 Zeichen

toilet "$i"

Ja, ich weiß, ich betrüge.

Sie müssen Toilette installiert haben.

Java, 2.095

public class DigitalNumber {
    public static void main(String args[]){
        char[][] panel = new char[3][120]; //A 20 digit panel!
        int digXIndex = 0;int digYIndex = 0;
        for (int i=0;i<args[0].length(); i++){
            int dig=Integer.parseInt(""+args[0].charAt(i));
            panel[digXIndex][digYIndex]=32;   
            digYIndex++;
            if (dig!=1 && dig!=4)
                panel[digXIndex][digYIndex]='_';  
            else
                panel[digXIndex][digYIndex]=32;
            digYIndex++;
                panel[digXIndex][digYIndex]=32; 
            digYIndex=3*i;
            digXIndex++;
            if (dig!=1 && dig!=2 && dig!=3 && dig!=7)
                panel[digXIndex][digYIndex]='|';    
            else
                panel[digXIndex][digYIndex]=32;
            digYIndex++;
            if (dig!=1 && dig!=0 && dig!=7)
                panel[digXIndex][digYIndex]='_';    
            else
                panel[digXIndex][digYIndex]=32;
            digYIndex++;
            if (dig!=6 && dig!=5)
                panel[digXIndex][digYIndex]='|';  
            else
                panel[digXIndex][digYIndex]=32;
            digYIndex=3*i;
            digXIndex++;
            if (dig!=6 && dig!=8 && dig!=2 && dig!=0)
                panel[digXIndex][digYIndex]=32;  
            else
                panel[digXIndex][digYIndex]='|';
            digYIndex++;
            if (dig!=7 && dig!=4 && dig!=1)
                panel[digXIndex][digYIndex]='_';  
            else
                panel[digXIndex][digYIndex]=32;
            digYIndex++;
            if (dig!=2)
                panel[digXIndex][digYIndex]='|';  
            else
                panel[digXIndex][digYIndex]=32;
            digXIndex=0;
            digYIndex+=(i*3)+1;
        }       
        for (int i=0; i<3; i++){
            for (int j=0; j<120; j++)
                if (panel[i][j]!=0)
                System.out.print((char)(panel[i][j]));
                else
                    System.out.print("");
            System.out.println();
        }   
    }
}

BEISPIEL E / A

java DigitalNumber 98765432109876543210
     _  _  _  _  _     _  _     _  _  _  _  _  _     _  _     _ 
    |_||_|  ||_ |_ |_| _| _|  || ||_||_|  ||_ |_ |_| _| _|  || |
     _||_|  ||_| _|  | _||_   ||_| _||_|  ||_| _|  | _||_   ||_|

D: 295 Zeichen

import std.stdio;void main(string[]a){string[3]o;foreach(c;a[1]){int n=cast(int)(c)-48;auto e=" ";o[0]~=n!=1&&n!=4?" _ ":"   ";o[1]~=!n||n>3&&n!=7?"|":e;o[1]~=n>1&&n!=7?"_":e;o[1]~=n<5||n>6?"|":e;o[2]~=!(n&1)&&n!=4?"|":e;o[2]~=!n||n>1&&n!=4&&n!=7?"_":e;o[2]~=n!=2?"|":e;}foreach(l;o)writeln(l);}

Mehr leserlich:

import std.stdio;

void main(string[] a)
{
    string[3] o;

    foreach(c; a[1])
    {
        int n = cast(int)(c) - 48;
        auto e = " ";

        o[0] ~= n != 1 && n != 4 ? " _ " : "   ";

        o[1] ~= !n || n > 3 && n != 7 ? "|" : e;
        o[1] ~= n > 1 && n != 7 ? "_" : e;
        o[1] ~= n < 5 || n > 6 ? "|" : e;

        o[2] ~= !(n&1) && n != 4 ? "|" : e;
        o[2] ~= !n || n > 1 && n != 4 && n != 7 ? "_" : e;
        o[2] ~= n != 2 ? "|" : e;
    }

    foreach(l; o)
        writeln(l);
}

Ocaml, 268

let t=function|'1'|'4'->"   "|_->" _ "let m=function|'0'->"| |"|'1'|'7'->"  |"|'2'|'3'->" _|"|_->"|_|"|'5'|'6'->"|_ "let b=function|'0'|'8'->"|_|"|'1'|'4'|'7'->"  |"|'2'->"|_ "|_->" _|"let f s=let g h=String.iter(fun c->print_string(h c))s;print_newline()ing t;g m;g b

Lesbare Version

let t = function
  | '1'
  | '4' -> "   "
  | _ -> " _ "
let m = function
  | '0' -> "| |"
  | '1'
  | '7' -> "  |"
  | '2'
  | '3' -> " _|"
  | _ -> "|_|"
  | '5'
  | '6' -> "|_ "
let b = function
  | '0'
  | '8' -> "|_|"
  | '1'
  | '4'
  | '7' -> "  |"
  | '2' -> "|_ "
  | _ -> " _|"
let f s =
  let g h =
    String.iter (fun c -> print_string (h c)) s;
    print_newline () in
  g t;
  g m;
  g b

Perl (182 180)

#!perl -l
$_=<<7;
 _     _  _     _  _  _  _  _ 
| |  | _| _||_||_ |_   ||_||_|
|_|  ||_  _|  | _||_|  ||_| _|
7
@b=map{[/(...)/g]}split/\n/;@d=split//,<>;for$p(@b){print map$p->[$_],@d}

liest aus STDIN.

$ perl 7segment.pl 
1234567890987654321
    _  _     _  _  _  _  _  _  _  _  _  _  _     _  _     _ 
  | _| _||_||_ |_   ||_||_|| ||_||_|  ||_ |_ |_| _| _|  || |
  ||_  _|  | _||_|  ||_| _||_| _||_|  ||_| _|  | _||_   ||_|

Ghostscript (270) (248) (214)

Bearbeiten: Weitere Substitutionen. Leerzeichen zwischen den Ziffern entfernt.

Edit: Noch mehr Substitutionen. Die Hauptschleife sieht jetzt so aus, wie sie funktioniert!

/F{forall}def[48<~HUp;::1ncBInp~>{1 index 1 add}F
pop/*{dup
2 idiv exch
2 mod
1 eq}/P{print}/#{( )P}/?{ifelse
P}/O{{( )}?}/|{*{(|)}O}/_{*{(_)}O}>>begin[[[[ARGUMENTS{{load
# _ #}F()=]2{{| _ |}F()=]}repeat]pop[[[[}F

Verwendet die Argumentverarbeitungsfunktion von ghostscript: Rufen Sie mit auf gs -dNODISPLAY -- digit.ps 012 345 6789.

Delphi || 453 (568 Mit Format)

Nicht einmal nah genug, um zu gewinnen, aber es hat Spaß gemacht, das zu tun

const asc: array[0..9] of array[0..2] of string = ((' _ ','| |','|_|'),('   ','  |','  |'),(' _ ',' _|','|_ '),(' _ ',' _|',' _|'),('   ','|_|','  |'),(' _ ','|_ ',' _|'),(' _ ','|_ ','|_|'),(' _ ','  |','  |'),(' _ ','|_|','|_|'),(' _ ','|_|',' _|'));var s,l:string;x,i:integer;begin Readln(s);s:=StringReplace(s,' ','',[rfReplaceAll]);for I := 0 to 2 do begin l:='';for x := 1 to length(s) do l := l + asc[StrToInt(s[x])][i];writeln(l);end;readln;end.  

Mit Format

const
asc: array[0..9] of array[0..2] of string = (
  (' _ ','| |','|_|'),
  ('   ','  |','  |'),
  (' _ ',' _|','|_ '),
  (' _ ',' _|',' _|'),
  ('   ','|_|','  |'),
  (' _ ','|_ ',' _|'),
  (' _ ','|_ ','|_|'),
  (' _ ','  |','  |'),
  (' _ ','|_|','|_|'),
  (' _ ','|_|',' _|'));
var
s,l:string;
x,i:integer;
begin
    Readln(s);
    s:=StringReplace(s,' ','',[rfReplaceAll]);
    for I := 0 to 2 do
    begin
      l:='';
      for x := 1 to length(s) do
        l := l + asc[StrToInt(s[x])][i];
      writeln(l);
    end;
    readln

Ende.

PHP, 140 136 133 131 129 128 Bytes

^{Ich könnte mit Extended ASCII 5 7 mehr sparen : je eins für "| _"und den Zeilenumbruch, drei für ~"z/]{4lno~|"(bitweise Negation würde alles zu Extended ASCII-Zeichen machen = keine Sonderzeichen, und PHP benötigt dort keine Anführungszeichen), zwei für -1(es ist nur dort, um die Karte in Standard-ASCII zu halten). Aus Gründen der Lesbarkeit und Kompatibilität bleibe ich jedoch bei Standard-ASCII.}

for(;""<$c=$argv[1][$i++];)for($n=753754680;$n>>=3;)$r[$p++%3].="| _"[ord(~"z/]{4lno~|"[$c])-1>>$n%8&1?:$n&2];echo join("
",$r);

die Bitmap

• Nehmen Sie LEDS _, |_|, |_|als Bits -6-,024 ,135 (Bitnummer & 2 ist 0 für vertikale LEDs)
• Erstellen Sie Bitmaps für die Nummern 0..9: [123,48,94,124,53,109,111,112,127,125]
• Verringern Sie den Wert um 1, damit alle ASCII-Codes gedruckt werden können -> "z/]{4lno~|"
• negieren -> ~"z/]{4lno~|"(erlaubt ternäre Abkürzung bei der Zeichenauswahl)

Die Vorlage

• Verwendung 7für die Räume -> 767, 024,135
• Neugruppierung von Spalten anstelle von Zeilen -> 701, 623, 745(rendert$p=0 veraltet)
• umkehren -> 547326107 (Karte von rechts nach links lesen; ermöglicht arithmetisches Looping)
• Null anhängen -> 5473261070 (ermöglicht die Kombination von Shift und Test im Schleifenkopf)
• Oktal lesen, in Dezimalzahl konvertieren -> 753754680(zwei Bytes kürzer: eine Ziffer und das Präfix)

Nervenzusammenbruch

for(;""<$c=$argv[1][$i++];) // loop through input characters
    for($n=753754680;$n>>=3;)   // loop through template
        $r[$p++%3].="| _"[          // append character to row $p%3:
            ord(~"z/]{4lno~|"[$c])-1// decode bitmap
                >>$n%8&1            // test bit $n%8 (always 1 for bit 7)
            ?                       // if set: 1 (space)
            :$n&2                   // else: 2 (underscore) for bits 2,3,6; 0 (pipe) else
        ];
echo join("\n",$r);         // print result

Java 8, 280 Bytes

interface M{static void main(String[]a){String x="",y=x,z=x;for(int c:a[0].getBytes()){c-=48;x+=" "+(c==4|c==1?" ":"_")+" ";y+=(c==7|c>0&c<4?" ":"|")+(c==7|c<2?" ":"_")+(c>4&c<7?" ":"|");z+=(c%2<1&c!=4?"|":" ")+(c%3==1?" ":"_")+(c==2?" ":"|");}System.out.print(x+"\n"+y+"\n"+z);}}

Erläuterung:

Probieren Sie es hier aus.

interface M{                     // Class
  static void main(String[]a){   //  Mandatory main-method
    String x="",                 //   String for row 1, starting empty
           y=x,                  //   String for row 2, starting empty
           z=x;                  //   String for row 3, starting empty
    for(int c:a[0].getBytes()){  //   Loop over the bytes of the input
      c-=48;                     //    Convert the byte to integer
      x+=                        //    Append to row 1:
         " "                     //     a space
         +(c==4|c==1?            //     +If the digit is a 1 or 4:
            " "                  //       Append a space
           :                     //      Else:
            "_")                 //       Append an underscore
         +" ";                   //     + another space
      y+=                        //    Append to row 2:
         (c==7|c>0&c<4?          //      If the digit is 1, 2, 3, or 7:
           " "                   //       Append a space
          :                      //      Else:
           "|")                  //       Append a pipe
         +(c==7|c<2?             //     +If the digit is 0, 1, or 7:
            " "                  //       Append a space
           :                     //      Else:
            "_")                 //       Append an underscore
         +(c>4&c<7?              //     +If the digit is 5 or 6:
            " "                  //       Append a space
           :                     //      Else:
            "|");                //       Append a pipe
      z+=                        //    Append to row 3:
         (c%2<1&c!=4?            //      If the digit is 0, 2, 6 or 8:
           "|"                   //       Append a pipe
          :                      //      Else:
           " ")                  //       Append a space
          +(c%3==1?              //     +If the digit is 1, 4, or 7:
             " "                 //       Append a space
            :                    //      Else:
             "_")                //       Append a pipe
          +(c==2?                //     +If the digit is 2:
             " "                 //       Append a space
            :                    //      Else:
             "|");               //       Append a pipe
    }                            //   End of loop
    System.out.print(x+"\n"+y+"\n"+z);
                                 //   Print the three rows
  }                              //  End of main-method
}                                // End of class

Als Funktion wären dies stattdessen 218 Bytes .

Python, 227 Zeichen

a="   ";b=" _ ";c="|_|";d="| |";e="|  ";f="  |";g="|_ ";h=" _|"
z=[[b,d,c],[a,f,f],[b,h,g],[b,h,h],[a,c,f],[b,g,h],[b,g,c],[b,f,f],[b,c,c],[b,c,h]]
x=map(int,raw_input())
for i in range(3):
 for j in x:
  print z[j][i],
 print

Einfach und unkompliziert.

Perl, 145 Zeichen

$i=<>;for$s(6,3,0){for($i=~/./g){$v=(175,9,158,155,57,179,183,137,191,187)[$_]>>$s;$o.=($v&4?'|':$").($v&2?'_':$").($v&1?'|':$")}$o.="
"}print$o

Ungolfed:

# Read STDIN
$i = <>;
# Amount to bit shift later
for $s (6,3,0)
{
  # For each character C from STDIN
  for ($i =~ /./g)
  {
    # Get the Cth array index, bit shifted right by $s
    $v = (175, 9, 158, 155, 57, 179, 183, 137, 191, 187)[$_]>>$s;
    # Concatenate each character if the bitwise masked value says it should be there
    $o .= ($v & 4 ? '|' : $") .
          ($v & 2 ? '_' : $") .
          ($v & 1 ? '|' : $");
  }
  # Concatenate a newline
  $o .= "
";
}
# Print the result
print $o;

Python 3.4.3 - 1514 858 Bytes

Die Versuchung, dies zu lösen, war zu groß, um sich nicht anzumelden und zu antworten = P

Ich bin ein bisschen neu in Python, also habe ich mein Programm schön und ordentlich formatiert (oder zumindest habe ich es getan). Verbesserungen werden sehr geschätzt!

import sys;l1,l2,l3,l4,l5="";num=input()
for c in num:
    if c=="1":
        l1+=" oo  ";l2+="  o  ";l3+="  o  ";l4+="  o  ";l5+="oooo "
    if c=="2":
        l1+="oooo ";l2+="   o ";l3+="oooo ";l4+="o    ";l5+="oooo "
    if c=="3":
        l1+="oooo ";l2+="   o ";l3+=" ooo ";l4+="   o ";l5+="oooo "
    if c=="4":
        l1+="o  o ";l2+="o  o ";l3+="oooo ";l4+="   o ";l5+="   o "
    if c=="5":
        l1+="oooo ";l2+="o    ";l3+="oooo ";l4+="   o ";l5+="oooo "
    if c=="6":
        l1+="oooo ";l2+="o    ";l3+="oooo ";l4+="o  o ";l5+="oooo "
    if c=="7":
        l1+="oooo ";l2+="   o ";l3+="   o ";l4+="   o ";l5+="   o "
    if c=="8":
        l1+="oooo ";l2+="o  o ";l3+="oooo ";l4+="o  o ";l5+="oooo "
    if c=="9":
        l1+="oooo ";l2+="o  o ";l3+="oooo ";l4+="   o ";l5+="oooo "
    if c=="0":
        l1+="oooo ";l2+="o  o ";l3+="o  o ";l4+="o  o ";l5+="oooo "
print(l1+"\n"+l2+"\n"+l3+"\n"+l4+"\n"+l5)

Bearbeiten: Verkürzte Variablennamen, verwendet; zu verkürzen, nur ein Leerzeichen am Ende der Ausgabenummern, definierte Variablen auf einmal.

Neue Zeilen bestehen aus 2 Byte (CRLF) und ich habe Tabulatoren anstelle von 4 Leerzeichen verwendet.

SmileBASIC, 216 Bytes

?INPUT N$DIM A[14]COPY A,@A@A
DATA 1,0,0,1,3,1,1,3,0,4,3,4,1,6FOR D=0 TO LEN(N$)-1X=ASC("w$]m.k{%\o"[VAL(N$[D])])FOR I=0TO 6T=I*2IF X<<31THEN GBOX A[T]+D*5,A[T+1],A[T]+D*5+!(I MOD 3),A[T+1]+!!(I MOD 3)
X=X/2NEXT
NEXT

Verwenden Sie Grafiken anstelle von Text, da dieser wahrscheinlich kürzer ist.

Erläuterung:

PRINT 'so the input and output don't overlap
INPUT NUMBER$ 'get number
DIM PTS[7*2] 'locations of segments
COPY PTS,@PTDATA 'copy data into array
@PTDATA
DATA 1,0,0,1,3,1,1,3,0,4,3,4,1,6 'stored as x,y,x,y,...
FOR DIGIT=0 TO LEN(NUMBER$)-1
 NUM=ASC("w$]m.k{%\o"[VAL(NUMBER$[DIGIT])]) 'get digit data. That data string doesn't have any non-ASCII characters, except \ which is 127 in SB.
 FOR I=0 TO 7-1 'draw each segment
  T=I*2 'position of point in array
  IF X AND 1 THEN GLINE PTS[T]+DIGIT*5,PTS[T+1],PTS[T]+DIGIT*5+!(I MOD 3),PTS[T+1]+!!(I MOD 3) 'draw segment. I MOD 3 determines whether it's horizontal or vertical.
  X=X>>1 'shift to next bit
 NEXT
NEXT

C ++, 230 229 225 223 218 207 204 198 Bytes

#import<iostream>
#define d for(auto
std::string v[3],t,g="|_| =2$0^262\'032;2$2?272";main(){std::cin>>t;d i:t)d j:{0,1,2})d k:{0,1,2})v[k]+=g[g[i*2-92+!k]>>j+k/2*3&1?j:3];d j:v)std::cout<<j<<'\n';}

Liest von stdin und gibt nach stdout aus.

Erläuterung:

#import<iostream>                // string inside

std::string v[3], t, g="|_| "    // symbol on different horizontal position
      "=2$0^262\'032;2$2?272";   // space(0) or not(1) for each number and position
                                 // binary representation, last 6 bits is used
                                 // even positions are for row 1, 2; odds are for row 0

main() {
    std::cin>>t;                 // input
    for (auto i:t)               // for each character
        for (auto j:{0,1,2})     // for each horizontal position
            for (auto k:{0,1,2}) // for each vertical position
                v[k]+=g[         // use first four chars only
                    g[i*2-92     // i*2-96 is number*2, +4 to skip first four
                        +!k]     // row 0 uses another character
                    >>j+k/2*3    // (k==2?3:0)+j, the expected bit
                    &1           // extract the bit
                    ?j:3         // space or not space
                ];

    for (auto j:v) std::cout<<j<<'\n'; // output
}

Powershell, 114 Bytes

param($a)6,3,0|%{$l=$_
-join($a|% t*y|%{('   0 _ 0 _|0|_ 0| |0  |0|_|'-split0)[(+('f-SR5Z^mvr'["$_"])-shr$l)%8]})}

Testskript:

$f = {

param($a)6,3,0|%{$l=$_
-join($a|% t*y|%{('   0 _ 0 _|0|_ 0| |0  |0|_|'-split0)[(+('f-SR5Z^mvr'["$_"])-shr$l)%8]})}

}

&$f "1234567890"
&$f "81"

Ausgabe:

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

Hauptidee:

Jede Standardnummer im Digitaluhrstil enthält 3 Zeilen. Darüber hinaus enthält die erste Zeile nur 2 Optionen. Insgesamt 6 Optionen. Daher sind 7 Bits ausreichend, um jede Ziffer zu codieren.

line str=@('   ', ' _ ', ' _|', '|_ ', '| |', '  |', '|_|')

#    line str    binary       dec    ASCII
-    --------    ---------    ---    -----
0 -> 1 
     4 
     6        -> 1 100 110 -> 102 -> 'f'

1 -> 0
     5
     5        -> 0 101 101 ->  45 -> '-'

...

8 -> 1
     6
     6        -> 1 110 110 -> 118 -> 'v'

9 -> 1
     6
     2        -> 1 110 010 -> 114 -> 'r'

Die Zeichenfolge f-SR5Z^mvrcodiert also alle Segmente für alle Standardnummern im Digitaluhrstil.

Hinweis: Die Reihenfolge der line strwurde speziell so gewählt, dass alle Codes im Intervall lagen 32..126.