将数字转换为7段显示模式

28

给定两个任意数字A，B。将数字B打印为数字LED图案，其中A是刻度。

输入：

1 2320451640799518

输出：

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

输入：

2 23

输出：

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

规则：

  • 使用STDIN / STDOUT进行输入/输出

  • 以最多票数获胜的代码。如果是领带，将接受最短的代码

  • 投票最多的答案将在01/02/2014被接受（以最高12票接受此答案）

ascii-art  popularity-contest 
— 瓦西
source
2
有关代码窃取/启发的一些相关问题：“ 模拟7段显示器 ”和“ LED数字和字母 ”。
— 达伦·斯通
@Wasi谢谢。我看到了您所做的修改，已为我清除了。
— C0deH4cker 2014年
您的9应该在最后一行加上下划线，就像颠倒的
— Tomas
1
@Tomas感谢您的建议。但是，我们已经有了13个答案，因此进一步对其进行更改将是不公平的:-)
— Wasi 2014年
好的，瓦西，但我希望你不要介意我9在回答中使用了我喜欢的形状，因为我更喜欢它：-)
— Tomas

Answers:

12

Python 3中，286 282 280

是的，我打了这个。好挑战！

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


另外，这是Python 2版本，仅重273个字节！

不再用更多原始的高尔夫源更新此内容。它是在原始源为282字节（Python 3版本）时创建的。

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

这可能是作弊，所以我将其单独添加。让我知道这是否有效。

— C0deH4cker
source
6

Haskell（389个字符）

该解决方案使用7个数组，每个数组对应一个数组，并使用此映像中的名称：

8 segment display

。该值a !! 4将是应在数字4的那个位置显示的字符。

将这些值乘以适当的小数位数（使用r和rp进行复制），最后打印出来。

代码

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

用法示例

echo '1 2320451640799518' | runhaskell ./digit_led.hs
 _  _  _  _     _     _     _  _  _  _  _     _ 
 _| _| _|| ||_||_   ||_ |_|| |  ||_||_||_   ||_|
|_  _||_ |_|  | _|  ||_|  ||_|  |  |  | _|  ||_|
— 大卫·米亚尼（David Miani）
source
6

C，249226个字符

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

加上空白：

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

笔记：

  • 最多打印99位
  • 如果输入格式不正确（例如，包含非数字或小数位数<1），则行为不确定
  • 应该是合法的C89代码

如果有人关心，我将提供其工作原理的解释。

— 灵玛
source
1
根据我在此页面上阅读的内容，什么是“ OK in C”，您不需要将其包括在内#include <stdio.h>（因为它将在没有C的情况下进行编译。）您也可以将一个int放入其中main()，例如main(x)，舍弃1个字节-尽管无效签名，并把scanf里面for：for(scanf("%d %98s", &s, &i); …)多一个的剃须。– 在这里看看。
— Runium 2014年
@Sukminder这些是非常有用的提示，谢谢！我删除了#include，在其中移动了，scanf在中for删除了不必要&的&i，然后将int变量放在全局范围内以利用静态0初始化。该代码应现在仍然是合法的C89，但我没有彻底检查。我相信，把一个int中main是不合法的，所以我离开了这一点。
— reima 2014年
放弃标准合规性可以有很大帮助。例如，您可以省略int全局变量。也%98s可以%s（对于更长的字符串，无论如何您都会失败，这有什么关系吗？）
— ugoren 2014年
好！我使用了“类似”的哲学，但更简单-PERL中的187个字符
— Tomas
5

Ruby 2.0

快速和（不是这样）天真的红宝石实现。

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}

快速说明：

我首先声明代表水平和垂直条的开和关数字的字符串。
然后，我阅读刻度和数字。
然后，我声明一个必要大小的数组，以存储给定比例的足够行。奇怪的字符串实际上是7位值的映射，表示每个数字要打开的LED。
接下来，考虑到水平缩放比例，对于每个数字，我从上到下填充输出数组。
最后一个循环是填充仅包含竖线的行，只需删除横杠即可从中间和底部的行生成竖线。
最后，我打印输出数组！

— 达里乌斯爵士
source
您能解释一下发生了什么吗？
— Michael Stern 2014年
5

没有导入的Python 2.6。我想说这种解决方案的吸引力在于模板的使用。不幸的是，我认为这就是为什么我很难整理它。

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)

还有一点（308个字符）：

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
source
仅供参考，数字的顶部应该是“ _”（下划线），并且数字之间没有空格。我一开始就感到困惑哈哈
— C0deH4cker 2014年
5

（编辑：此解决方案现在无效，因为銻指令的语义已更改。我没有意识到更改指令时已经使用了该指令。但是，您可以通过简单地将其更改为较新的说明壹。）

滑动 -85个字符

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

①

输入：

1 1024856359701

输出：

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

②

输入：

2 47474747

输出：

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

— Timwi
source
您可以修复该程序吗？不考虑整个中风是很丑陋的。
— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ 2014年
我当然可以将更銻改为壹，但这会使该条目作弊，因为它壹是在发布此挑战后发明的。
— Timwi 2014年
我认为这不是什么大问题。无论如何，我不会缩短您的程序。
— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ 2014年
1
不，但是这会违反该社区的重要规则。
— Timwi 2014年
不再违反规则：P
— ASCII仅限
4

C＃（480 443个字符）

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

扩大的视野：

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

我的想法是将任务分成5条水平线，然后依次将每个字符分为左右，中部。

— 里克
source
也许我复制错了，但是我尝试在ideone上运行它，但它给出了一个错误。ideone.com/gQ6LH7
— C0deH4cker 2014年
可能是我的错，让我看看
— Rik 2014年
1
@ C0deH4cker我在两个单独的ReadLines中接受了输入。这个作品：ideone.com/4jTxeu
— Rik
1
@ C0deH4cker我制作了一个版本，该版本接受指定的输入，并删除了9的底部。该输入使用了尽可能多的字符，这9个额外花费了1个字符。
— 里克2014年
1
你那里有多余;的东西（480）；你可以写Action<z,z,z,int>q=(l,m,r,n)=>{...};（470）; 您可以设置ha 的第一个参数char并进行""+内部h运算（467）; 最后，您可以声明并重新使用z d="134579",b="1237"（465）。那是迄今为止我能做到的最小的事
— Timwi'1
3

我猜有很短的解决方案，但是由于这不是代码高尔夫，所以我很满意！

这个PHP脚本将使用两个数字 a，大小分别b为STDIN和bLED格式的echo a。

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

编辑：看前面的输出示例，我错误地认为数字之间的间距应与a大小。OP声明不需要空间，此问题已得到修复。

— 韦里奥
source
实际上，数字之间不应有任何空格。样本看起来像这样的唯一原因是空格是“ |”所在的位置 例如将是8。花了我一段时间才能弄清楚
— C0deH4cker 2014年
哦，对了！谢谢您：)
— Vereos 2014年
2

C＃，435 359 473字节

编辑：

  • 删除了冗余代码。减少了比较的字节大小。
  • 使用standard in作为输入转换为独立应用程序。

这是高尔夫代码（带有换行符和空格）：

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;
    }
}
— 手工电子食品
source
它们是有效的C＃函数。从来没有说过它应该是一个独立程序。但是，它不使用标准英寸
— 手工E-食品
@Timwi，经过编辑以符合标准……
— Hand-E-Food
1
做得好！！我打了很多球，然后我将其降低到425个（字符； UTF-8中的432个字节），使其比其他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 2014年
1
使用其他C＃答案将所有内容放入System命名空间的想法，它将结果降至423
— Timwi 2014年
2

C（561 492个字节）

作者是frmar。他上周向我发送了他的答案（他尚未创建帐户）。

492个字节，但更加模糊：

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

先前版本使用561个字节：

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

frmar的原始版本（623字节）：

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

汇编：

$ gcc -std=c99 -Wall print_as_led.c

使用默认0123456789编号但大小不同的示例：

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

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

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

其他例子：

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

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

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

较大的尺寸：

$ ./a.out 4 42
       ____
|    |     |
|    |     |
|    |     |
|____| ____|
     ||
     ||
     ||
     ||____
$ ./a.out 5 42
        _____
|     |      |
|     |      |
|     |      |
|     |      |
|_____| _____|
      ||
      ||
      ||
      ||
      ||_____
— 寡头
source
1

Perl + FIGlet + BRA *：54个字符

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

我认为使用FIGlet很容易做到这一点，但是似乎没有任何合适的字体可用于此目的。所以我做了一些:-)

这是终端上的外观：

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

* BRA：公然违反规则

— 吱吱作响的骨
source
不知道为什么有反对的理由。字体不错！
— VisioN 2014年
我不是downvoting，但我明白，使用一个程序，而不是实际制作的节目是一种欺骗行为。
— 托马斯
1

PERL，  261 244 187   166个字符

一点点的按位编码原理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

添加空格的代码：

($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必须通过调用-n：

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

笔记：

  • 关于数字显示方式的所有信息都编码在字符串中Gl+%<UWm7=：-)一个字符对应一个数字，编码是在字符中3个连续字符的3个位置" _ _|_| |_ |"字符串。
  • 数字由3行构成，一行一行。3行中的每一行对应于一个对子例程的调用c，该还完成了第二行和第三行的垂直缩放。
  • 在子例程的末尾进行水平缩放c。

我的sed程序无法缩放，但看起来好多了，不是吗？:-)

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

我的PERL脚本使用的想法差不多，但是在PERL中要难看得多。请注意，对于我的sed程序，我更喜欢使用9在最后一行带有下划线的工具，就像反转6一样。

— 托马斯
source
我想知道您是否可以解释扩展的工作原理，我正在尝试在Perl中实现自己的版本。但是似乎无法正确实现垂直和水平缩放。
— 亨特·麦克米伦
0

C＃，386个 382 364字符/ 374个字节（UTF-8）和（很多？）的改进空间...

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

编辑 废话...我错过了“规模”部分抓取

如果我熟悉它，我会再给它一个镜头。

— 罗比三世
source
是的，比例尺部分使它感到恐惧。
— cjfaure 2014年
0

J-147 95字符

添加了所需的缩放比例：

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

带注释的版本：

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]

例：

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

2 123
     --  -- 
|      |   |
|      |   |
     --  -- 
|   |      |
|   |      |
     --  --
— jpjacobs
source
这如何回答这个问题？
— Wasi
您绝对正确...我会解决的
— jpjacobs 2014年
您的示例不正确。观看问题。
— 托马斯2014年
0

Ruby，126个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}}

每个数字因此被编码为位图，以三分之二表示，每个三分之一由八进制数字表示。

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

由于所有数字都设置了64位或32位，因此范围是八进制044到177八进制。不幸的是177是不可打印的DEL字符，因此魔术字符串在所需的位图代码下方包含数字2，我们必须在函数中重新添加2。

取消测试程序

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]

输出量

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

先前的解决方案：

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
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.