रेखाओं के बीच


31

यहाँ छवि विवरण दर्ज करें

दूसरे दिन वर्ग-शासित पेपर पर डूडलिंग करते हुए, मैं अंकों के लिए उपरोक्त नकारात्मक-स्थान फ़ॉन्ट के साथ आया। यदि आपने इसे अभी तक देखा नहीं है, तो उपरोक्त आकृतियों के बीच के रिक्त स्थान का अनुपात 1.618033988749 है । इस चुनौती में, आपका कार्य इनपुट के रूप में एक संख्या लेना है और इसे ऊपर दिए गए उदाहरण के समान प्रस्तुत करना है।

यहाँ ये कैसे बनाया जाता है। सभी लाइनें एक नियमित ग्रिड पर होंगी, ताकि व्यक्तिगत अंक कम संख्या में ग्रिड कोशिकाओं से बने हों। यहां 10 अंकों के आकार दिए गए हैं (हम इस चुनौती के लिए दशमलव बिंदु की उपेक्षा करेंगे):

यहाँ छवि विवरण दर्ज करें
हाँ 7 सबसे ऊपर के सुनहरे अनुपात के उदाहरण से भिन्न है। मैं थोड़े गड़बड़ कर दिया। हम इस एक के साथ जा रहे हैं।

ध्यान दें कि प्रत्येक अंक पाँच सेल लंबा है, और तीन कोशिकाएँ चौड़ी हैं। किसी संख्या को रेंडर करने के लिए, आप इसके सभी अंकों को एक दूसरे के बगल में रखने की कल्पना कर सकते हैं, जैसे कि प्रत्येक जोड़ी के अंकों के बीच एक खाली कॉलम होता है। उदाहरण के लिए, 319इनपुट के रूप में लेते हुए , हम लिखेंगे:

यहाँ छवि विवरण दर्ज करें

ध्यान दें कि हम एक अग्रणी और अनुगामी खाली कॉलम जोड़ते हैं। अब हम कोशिकाओं को उल्टा करते हैं:

यहाँ छवि विवरण दर्ज करें

आउटपुट को तब परिणामी बहुभुजों की सीमाएँ होनी चाहिए:

यहाँ छवि विवरण दर्ज करें

बेशक आप किसी अन्य तरीके से परिणाम उत्पन्न कर सकते हैं, जब तक कि प्रस्तुत आउटपुट समान दिखता है।

इनपुट

  • आप एक स्ट्रिंग या अंकों की सूची के रूप में STDIN (या निकटतम वैकल्पिक), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट लेते हुए एक प्रोग्राम या फ़ंक्शन लिख सकते हैं। (आप एक संख्या नहीं ले सकते क्योंकि यह आपको अग्रणी शून्य का समर्थन करने की अनुमति नहीं देगा।)
  • आप मान सकते हैं कि इनपुट में कोई 16 अंक नहीं होंगे।

उत्पादन

  • आउटपुट या तो स्क्रीन पर प्रदर्शित हो सकता है या एक सामान्य छवि प्रारूप में एक फ़ाइल में लिखा जा सकता है।
  • आप रेखापुंज और वेक्टर ग्राफिक्स दोनों का उपयोग कर सकते हैं।
  • या तो मामले में, अंतर्निहित ग्रिड की कोशिकाओं का पहलू अनुपात 1 होना चाहिए (अर्थात, कोशिकाओं को वर्ग होना चाहिए)।
  • रेखापुंज ग्राफिक्स के मामले में, प्रत्येक सेल को कम से कम 20 को 20 पिक्सेल से कवर करना चाहिए।
  • सेल आकार का 10% से अधिक चौड़ा नहीं होना चाहिए। मैं यहाँ अलियासिंग के कारण एक या दो पिक्सेल लेवे देने को तैयार हूँ।
  • लाइनें और पृष्ठभूमि किसी भी दो स्पष्ट रूप से अलग-अलग रंग हो सकते हैं, लेकिन लाइनों द्वारा बनाई गई आकृतियों को भरा नहीं जाना चाहिए (अर्थात यह है कि पृष्ठभूमि का रंग भी होना चाहिए)।
  • प्रत्येक बंद लूप के भीतर कोई अंतराल नहीं होना चाहिए।
  • बेशक, पूरा परिणाम दिखाई देना चाहिए।

परीक्षण के मामलों

यहां 10 इनपुट दिए गए हैं, जो एक साथ आसन्न अंकों के सभी संभावित जोड़ों को कवर करते हैं, साथ ही हर संभव अग्रणी और अनुगामी अंक:

07299361548
19887620534
21456837709
39284106657
49085527316
59178604432
69471338025
79581224630
89674235011
97518264003

और यहाँ उन लोगों के लिए अपेक्षित परिणाम हैं:

यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें

सुनिश्चित करें कि एक भी अंक दिए जाने पर आपका कोड भी काम करता है (मैं यहां अपेक्षित परिणाम शामिल नहीं करना चाहता, क्योंकि वे स्पष्ट होने चाहिए, और परीक्षण मामला अनुभाग पर्याप्त रूप से फूला हुआ है)।


क्या ASCII कला को स्वीकार किया जाएगा?
ब्लू

2
@ मुझे लगता है कि एक बहुत ही अलग काम के लिए करना होगा, और जवाब शायद ही तुलनीय होगा, तो नहीं, माफ करना। मैं आमतौर पर एक एकल चुनौती में ग्राफिकल आउटपुट और ASCII कला के मिश्रण का प्रशंसक नहीं हूं।
मार्टिन एंडर

ठीक है, त्वरित उत्तर के लिए धन्यवाद
ब्लू

क्या इसे फोंट आयात करने की अनुमति है?
मार्व

@ मारव हम्म, दिलचस्प सवाल। मैं कहूंगा कि आपको उस मामले में फ़ॉन्ट फ़ाइल का आकार गिनना चाहिए।
मार्टिन एंडर

जवाबों:


1

बीबीसी बेसिक, 182 एएससीआईआई अक्षर (175 बाइट्स के साथ संकलित फ़ाइलें)

Http://www.bbcbasic.co.uk/bbcwin/bbcwin.html पर दुभाषिए को डाउनलोड करें

I.n$
F.j=0TOLENn$*4p=ASCM."?@\@?[@_?DTP?TT@?pv@?PTD?@TD?||@?@T@?PT@",VALM.n$,j/4+1,1)*4+1+j MOD4)F.k=0TO4p*=2q=64A.p
V.537;q;0;2585;0;q;537;-q;0;2585;0;-q;25;0;64;
N.MOVEBY 64,-320N.

स्कोरिंग: जब उपरोक्त कार्यक्रम को संपादक में चिपकाया जाता है और चलाया जाता है, तो संपादक संक्षिप्त कीवर्ड को ऑनस्क्रीन पूर्ण कीवर्ड में विस्तारित करेगा, हालांकि वे टोकन के बाद वास्तव में केवल 1 बाइट हैं। (उदाहरण I.=INPUT भंडारण स्थान 1 बाइट।)

व्याख्या

मैं अभी बताऊंगा कि VDU लाइन क्या करती है: यह स्क्रीन पर वर्तमान पिक्सेल रंग को थोड़ा-सा फ़्लिप करके एक बॉक्स बनाता है। इसका मतलब यह है कि (कोनों के साथ थोड़ी सी देखभाल के साथ) एक सेल को एक दूसरे के बगल में खींचना संभव है, और इंटरवलिंग एज डबल ड्राइंग के कारण रद्द हो जाएगा और गायब हो जाएगा।

करीबी परीक्षा से पता चलेगा कि एक सेल के ऊपरी दाएं और नीचे के बाएं कोने खींचे गए हैं लेकिन इस काम को करने के लिए शीर्ष बाएं और नीचे दाएं गायब हैं ("गोल")।

सेल तैयार होने के बाद, ग्राफिक्स कर्सर को अगले सेल के लिए तैयार किए गए 32 पिक्सल्स को ऊपर ले जाया जाता है।

कार्यक्रम के बाकी एक काफी सीधा ASCII बिटमैप विघटन है। जिस तरह से बिटमैप विघटित होता है, उसके लिए सेल की आयाम 64x64 इकाइयाँ होती हैं।qउस सेल के आकार को नियंत्रित करता है जो प्लॉट किया जाता है: एक सेल के लिए 64x64 इकाइयाँ मौजूद हैं, एक सेल के लिए 0x0 जो अनुपस्थित है।

अघोषित कोड

  m$="?@\@?[@_?DTP?TT@?pv@?PTD?@TD?||@?@T@?PT@" :REM bitmap for digits, including column of filled cells at left. BBC strings are 1-indexed
  INPUTn$                                       :REM user input
  FORj=0 TO LENn$*4                             :REM iterate 4 times per input digit, plus once more (plot column 0 of imaginary digit to finish)
    d=VAL MID$(n$,j/4+1,1)                      :REM extract digit from n$ (1-character string). VAL of empty string = 0, so 123->1,1,1,1,2,2,2,2,3,3,3,3,0
    p=ASC MID$(m$,d*4+1+j MOD4)                 :REM get column bitmap from m$ d*4 selects digit, j MOD4 selects correct column of digit, add 1 to convert to 1-index
    FORk=0TO4                                   :REM for each cell in the column
      p*=2                                      :REM bitshift p
      q=64ANDp                                  :REM find size of cell to draw. 64 for a filled cell, 0 for an absent cell.
      VDU537;q;0;                               :REM line q units right, inverting existing screen colour. Draw last pixel (will be inverted next line)
      VDU2585;0;q;                              :REM line q units up, inverting existing screen colour. Dont draw last pixel (will be filled in next line)
      VDU537;-q;0;                              :REM line q units left, inverting existing screen colour. Draw last pixel (will be inverted next line)
      VDU2585;0;-q;                             :REM line q units down, inverting existing screen colour. Dont draw last pixel (avoid inverting 1st pixel of 1st line)
      VDU25;0;64;                               :REM move up 64 units for cell above
    NEXT
    MOVEBY 64,-320                              :REM move right and down for next column.
  NEXT

उत्पादन

MOVEरों बस आउटपुट स्क्रीन पर ऊंचाइयों उचित प्राप्त कर रहे हैं। बीबीसी बेसिक इस मोड में 2 इकाइयों = 1 पिक्सेल का उपयोग करता है, इसलिए कोशिकाएं वास्तव में 32x32 पिक्सेल हैं।

यहाँ छवि विवरण दर्ज करें


10

ऑक्टेव, 233 225 216 213 बाइट्स

o=@ones;l=z=o(5,1);for k=input('')-47;l=[l,reshape(dec2bin([448,22558,8514,10560,3936,2376,328,15840,320,2368](k),15),5,[])-48,z];end;L=~o(size(l)+2);L(2:6,2:end-1)=l;O=o(3);O(5)=-8;M=~conv2(kron(L,o(25)),O);imshow(M)

यहां पहला परीक्षण मामला (एक आकारित स्क्रीन कैप्चर से, यह मेरे मॉनिटर = फिट बैठता है): यहाँ छवि विवरण दर्ज करें

o=@ones;
l=z=o(5,1);                   %spacer matrices
for k=input('')-47;           %go throu all input digis
                              %decode the matrices for each digit from decimal
l=[l,reshape(dec2bin([448,22558,8514,10560,3936,2376,328,15840,320,2368](k),15),5,[])-48,z];
end
L=~o(size(l)+2);           %pad the image
L(2:6,2:end-1)=l;
O=o(3);O(5)=-8;               %create edge detection filter
imshow(~conv2(kron(L,o(25)),O)) %image resizing /edge detection (change 25 to any cell size you like)

इनपुट मनमानी लंबाई हो सकती है, जैसे कि '07299361548'

बातचीत सफलता की कुंजी है।


धन्यवाद के बाइट्स =) एक गुच्छा द्वारा स्कोर में सुधार के लिए @LuisMendo
flawr

2
मैं इस बात से ज्यादा सहमत नहीं था कि सफलता सफलता की कुंजी :-)
लुइस मेंडो

किसी तरह यह हमेशा मेरे सफल
मैटलैब

5

जावास्क्रिप्ट ईएस 6, 506 बाइट्स

a=>{with(document)with(body.appendChild(createElement`canvas`))with(getContext`2d`){width=height=(a.length+2)*80;scale(20,20);translate(1,1);lineWidth=0.1;beginPath();["oint",...a.map(i=>"05|7agd7|oint 067128a45|oicgmnt 01de25|oil9amnt 01de23fg45|oint 03fh5|68ec6|oint 03fg45|oij78knt 05|9agf9|oij78knt 01dh5|oint 05|78ed7|9agf9|oint 03fg45|78ed7|oint".split` `[i]),"05"].map(i=>{i.split`|`.map(i=>[...i].map((e,i,_,p=parseInt(e,36),l=~~(p/6),r=p%6)=>i?lineTo(l,r):moveTo(l,r)));translate(4,0)});stroke()}}

Ungolfed:

a=>{                                            // anonymous function declaration, accepts array of numbers
  with(document)                                // bring document into scope
  with(body.appendChild(createElement`canvas`)) // create canvas, drop into html body, bring into scope
  with(getContext`2d`){                         // bring graphics context into scope
    width=height=(a.length+2)*80;               // set width and height
    scale(20,20);                               // scale everything to 20x
    translate(1,1);                             // add padding so outline doesn't touch edge of canvas
    lineWidth=0.1;                              // have to scale line width since we scaled 20x
    beginPath();                                // start drawing lines
    ["oint",                                    // beginning "glyph", draws left end of negative space, see below
     ...a.map(i=>`05|7agd7|oint                 // glyphs 0-9 encoded as vertices
                  067128a45|oicgmnt             //   glyphs seperated by " "
                  01de25|oil9amnt               //   lines within each glyph seperated by "|"
                  01de23fg45|oint               //   a single vertex is stored as a base36 char
                  03fh5|68ec6|oint              //     where a number corresponds to one of the verts shown below:
                  03fg45|oij78knt               //        0  6 12 18 24
                  05|9agf9|oij78knt             //        1  7 13 19 25
                  01dh5|oint                    //        2  8 14 20 26
                  05|78ed7|9agf9|oint           //        3  9 15 21 27
                  03fg45|78ed7|oint`            //        4 10 16 22 28
       .split` `[i]),                           //        5 11 17 23 29
     "05"]                                      // end "glyph", draws right end of negative space, see above
      .map(i=>{                                 // for each glyph string
        i.split`|`                              // seperate into list of line strings
          .map(i=>[...i]                        // convert each line string into list of chars
            .map((e,i,_,p=parseInt(e,36),       // convert base36 char to number
                  l=~~(p/6),r=p%6)=>            // compute x y coords of vertex
              i?lineTo(l,r):moveTo(l,r)));      // draw segment
        translate(4,0)});                       // translate origin 4 units to right
    stroke()}}                                  // draw all lines to canvas

माना जाता है कि <body>फ़ायरफ़ॉक्स 46 में परीक्षण के लिए कैनवास को जोड़ने के लिए एक है।

उदाहरण रन (च को अनाम कार्य निर्दिष्ट करना):

f([1,0,3])

पैदावार:

उदाहरण आउटपुट


5

एचटीएमएल + जावास्क्रिप्ट ईएस ६, ३५२

नीचे दिए गए स्निपेट का परीक्षण करें

<canvas id=C></canvas><script>s=prompt(),C.width=-~s.length*80,c=C.getContext("2d"),[...s].map(d=>[30,d*=3,++d,++d].map(w=a=>{for(a=parseInt("vhvivgtlnllv74vnltvlt11vvlvnlv0"[a],36)*2+1,p=1,y=100,i=64;i>>=1;p=b,y-=20)c.moveTo(x+20,y),b=a&i?1:0,c[b-p?'lineTo':'moveTo'](x,y),(a^q)&i&&c.lineTo(x,y-20);q=a,x+=20}),q=63,x=0),w(30),w(0),c.stroke()</script>

कम गोल्फ वाला

s=prompt(),C.width=-~s.length*80,c=C.getContext("2d"),
w=a=>{
  a=parseInt("vhvivgtlnllv74vnltvlt11vvlvnlv0"[i],36)*2+1
  for(p=1,y=100,i=32;i;p=b,y-=20,i>>=1)
    c.moveTo(x+20,y),
    b=a&i?1:0,
    c[b-p?'lineTo':'moveTo'](x,y),
    (a^q)&i&&c.lineTo(x,y-20)
  q=a 
  x+=20
},
[...s].map(d=>[30,d*=3,++d,++d].map(w),q=63,x=0),
w(30),w(0)
c.stroke()

1
मुझे नहीं लगता कि आपको क्लोजिंग स्क्रिप्ट टैग की आवश्यकता है ...
मामा फन रोल

3

जावा, 768 बाइट्स

import java.awt.*;import java.awt.image.*;class G{public static void main(String[]v)throws Exception{int s=20,n=v[0].length(),i=0,j,w=(n*3+n+1)*s,h=5*s,a[][]={{6,7,8},{0,2,3,10,11,12,13},{1,6,8,13},{1,3,6,8},{3,4,5,6,8,9},{3,6,8,11},{6,8,11},{1,2,3,4,6,7,8,9},{6,8},{3,6,8}};BufferedImage o,b=new BufferedImage(w,h,1);Graphics g=b.getGraphics();g.setColor(Color.WHITE);for(;i<n;i++)for(j=0;j<15;j++){int c=j;if(java.util.Arrays.stream(a[v[0].charAt(i)-48]).noneMatch(e->e==c))g.fillRect((1+i*4+j/5)*s,j%5*s,s,s);}o=new BufferedImage(b.getColorModel(),b.copyData(null),0>1,null);for(i=1;i<h-1;i++)for(j=1;j<w-1;j++)if((b.getRGB(j+1,i)|b.getRGB(j-1,i)|b.getRGB(j,i+1)|b.getRGB(j,i-1))<-1)o.setRGB(j,i,-1);javax.imageio.ImageIO.write(o,"png",new java.io.File("a.png"));}}

Ungolfed

import java.awt.*;
        import java.awt.image.BufferedImage;

class Q79261 {
    public static void main(String[] v) throws Exception {
        int scale = 20, n = v[0].length(), i = 0, j, width = (n * 3 + n + 1) * scale, height = 5 * scale, values[][] = {{6, 7, 8}, {0, 2, 3, 10, 11, 12, 13}, {1, 6, 8, 13}, {1, 3, 6, 8}, {3, 4, 5, 6, 8, 9}, {3, 6, 8, 11}, {6, 8, 11}, {1, 2, 3, 4, 6, 7, 8, 9}, {6, 8}, {3, 6, 8}};
        BufferedImage output, temp = new BufferedImage(width, height, 1);
        Graphics g = temp.getGraphics();
        g.setColor(Color.WHITE);
        for (; i < n; i++)
            for (j = 0; j < 15; j++) {
                int finalJ = j;
                if (java.util.Arrays.stream(values[v[0].charAt(i) - 48]).noneMatch(e -> e == finalJ))
                    g.fillRect((1 + i * 4 + j / 5) * scale, j % 5 * scale, scale, scale);
            }
        output = new BufferedImage(temp.getColorModel(), temp.copyData(null), 0 > 1, null);
        for (i = 1; i < height - 1; i++)
            for (j = 1; j < width - 1; j++)
                if ((temp.getRGB(j + 1, i) | temp.getRGB(j - 1, i) | temp.getRGB(j, i + 1) | temp.getRGB(j, i - 1)) < -1)
                    output.setRGB(j, i, -1);
        javax.imageio.ImageIO.write(output, "png", new java.io.File("a.png"));
    }
}

टिप्पणियाँ

  • इनपुट तर्क के रूप में एक एकल स्ट्रिंग है। उपयोग कैसे करें: javac G.java,java G 80085

  • मैं एक काले कैनवास से शुरू कर रहा हूं, फिर मैं सफेद सकारात्मक के रूप में संख्याओं को जोड़ रहा हूं। मैं छवि की एक प्रति बनाता हूं और फिर प्रत्येक काले पिक्सेल को फ्लिप करता हूं जिसमें मूल छवि पर 4 काले पड़ोसी हैं।

आउटपुट

0 1 2 3 4 5 6 7 8 9

कुछ एकल अंक:

यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें


java.awt। * में java.awt.image.BufferedImage नहीं है?
तत्व 118

@ Element118 यह नहीं करता है।
मार्व

2

आर, गोल्फ के लिए बहुत सारे बाइट्स ( 1530+ 1115)

library(reshape2);library(ggplot2);library(png)
M=matrix(1,5,3)
M=lapply(list(c(7:9),c(1,3,4,11:14),c(2,7,9,14),c(2,4,7,9),c(4:7,9,10),c(4,7,9,12),c(7,9,12),c(2:5,7:10),c(7,9),c(4,7,9)),function(x){M[x]=0;M})
g=function(P){
S=matrix(0,5,1)
R=NULL
for(N in P){R=Reduce(cbind2,list(R,S,M[[N+1]]))}
cbind(R,S)}
p=function(P){
o=t(apply(g(P),1,rev))
ggplot(melt(o),aes(x=Var1,y=Var2))+geom_raster(aes(fill=value))+coord_flip()+scale_fill_continuous(guide=FALSE,high="#FFFFFF",low="#000000")+scale_y_reverse()+scale_x_reverse()+theme_bw()+theme(panel.grid=element_blank(),panel.border=element_blank(),panel.background=element_blank(),axis.title=element_blank(),axis.text=element_blank(),axis.ticks=element_blank(),plot.margin=unit(c(0,0,0,0),"mm"))+ggsave("t.png",width=dim(o)[2]/2.5,height=2,units="in",dpi=99)
q=readPNG("t.png")
k=q[,,1]
b=replace(k,k==1,0)
for(i in 1:nrow(k)){
for(j in 1:ncol(k)){
u=(i==nrow(k))
v=(j==ncol(k))
if(u&v){b[i,j]=1;break}
if((i==1)|u|(j==1)|v){b[i,j]=1;next}else{if(all(k[c((i-1):(i+1)),c((j-1):(j+1))])){b[i,j]=1}else{b[i,j]=0}}}}
q[,,1:3]=abs(replace(k,b==1,0)-1)
writePNG(q,"t.png")}

# run p(c(0,1,2,3,4,5))

यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें यहाँ छवि विवरण दर्ज करें

लिखने के लिए डिस्क पर lol, फिर डिस्क से पढ़ने से ब्लैक फिल को हटा दिया जाता है।


2

पायथन 3, 326 325 बाइट्स

import numpy
from skimage import io,transform as t,filters as f
r=[[1]*5,[0]*5]
for c in map(int,input()):r+=[map(float,bin(0x3f1fa7e1bd7b5aff84ff6b7fd6f087ff5ff6bf)[2:][15*c+5*i:15*c+5*-~i])for i in[0,1,2]]+[[0]*5]
r+=[[1]*5]
p=[[1]*len(r)]
r=p+list(zip(*r))+p
io.imsave("o.png",1-f.sobel((t.rescale(numpy.array(r),16,0))))

2
मैं दूसरे दिन आपके एक उत्तर पर यह टिप्पणी करने वाला था, लेकिन range(3)कभी इसके लायक नहीं था।
Sp3000

1

सी #, 768 773 776 बाइट्स

namespace System.Drawing{class P{static void Main(string[]a){uint[]l={0xEBFBFFFC,0xB89B21B4,0xABFFF9FC,0xAA1269A4,0xFFF3F9FC};var w=a[0].Length*80+20;var b=new Bitmap(w,100);var g=Graphics.FromImage(b);g.FillRectangle(Brushes.Black,0,0,w,100);for(int i=0;i<a[0].Length;i++)for(int r=0;r<5;r++)for(int c=0;c<3;c++)if((l[r]&((uint)1<<(175-a[0][i]*3-c)))>0)g.FillRectangle(Brushes.White,20*(1+i*4+c),20*r,20,20);for(int x=1;x<w-1;x++)for(int y=1;y<99;y++)if(b.GetPixel(x,y).B+b.GetPixel(x+1,y).B+b.GetPixel(x,y+1).B+b.GetPixel(x,y-1).B+b.GetPixel(x+1,y-1).B+b.GetPixel(x+1,y+1).B+b.GetPixel(x-1,y+1).B+b.GetPixel(x-1,y-1).B==0)b.SetPixel(x,y,Color.Red);for(int x=1;x<w-1;x++)for(int y=1;y<99;y++)if(b.GetPixel(x,y).R>0)b.SetPixel(x,y,Color.White);b.Save(a[0]+".bmp");}}}

कमांड लाइन तर्क के रूप में संख्या लेता है। नाम के रूप में संख्या के साथ एक अच्छा, स्वच्छ, गैर-अलियास बीएमपी छवि आउटपुट करता है।

गोल्फ से पहले मूल:

namespace System.Drawing
{
    class P
    {
        static void Main(string[] args)
        {
            var numbers = args[0];
            uint[] lines = {
                0xEBFBFFFC, // 111 010 111 111 101 111 111 111 111 111 00
                0xB89B21B4, // 101 110 001 001 101 100 100 001 101 101 00
                0xABFFF9FC, // 101 010 111 111 111 111 111 001 111 111 00
                0xAA1269A4, // 101 010 100 001 001 001 101 001 101 001 00
                0xFFF3F9FC  // 111 111 111 111 001 111 111 001 111 111 00
            };
            var width = numbers.Length*4 + 1;
            var bmp = new Bitmap(width*20, 5*20);
            using (var gfx = Graphics.FromImage(bmp))
            {
                gfx.FillRectangle(Brushes.Black, 0, 0, width*20+2, 5*20+2);
                // Process all numbers
                for (int i = 0; i < numbers.Length; i++)
                {
                    var number = numbers[i]-'0';
                    for (int line = 0; line < 5; line++)
                    {
                        for (int col = 0; col < 3; col++)
                        {
                            if ((lines[line] & ((uint)1<<(31-number*3-col))) >0)
                                gfx.FillRectangle(Brushes.White, 20*(1 + i * 4 + col), 20*line, 20 , 20 );
                        }
                    }
                }
                // Edge detection
                for (int x = 1; x < width*20-1; x++)
                {
                    for (int y = 1; y < 5*20-1 ; y++)
                    {
                        if (bmp.GetPixel(x,y).B +
                            bmp.GetPixel(x + 1, y).B +
                                bmp.GetPixel(x, y + 1).B +
                                bmp.GetPixel(x, y - 1).B +
                                bmp.GetPixel(x + 1, y - 1).B +
                                bmp.GetPixel(x + 1, y + 1).B + 
                                bmp.GetPixel(x - 1, y + 1).B + 
                                bmp.GetPixel(x - 1, y - 1).B == 0)
                                bmp.SetPixel(x, y, Color.Red);
                    }
                }
                // Convert red to white
                for (int x = 1; x < width * 20 - 1; x++)
                {
                    for (int y = 1; y < 5 * 20 - 1; y++)
                    {
                        if (bmp.GetPixel(x, y).R>0)
                            bmp.SetPixel(x, y, Color.White);
                    }
                }
            }
            bmp.Save(@"c:\tmp\test.bmp");
        }
    }
}

1

गणितज्ञ 328 बाइट्स

j@d_:=Partition[IntegerDigits[FromDigits[d/.Thread[ToString/@Range[0,9]->StringPartition["75557262277174771717557117471774757711117575775717",5]],16],2, 20]/.{0->1,1->0},4];j@"*"=Array[{1}&,5];
w@s_:=  ColorNegate@EdgeDetect@Rasterize@ArrayPlot[Thread[Join@@Transpose/@j/@Characters@(s<>"*")],Frame->False,ImageSize->Large]

w["07299361548"]
w["19887620534"]

पिक


व्याख्या

प्रत्येक इनपुट अंक के लिए कोशिकाओं की 5 लाइनों में से चार बिट्स का उपयोग किया जाएगा।

"75557262277174771717557117471774757711117575775717"बिटमैप के रूप में 0 से 9 का प्रतिनिधित्व करता है।

ऊपर दिए गए बड़े पूर्णांक में पहले 5 अंक, अर्थात् 75557इंगित करते हैं कि शून्य के लिए प्रत्येक सरणी पंक्ति को कैसे प्रदर्शित किया जाना चाहिए। 7प्रतिनिधित्व करेंगे {0,1,1,1}, अर्थात्, एक सफेद सेल, इसके दाईं ओर, 3 काली कोशिकाओं द्वारा; अग्रणी 0प्रदर्शित अंकों को अलग करने के लिए रिक्त स्थान है। 5से मेल खाती है {0,1,0,1}, कि सफेद, काले, सफेद, काले कोशिकाओं है।

निम्नलिखित प्रतिस्थापन नियमों की एक सूची तैयार करता है:

Thread[ToString /@ Range[0, 9] -> StringPartition["75557262277174771717557117471774757711117575775717", 5]]

{"0" -> "75557", "1" -> "26227", "2" -> "71747", "3" -> "71717", "4" -> "55711", "5" - > "74717", "6" -> "74757", "7" -> "71111", "8" -> "75757", "9" -> "75717"}

ध्यान दें कि जब 3इनपुट होता है, तो इसे बदल दिया जाएगा 71717 यह प्रतिनिधित्व बाइनरी में व्यक्त किया गया है:

p = Partition[IntegerDigits[FromDigits["3" /. {"3" -> "71717"}, 16], 2, 20], 4]

{{0, 1, 1, 1}, {0, 0, 0}, 1}, {0, 1, 1, 1}, {0, 0, 0, 1}, {0, 1, 1, 1}। }

इसका श्वेत-श्याम विलोम 1एस और 0एस के आदान-प्रदान से पाया जाता है ।

q = p /. {0 -> 1, 1 -> 0}

{{1, 0, 0, 0}, {1, 1, 1, 1}, {1, 0, 0, 0}, {1, 1, 1, 0}, {1, 0, 0, 0}। }


आइए देखते हैं कि क्या pऔर कैसा qदिखता है ArrayPlot:

ArrayPlot[#, Mesh -> True, ImageSize -> Small, PlotLegends -> Automatic] & /@ {p, q}

Pis


यह बस शून्य से सारणियों में जुड़ता है और प्रत्येक अंक के लिए बड़े सरणी के माध्यम से प्रस्तुत करता है ArrayPlot। अंतिम अंक के बाद अंतिम ऊर्ध्वाधर स्थान के रूप *में परिभाषित किया गया है j

Thread[Join @@ Transpose /@ j /@ Characters@(s <> "*")]
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.