28

दो मनमानी संख्याओं को देखते हुए ए, बी। एक डिजिटल एलईडी पैटर्न के रूप में प्रिंट नंबर बी जहां ए पैमाने है।

इनपुट:

1 2320451640799518

ouput:

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

इनपुट:

2 23

ouput:

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

नियम:

इनपुट / आउटपुट के लिए STDIN / STDOUT का उपयोग करें
अधिकांश अप-वोट जीत के साथ कोड। टाई के मामले में, सबसे छोटा कोड स्वीकार किया जाएगा
अधिकांश मतदान वाले उत्तर को 01/02/2014 को स्वीकार किया जाएगा ( इस उत्तर को उच्चतम 12 मतों के साथ स्वीकार किया जाएगा )

ascii-art popularity-contest

— क्या मै था
स्रोत

2

कोड चोरी / प्रेरणा के लिए कुछ संबंधित प्रश्न: " एक 7-खंड प्रदर्शन का अनुकरण करें " और " एलईडी नंबर और पत्र "।

— डैरेन स्टोन

@ धन्यवाद धन्यवाद। मैंने आपका संपादन देखा जिसने इसे मेरे लिए मंजूरी दे दी।

— C0deH4cker

आपका 9 अंतिम पंक्ति में अंडरस्कोर होना चाहिए, उलटा होने की तरह 6.

— टॉमस

1

@ टॉमस सुझाव के लिए धन्यवाद। लेकिन, हमारे पास पहले से ही 13 उत्तर हैं, इसलिए इसे आगे बदलना अनुचित होगा :-)

— वासि

ओके वासी लेकिन मुझे आशा है कि आपको कोई आपत्ति नहीं है कि मैंने अपने उत्तर9 में अपने पसंदीदा आकार का उपयोग किया है , क्योंकि मुझे यह अधिक पसंद है :-)

— टॉमस

20

कमोडोर 64 बुनियादी

PETSCII कला नियम :)

सूची

आउटपुट:

भागो

— डैंको डर्बीक
स्रोत

3

अंक 4 का क्या हुआ? oO

— तिमवी

इस तरह से मैं नंबर 4 लिखता हूं, लेकिन ठीक है, मैंने तय किया कि :)

— डैंको डर्बीव

2

आकर्षक - क्या आप इसे हाथ से भी लिखते हैं? क्या यह स्वीडन में आम है, या जहां भी आप मूल रूप से जय हो?

— 18

अगर मैं कर सकता तो मैं +100।

— माइकल कोहल

12

पायथन 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)))

इसके अलावा, यहाँ केवल 273 बाइट्स में पायथन 2 संस्करण का वजन है!

आगे गोल्फ के मूल स्रोत के साथ इसे और अधिक अपडेट नहीं करना। यह तब बनाया गया था जब मूल स्रोत 282 बाइट्स (पायथन 3 संस्करण) था।

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

यह धोखा हो सकता है, इसलिए मैं इसे अलग से जोड़ रहा हूं। मुझे पता है कि यह वैध माना जाता है या नहीं।

— C0deH4cker
स्रोत

6

हास्केल (389 वर्ण)

समाधान 7 सरणियों का उपयोग करता है, इस छवि के नामों का उपयोग करके, सरणी के प्रत्येक खंड के लिए एक:

8 खंड प्रदर्शन

। मान 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
 _  _  _  _     _     _     _  _  _  _  _     _ 
 _| _| _|| ||_||_   ||_ |_|| |  ||_||_||_   ||_|
|_  _||_ |_|  | _|  ||_|  ||_|  |  |  | _|  ||_|

— डेविड मियां
स्रोत

6

सी, 249 226 वर्ण

सी में गोल्फ समाधान:

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 कोड होना चाहिए

मैं इस बात का स्पष्टीकरण प्रदान करूंगा कि यह कैसे काम करता है, किसी को भी परवाह करनी चाहिए।

— reima
स्रोत

1

मैंने इस पेज के चारों ओर जो पढ़ा है, वह "ओके इन सी" है, इसमें आपको शामिल करने की आवश्यकता नहीं है #include <stdio.h>(जैसा कि इसके बिना संकलन होगा।) आप 1 बाइट में एक इंटे भी डाल सकते हैं main(), जैसे main(x)- यह मान्य नहीं है। हस्ताक्षर, और scanfअंदर रखना for: for(scanf("%d %98s", &s, &i); …)एक और शेविंग। - यहाँ एक नज़र है ।

— रनियम

@Sukminder ये बहुत मददगार संकेत हैं, धन्यवाद! मैंने हटा दिया #include, scanfअंदर ले जाया गया for, अनावश्यक &को हटा &iदिया और intवैरिएबल को वैश्विक स्कोप में स्थैतिक 0 आरंभीकरण का फायदा उठाने के लिए रखा। कोड अब भी कानूनी C89 होना चाहिए , लेकिन मैंने पूरी तरह से जांच नहीं की। मेरा मानना है कि एक intको रखना mainकानूनी नहीं है, इसलिए मैंने उसे छोड़ दिया।

— रीमा लागू

मानक अनुपालन देने से बहुत मदद मिल सकती है। उदाहरण के लिए, आप intवैश्विक चर के लिए छोड़ सकते हैं । यह भी %98sहो सकता है %s(लंबे समय तक तार आप किसी भी तरह से विफल हो जाते हैं, क्या यह किसी भी तरह से मायने रखता है?)

— ugoren

अच्छा! मैंने "इसी तरह के दर्शन" का उपयोग किया, लेकिन सरल - पेरेल में 187 चार्ट

— टॉमस

5

रूबी 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-बिट मानों का मानचित्रण है, जिसमें यह दर्शाया गया है कि प्रत्येक अंक के लिए एल ई डी को स्विच किया जाता है।
अगला, प्रत्येक अंक के लिए, मैं क्षैतिज सरणी को ध्यान में रखते हुए, ऊपर से नीचे तक आउटपुट सरणी को भरता हूं।
अंतिम लूप उन पंक्तियों को भरने के लिए है जिनमें केवल ऊर्ध्वाधर बार होते हैं, जो क्षैतिज पट्टियों को हटाकर केवल मध्य और नीचे की पंक्तियों से उत्पन्न हो सकते हैं।
अंत में, मैं आउटपुट सरणी प्रिंट करता हूं!

— SirDarius
स्रोत

क्या आप बता सकते हैं कि यहाँ क्या हो रहा है?

— माइकल स्टर्न

5

पायथन 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
स्रोत

Fyi, अंकों का शीर्ष '_' (अंडरस्कोर) माना जाता है, और अंकों के बीच कोई स्थान नहीं है। मैं पहली हाहा में उलझन में था

— C0deH4cker

5

(संपादित करें: यह समाधान अब अमान्य है क्योंकि 銻निर्देश के शब्दार्थ बदल गए हैं। मुझे यह महसूस नहीं हुआ कि मैंने इसे बदलते समय पहले ही निर्देश का उपयोग कर लिया है। आप, हालांकि, केवल इसे बदलकर कार्यक्रम को ठीक कर सकते हैं। नया निर्देश 壹।)

स्कल्प्टिंग - 85 वर्ण

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

①

इनपुट:

1 1024856359701

आउटपुट:

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

②

इनपुट:

2 47474747

आउटपुट:

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

— Timwi
स्रोत

क्या आप प्रोग्राम को ठीक कर सकते हैं? पूरे पोस्ट स्ट्रोक को छोड़ना काफी बदसूरत है।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

मैं निश्चित रूप से बदल सकता है 銻करने के लिए 壹है, लेकिन वह इस प्रविष्टि धोखाधड़ी क्योंकि होगा 壹आविष्कार किया गया था के बाद इस चुनौती तैनात थे।

— टिमवी

मुझे नहीं लगता कि यह एक समस्या है। मैं वैसे भी आपके कार्यक्रम को कमतर नहीं बनाता।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

1

नहीं, लेकिन यह इस समुदाय के एक महत्वपूर्ण नियम का उल्लंघन करेगा।

— टिमवी

अब कोई नियम का उल्लंघन नहीं करता है: P

— ASCII-only

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 क्षैतिज रेखाओं में विभाजित करना था, जो प्रत्येक वर्ण के लिए बाएँ, दाएँ और मध्य भाग में विभाजित होते हैं।

— रिक
स्रोत

शायद मैंने इसे गलत तरीके से कॉपी किया, लेकिन मैंने इसे आइडोन पर चलाने की कोशिश की और इसने एक त्रुटि दी। ideone.com/gQ6LH7

— C0deH4cker

शायद मेरी गलती है, मुझे देखने दो

— Rik

1

@ C0deH4cker मैंने इनपुट को दो अलग-अलग ReadLines में लिया। यह एक काम करता है: ideone.com/4jTxeu

— रिक

1

@ C0deH4cker मैंने एक संस्करण बनाया जो इनपुट को निर्दिष्ट के रूप में लेता है, और 9. के निचले हिस्से को छोड़ता है। इनपुट के रूप में कई चार्ट लेता है, 9 की लागत 1 अतिरिक्त होती है।

— रिक

1

आपके पास ;वहाँ एक अनावश्यक (480) है; आप लिख सकते हैं Action<z,z,z,int>q=(l,m,r,n)=>{...};(470); आप में से पहले पैरामीटर कर सकते हैं hएक charऔर कर ""+के अंदर h(467); और अंत में, आप घोषणा कर सकते हैं और फिर से उपयोग z d="134579",b="1237"(465) कर सकते हैं। वह सबसे छोटा मैं इसे अभी तक बना सकता है

— टिमवी

3

मुझे लगता है कि बहुत छोटे समाधान हैं, लेकिन चूंकि यह कोड-गोल्फ नहीं है इसलिए मैं काफी संतुष्ट हूं!

यह PHP स्क्रिप्ट एसटीडीआईएन से दो नंबर लेगी a, bऔर bएलईडी प्रारूप में गूंज , 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आकार जितना बड़ा होना चाहिए । यह ओपी की घोषणा के साथ तय किया गया है कि किसी स्थान की आवश्यकता नहीं है।

— Vereos
स्रोत

दरअसल, अंकों के बीच कोई रिक्त स्थान नहीं होना चाहिए। एकमात्र कारण यह लग रहा है कि नमूने के लिए रास्ता रिक्त स्थान हैं जहां '|' उदाहरण के लिए एक 8 पर होगा। मुझे कुछ समय के लिए पता चला

— C0deH4cker

ओह, तुम सही हो! धन्यवाद :)

— वीरोस

2

सी #, 435 359 473 बाइट्स

संपादन:

हटाए गए अनावश्यक कोड। तुलना के बाइट आकार में कमी।
इनपुट के लिए मानक का उपयोग करते हुए एक स्टैंड-अलोन अनुप्रयोग में परिवर्तित।

यहाँ गोल्फ कोड है (अतिरिक्त लाइन ब्रेक और व्हाट्सएप के साथ):

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

— हाथ-ए-खाना
स्रोत

वे C # फ़ंक्शंस मान्य हैं। यह कभी नहीं कहा गया कि यह एक स्टैंड-अलोन कार्यक्रम होना चाहिए। हालांकि, यह मानक में उपयोग नहीं करता।

— हाथ-ए-खाना

@ टिम्मी, अनुरूप करने के लिए संपादित ...

— हाथ-ई-फूड

1

बहुत बढ़िया!! मैंने इसे कुछ और गोल किया है और मैंने इसे 425 (वर्ण; 432 बाइट्स यूटीएफ -8 में) प्राप्त किया है, जो इसे अन्य सी # उत्तर की तुलना में छोटा बनाता है।

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

— तिमवी

1

Systemनेमस्पेस में सब कुछ डालने के दूसरे सी # उत्तर के विचार का उपयोग करते हुए इसे 423 तक

— टिमवी

2

सी ( 561 492 बाइट्स)

लेखक फ्रेंमर है। उसने मुझे पिछले हफ्ते अपना जवाब भेजा (उसने अभी तक अपना खाता नहीं बनाया है)।

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

मूल संस्करण फ्रमर (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
        _____
|     |      |
|     |      |
|     |      |
|     |      |
|_____| _____|
      ||
      ||
      ||
      ||
      ||_____

— olibre
स्रोत

1

पर्ल + फिगलेट + बीआर ^* : 54 वर्ण

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

मुझे लगा कि यह FIGlet के साथ करना काफी आसान होगा , लेकिन इस उद्देश्य के लिए कोई उपयुक्त फोंट नहीं दिखाई दिया। तो मैंने कुछ बनाया :-)

यहाँ यह टर्मिनल पर कैसा दिखता है:

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

_{* बीआरए: स्पष्ट नियम का दुरुपयोग}

— बग़ल में ossifrage
स्रोत

नहीं मिलता है कि क्यों वहाँ के लिए एक downvote है। फोंट के साथ अच्छी चाल!

— 21

मैं downvoting नहीं था, लेकिन मैं समझता हूँ कि यह होगा कि का उपयोग करते हुए एक कार्यक्रम के बजाय वास्तव में बनाने कार्यक्रम धोखा दे रही है।

— टॉमस

1

पेरल, 261 244 187 166 चार्ट

थोड़ा सा बिटकॉइन एन्कोडिंग दर्शन नियमz :-)

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

पर्ल को इनवाइट करना होगा -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

बहुत सुंदर विचार मेरे पर्ल स्क्रिप्ट का उपयोग करता है, लेकिन पेरेल में यह बहुत बदसूरत है। ध्यान दें कि मेरे sed प्रोग्राम के लिए मैंने उपयोग करना पसंद किया है 9जिसमें अंतिम पंक्ति में अंडरस्कोर है, उलट 6 जैसा होना चाहिए।

— टॉमस
स्रोत

मैं सोच रहा था कि क्या आप बता सकते हैं कि स्केलिंग कैसे काम करता है, मैं पर्ल में अपने स्वयं के संस्करण को लागू करने की कोशिश कर रहा हूं। लेकिन ऊर्ध्वाधर और क्षैतिज स्केलिंग अधिकार प्राप्त करने के लिए प्रतीत नहीं कर सकते।

— हंटर मैकमिलन

0

C #, 386 382 364 chars / 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();}}}

संपादित बकवास ... मैं "पैमाने" हिस्सा याद किया

मैं इसे एक और शॉट दूंगा अगर मुझे इसके आसपास मिलता है ..

— RobIII
स्रोत

हाँ, पैमाना हिस्सा इसे डरावना बनाता है।

— cjfaure

0

जे - 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
स्रोत

यह प्रश्न का उत्तर कैसे देता है?

— वसी था

आप बिल्कुल सही हैं ... मैं इसे ठीक

— करूंगा

आपका उदाहरण गलत है। सवाल देखो।

— टॉमस

0

रूबी, 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
 ____        ____  ____        ____  ____  ____  ____  ____
|    |     |     |     ||    ||     |          ||    ||    |
|    |     |     |     ||    ||     |          ||    ||    |
|    |     |     |     ||    ||     |          ||    ||    |
|    |     | ____| ____||____||____ |____      ||____||____|
|    |     ||          |     |     ||    |     ||    |     |
|    |     ||          |     |     ||    |     ||    |     |
|    |     ||          |     |     ||    |     ||    |     |
|____|     ||____  ____|     | ____||____|     ||____| ____|

— स्तर नदी सेंट
स्रोत

0

पर्ल 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
स्रोत

7-सेगमेंट डिस्प्ले पैटर्न में ट्रांसफॉर्म नंबर

कमोडोर 64 बुनियादी

पायथन 3, 286 282 280

हास्केल (389 वर्ण)

कोड

उदाहरण उपयोग

सी, 249 226 वर्ण

रूबी 2.0

स्कल्प्टिंग - 85 वर्ण

इनपुट:

आउटपुट:

इनपुट:

आउटपुट:

C # ( 480 443 वर्ण)

सी #, 435 359 473 बाइट्स

सी ( 561 492 बाइट्स)

492 बाइट्स लेकिन थोड़ा अधिक मोटे:

561 बाइट्स का उपयोग कर पिछला संस्करण:

मूल संस्करण फ्रमर (623 बाइट्स) से:

संकलन:

डिफ़ॉल्ट 0123456789संख्या लेकिन विभिन्न आकारों का उपयोग करने वाले उदाहरण :

अन्य उदाहरण:

बड़े आकार:

पर्ल + फिगलेट + बीआर * : 54 वर्ण

पेरल, 261 244 187 166 चार्ट

C #, 386 382 364 chars / 374 बाइट्स (UTF-8) और (बहुत सारे) कमरे के लिए ...

जे - 147 95 वर्ण

रूबी, 126 ASCII वर्ण

पर्ल 6, 284 241 237

डिफ़ॉल्ट `0123456789`संख्या लेकिन विभिन्न आकारों का उपयोग करने वाले उदाहरण :

पर्ल + फिगलेट + बीआर ^* : 54 वर्ण