अंक किस आकार का है?

Question

_|वर्णों का उपयोग करके ASCII में 7-खंड अंकों का प्रतिनिधित्व किया जा सकता है । यहाँ आकार 1अंक दिए गए हैं :

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

प्रत्येक सेगमेंट को आनुपातिक रूप से लंबा करके बड़े आकार बनाए जाते हैं। यहाँ एक जोड़े के 3 अंक हैं।

 ___    ___    ___    ___    ___    ___    ___ 
|   |  |          |  |          |  |   |  |   |
|   |  |          |  |          |  |   |  |   |
|___|  |___       |  |___    ___|  |   |  |___|
|   |  |   |      |      |      |  |   |      |
|   |  |   |      |      |      |  |   |      |
|___|  |___|      |   ___|   ___|  |___|   ___|

लक्ष्य

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

यह कोड-गोल्फ , सबसे कम बाइट्स जीतता है।

आप या तो एक कार्यक्रम या एक फ़ंक्शन लिख सकते हैं, जो अंक को या तो STDIN या एक तर्क के रूप में प्राप्त कर सकता है, और मूल्य को प्रिंट / वापस कर सकता है।

अंकों को एक बहु-पंक्ति स्ट्रिंग के रूप में प्रदान किया जाएगा, जिसे एक पूर्ण आयत बनाने के लिए आवश्यक अनुगामी व्हॉट्सएप की न्यूनतम मात्रा के साथ गद्देदार किया जाएगा। अनुगामी न्यूलाइन इनपुट का एक वैकल्पिक हिस्सा है। कोई अनावश्यक अग्रणी स्थान नहीं होगा।

जब एक गैर-अंक पारित किया जाता है, तो यह अभी भी _|वर्णों से युक्त होगा, एक आयत के लिए गद्देदार, और इसमें कोई अनावश्यक लीड नहीं है। कोई खाली लाइनें नहीं होंगी। आपको खाली इनपुट से नहीं जूझना पड़ेगा।

आउटपुट एक एकल गैर-नकारात्मक पूर्णांक होना चाहिए, जिसमें वैकल्पिक अनुगामी न्यूलाइन है। यदि इनपुट किसी भी आकार, आउटपुट का उचित अंक नहीं है 0। आकार, आकार आउटपुट।

यहां दिए गए आकार के लिए प्रत्येक अंक की चौड़ाई और ऊंचाइयों के लिए एक आसान मार्गदर्शिका है N।

Digit  Height  Width (not counting newlines)
1      2N      1
2      2N+1    N+2
3      2N+1    N+1
4      2N      N+2
5      2N+1    N+2
6      2N+1    N+2
7      2N+1    N+1
8      2N+1    N+2
9      2N+1    N+2
0      2N+1    N+2

I / O उदाहरण

में:

__ 
  |
__|
  |
__|

बाहर:

2

में:

|
|
|

बाहर:

0  //because it is of an invalid height.  Either 1 char too short or tall.

में:

|    |
|    |
|    |
|____|
     |
     |
     |
     |

बाहर:

4

में:

 ___ 
|    
|___ 
|   |
|___|

बाहर:

0 //1 char too wide

में:

 _ 
|_|
| |

बाहर:

0 //it's not a digit

में:

 __ 
|   
|__ 
   |
 __|

बाहर:

2

में:

 _  _ 
 _| _|
|_  _|

बाहर:

0  //both would be valid individually, but input should be a *single* digit

में:

 _ 
|_|
|_|

बाहर:

1

में:

|
|

बाहर:

1

में:

__|_
 |  
 _ |
  _ 
|__ 

बाहर:

0

---

यह लगभग 3 साल पहले से 7-सेगमेंट डिस्प्ले पैटर्न में ट्रांसफॉर्म नंबर का विलोम है ।

Comments

@steveverrill वास्तव में आकार 0अंक के रूप में ऐसी कोई चीज नहीं है , है? जब तक आप उन्हें आकर्षित करने का एक तरीका नहीं सोचते।

— PhiNotPi 16

यह अविश्वसनीय रूप से आसान होगा यदि नियम के लिए नहीं कि यह एक वैध अंक होना चाहिए ...

— ETHproductions

@ETHproductions मैं जागरूक हूं।

— फीनोटपी

@ETHproductions यदि इसकी आवश्यकता नहीं होती, तो यह codegolf.stackexchange.com/q/19548/15599 की

— लेवल रिवर सेंट

Answer 1

रूबी, 250

->x{d=y=0
x.size.downto(0){|n|y=n
a=["|
"*2*n]
"XNRDqpm@A".bytes{|z|p=[?|,' ','']
h=s=""
(n*2).times{|i|
i%n<1&&(d=z>>i/n*3&7)&&h=[?_,' '][d/3%2]*n
s=p[d%3]+h+p[d/6]+"
"+s
h=' '*n}
z!=68&&s=' '*(1-d%3/2)+?_*n+" 
"+s
a<<s};puts a
a.index(x)&&break}
y}

यह देखते हुए कि बहुत सारे संभव अमान्य इनपुट हैं, ऐसा करने का एकमात्र तरीका सभी सही अंक उत्पन्न करना और यह देखने के लिए जांच करना है कि क्या इनपुट मेल खाता है।

मैं प्रत्येक अंक को नीचे से ऊपर तक, 2 हिस्सों में और ऊपर की रेखा के ऊपर बनाता हूं। यद्यपि 12 संभावनाएं हैं (यह देखते हुए कि बाएं खंड चालू या बंद हो सकता है 3और 7पूरी तरह से अनुपस्थित है) केवल 7 वास्तव में मौजूद हैं और एन्कोडिंग का सावधानीपूर्वक चयन सभी जानकारी (शीर्ष पंक्ति को छोड़कर) को एन्कोड करने में सक्षम बनाता है एकल चरित्र।

अंक 1वास्तव में पैटर्न को फिट नहीं करता है और इसे अलग से नियंत्रित किया जाता है, जिसका उपयोग सरणी को आरंभीकृत करने के लिए किया जाता है।

परीक्षण कार्यक्रम में अपराजित

यह संस्करण .नैदानिक ​​कारणों से रिक्त स्थान के बजाय उपयोग करता है।

#Encoding used for half-digits (radix 3,2,2 most significant digit at right)

#000    |_|  0

#100    ._|  1  . = space

#200    X_|  2  X = no space (for digits 3 and 7)  

#010    |.|  3

#110    ..|  4

#210    X.|  5

#001    |_.  6


f=->x{d=y=0                                        #d and y required to be intialized for scoping reasons
  x.size.downto(0){|n|y=n                          #Assume max possible size of character = length of input and iterate down through all possible sizes n   
    a=["|\n"*2*n]                                  #Make an array containing the digit 1 (different shape to others)
    "XNRDqpm@A".bytes{|z|                          #Each character encodes the pattern for a digit. Iterate through them
      p=['|','.','']                               #Possible components for left and right of digit
      h=s=""                                       #h initialized for scoping reasons. s will contain the digit string 
      (n*2).times{|i|                              #For each row
        i%n<1&&                                    #If i%n==1 we are at the bottom of a half digit
        (d=z>>i/n*3&7)&&                           #so extract info from z and store in d
        h=[?_,'.'][d/3%2]*n                        #h is the horizontal part of the half digit, either _ or spaces 
        s=p[d%3]+h+p[d/6]+"\n"+s                   #Build one row of digit, working upwards: left,middle,right
        h='.'*n                                    #If row i%n!=0 (not bottom row of half digit)the middle section must contain spaces
      }                                            #We now have both halves of the digit, only the top segment missing 
      z!=68&&s='.'*(1-d%3/2)+?_*n+".\n"+s          #If z!=68 (digit 4) add a top to the digit, with appropriate leading and trailing spaces        
      a<<s                                         #Add the completed digit of size n to a
    }
    #puts a                                        #Diagnostic: uncomment to print all the strings checked
    a.index(x)&&break                              #If string x is in a, break

  }
y                                                  #and return last value of n 
}


# digit 7, size 2. Trailing newline required. Outputs 2
puts f[
"__.
..|
..|
..|
..|
"]