_{अंक किस आकार से चोरी हुआ है?}

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

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

आपका काम कला को सामान्य संख्या में पार्स करना है।

नंबरों पर नोट

प्रत्येक अंक की एक अलग चौड़ाई होती है।
- 1 की चौड़ाई है 1
- 3और 7कर रहे हैं 2विस्तृत
- 245689और 0सभी 3चौड़े हैं

इसके अलावा प्रत्येक अंक गद्दी के एक चार है। यहाँ पूर्ण चार सेट है:

 // <- एक स्थान होना चाहिए, लेकिन एसई स्वरूपण ने इसे गड़बड़ कर दिया
|
|
-------------
 _ 
 _ |
| _ 
-------------
_ 
_ |
_ |
-------------

| _ |
  |
-------------
 _ 
| _ 
 _ |
-------------
 _ 
| _ 
| _ |
-------------
_ 
 |
 |
-------------
 _ 
| _ |
| _ |
-------------
 _ 
| _ |
 _ |
-------------
 _ 
| |
| _ |

इनपुट

इनपुट या तो कंसोल से हो सकता है या एक फ़ंक्शन के लिए स्ट्रिंग arg के रूप में।

उत्पादन

आउटपुट या तो कंसोल में डाला जाता है या फ़ंक्शन से लौटाया जाता है।

उदाहरण:

  _  _   _ 
|  |  | |_ 
|  |  | |_|
1776

 _   _     _ 
 _| | | | |_ 
|_  |_| | |_|
2016

   _       _ 
| |_| |_| |_ 
|  _|   |  _|
1945

   _   _   _   _   _   _ 
| | | | | | | | | | | | |
| |_| |_| |_| |_| |_| |_|
1000000

 _     _  _       _   _  _   _   _ 
| | |  _| _| |_| |_  |_   | |_| |_|
|_| | |_  _|   |  _| |_|  | |_|  _|
0123456789

यह कोड-गोल्फ इतना छोटा बाइट गिनती जीत है!

code-golf string parsing

— जे एटकिन
स्रोत

पायथ, 33 30 बाइट्स

sm@."/9Àøw"%%Csd409hTcC.z*3d

यहां यह विचार है: एक बार जब हम इनपुट को स्थानांतरित करते हैं, और अंकों में विभाजित होते हैं, तो हम व्यक्तिगत अंकों के तार को हैश कर सकते हैं और उन्हें अपने मूल्यों पर असाइन कर सकते हैं।

sm@."/9Àøw"%%Csd409hTcC.z*3d     Implicit: z=input
                      C.z        Transpose input.
                     c   *3d     Split that on "   ", a space between digits.
 m@."/9Àøw"%%Csd409hT            Map the following lambda d over that. d is a digit string.
             Csd                   Flatten the digit string, and convert from base 256.
            %   409                Modulo that by 409
           %       hT              and then by 11. All digits go to a distinct num mod 11.
   ."/9Àøw"                        The compressed string "03924785/61".
  @                                Index into that string.
s                                Flatten and implicitly output.

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत

कूल, मूल रूप से मेरे दृष्टिकोण की तरह दिखता है लेकिन बहुत छोटा है!

— लिन

@Lynn इस बारे में क्षमा करें; पायथ में ऐसा करने का मूल रूप से एक सबसे छोटा तरीका है।

— 20

4

रूबी, 184 बाइट्स

a=0
l=$<.map{|x|x.bytes.map{|y|y==32?0:1}+[0]*2}
(0..l[0].count-1).map{|i|l[0][i]+2*l[1][i]+4*l[2][i]}.each{|x|
x>0?(a=x+2*a):(p Hash[[40,6,32,20,18,26,42,8,44,64].zip(0..9)][a];a=0)}

व्याख्या

स्टड से इनपुट लेता है
बाइनरी दृश्यों के लिए स्ट्रिंग्स को कनवर्ट करता है, खंड पर / बंद के लिए 1/0
कॉलम को 3 बिट बाइनरी नंबर पर एन्कोड करता है
3 बिट संख्या से 9 बिट संख्या के अनुक्रम सांकेतिक शब्दों में बदलना, स्टॉप प्रतीकों के रूप में '0' कॉलम का उपयोग करें
9 बिट संख्याओं को अंकों में बदलने के लिए लुकअप टेबल का उपयोग करें

यह मेरा पहला कोड-गोल्फ है। मस्ती के लिए धन्यवाद!

— bogl
स्रोत

2

PPCG में आपका स्वागत है! अपनी पहली पोस्ट पर बहुत अच्छा काम!

— J Atkin

2

पायथ, 39 बाइट्स

sm@"413-928-506--7"%%Crd6C\524cjbC.z*3d

यह काम करने लगता है? इसे ऑनलाइन आज़माएं ।

— लिन
स्रोत

2

जाप, 119 बाइट्स

Ur"[|_]"1 z r" +
"R x1 qR² £"11
1 1
1151151
111
 15111
115 1
 1
115 1
111
1511
111
15  1
11511
111
115 1
111
11"q5 bXÃq

Try it here!

ओह, यह एक बहुत लंबा है। मुझे नहीं लगता कि मैंने गोल्फिंग पूरी की है।

व्याख्या

तैयारी

हम इनपुट लेते हैं और किसी भी में कनवर्ट |_करते हैं 1। फिर हम स्थानान्तरण करते हैं, रिक्त स्थान समाप्त करते हैं, और डबल-न्यूलाइन्स के साथ विभाजित होते हैं।

अनुवाद

हम परिणामी सरणी पर मैप करते हैं और इंडेक्स को देखते हैं जहां फॉर्म एक संदर्भ सरणी में दिखाई देता है। यहाँ मदद करने के लिए एक आरेख है:

MAPITEM
  11
  1 1 --> This same form appears at index 0 in the reference array
  11                            |
                                |
                                V
                        change the mapitem to 0!

उसके बाद, हम संख्या और आउटपुट की सरणी से जुड़ते हैं!

नोट : आप सोच रहे होंगे कि हमें प्रत्येक कला चरित्र को 1 की श्रृंखला में क्यों बदलना है। ऐसा इसलिए है क्योंकि वहाँ एक बग (या ऐसा कुछ) प्रतीत होता है जो मुझे पात्रों को स्टोर करने की अनुमति नहीं देता है जैसा कि है |_।

— मामा फन रोल
स्रोत

मैंने _बग को देखा , लेकिन मुझे नहीं पता कि इसकी वजह क्या थी।

— ETHproductions

ठीक है, के "\n\n"साथ R²और "\\||_"साथ प्रतिस्थापित किया जा सकता है "%||_"। मुझे लगता है कि आप भी कर सकते थे आधार 4 (4 disinctive वर्ण से प्रत्येक को बदलने के लिए लंबी स्ट्रिंग एन्कोडिंग द्वारा कुछ बाइट्स बचाने 0, 1, 2, या 3, 4 की एक बहु की लंबाई करने के लिए गद्दी, तो चल रहा है r"...."_n4 d}इस पर), लेकिन किसी कारण से , मैंने अभी तक यह काम नहीं किया है।

— ETHproductions

2

पायथन 2, 299 261 244 बाइट्स

s=lambda a,i=0:[a]if i==len(a[0])else[[j[:i]for j in a]]+s([j[i+1:]for j in a])if all(j[i]==' 'for j in a)else s(a,i=i+1)
p=lambda l:['95572431508448853268'.find(`sum(ord(c)**i for i,c in enumerate("".join(n)))%108`)/2for n in s(l.split('\n'))]

मुझे यह चुनौती बहुत अच्छी लगी!

व्याख्या

फ़ंक्शन sइनपुट के रूप में तीन पंक्तियों को लेता है, यह एक अंक पृथक्करण खोजने की कोशिश करता है (सभी वर्ण रिक्त स्थान हैं)। जब ऐसा पृथक्करण पाया जाता है तो यह sशेष तीन रेखाओं के साथ कॉल करता है और कॉल द्वारा लौटाए गए मान को उन तीन पंक्तियों में जोड़ देता है जो अंक बनाते हैं। यदि कोई पृथक्करण नहीं है तो इसका अर्थ है कि केवल एक अंक है।

फ़ंक्शन pप्रविष्टि बिंदु है इसलिए यह एक स्ट्रिंग लेता है जो अंकों का प्रतिनिधित्व करता है। अंकों को "हैश" के रूप में संग्रहीत किया जाता है sum(ord(c)**i for i,c in enumerate("".join(n)))%108ताकि अंतरिक्ष को बचाने के लिए गणना की जा सके (अन्य उत्तरों के लिए धन्यवाद!)।

उदाहरण

digits="""
 _     _ 
| | |  _|
|_| | |_ """[1:]  # remove the '\n' at the beginning

p(digits)  # [0, 1, 2]

अन्य संस्करण

261 बाइट्स (py3):

s=lambda a,i=0:[a]if i==len(a[0])else[[j[:i]for j in a]]+s([j[i+1:]for j in a])if all(j[i]==' 'for j in a)else s(a,i=i+1)
def p(l):[print([91,21,84,31,58,76,88,41,80,68].index(sum(ord(c)**i%20 for i,c in enumerate("".join(n)))),end="")for n in s(l.split('\n'))]

249 बाइट्स, यह एक लाइनों को स्थानांतरित करता है (py2):

f="".join
s=lambda a,i=0:[a]if i==len(a)else[a[:i]]+s(a[i+1:])if all(c==' 'for c in a[i])else s(a,i=i+1)
h=lambda s:ord(s[0])**len(s)+h(s[1:])if s else 0
p=lambda l:["10220907112527153129".index(`h(f(map(f,n)))%34`)/2for n in s(zip(*l.split('\n')))]

— डी आई सी ए
स्रोत

2

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

a=>[...(a=a.split`
`)[0]].map((b,c)=>(d={' ':0,'|':1,'_':2})[b]+d[a[1][c]]*2+d[a[2][c]]).join``.split(0).map(b=>[343,3,182,83,243,281,381,23,383,283].indexOf(+b)).join``

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

— Mwr247
स्रोत

बहुत अच्छा! काश अजगर ने लिस्ट स्प्लिट फंक्शन होता ...

— J Atkin

@ जेटकिन मैं joinएक स्ट्रिंग में एड करता हूं ताकि मैं इसे विभाजित कर सकूं । मेरा मानना है कि आप पायथन में भी ऐसा कर सकते हैं?

— Mwr247

0

पायथन 3, 281 254 बाइट्स

संपादित करें

मैंने सिर्फ दूसरे अजगर के उत्तर के लिए कोड को देखा और देखा कि बहुत से कोड समान हैं। यह स्वतंत्र रूप से आ गया था।

(नई पठनीयता "पठनीयता" के लिए जोड़ी गई)

def p(i):
 n=[[]]
 for l in zip(*i.split('\n')):
  if all(i==" "for i in l):n+=[[]]
  else:n[-1]+=l
 return''.join(map(lambda l:str([''.join(l[2:])==x for x in
             "|_ _ ||,|,|___ | ,_ ||,  _  ||, ___  |,|___  |,  ||,|___ ||, ___ ||"
                     .split(',')].index(1)),n))

Ungolfed:

def parse(input):
    lines = list(input.split('\n'))
    numbers = [[]]
    for lst in zip(*lines):
        if all(i==" " for i in lst):
            numbers += [[]]
        else:
            numbers[-1] += lst
    return ''.join(map(digit, numbers))

def digit(num):
    fingerprint = 
        "|_ _ ||,|,|___ | ,_ ||,  _  ||, ___  |,|___  |,  ||,|___ ||, ___ ||".split(',')
    return str([''.join(num[2:]) == y for y in fingerprint].index(True))

टेस्ट:

assert (parse("   _   _   _   _   _   _ \n| | | | | | | | | | | | |\n| |_| |_| |_| |_| |_| |_|") == '1000000')
assert (parse("   _       _ \n| |_| |_| |_ \n|  _|   |  _|") == '1945')
assert (parse(" _   _     _ \n _| | | | |_ \n|_  |_| | |_|") == '2016')
assert (parse(" _     _  _       _   _  _   _   _ \n| | |  _| _| |_| |_  |_   | |_| |_|\n|_| | |_  _|   |  _| |_|  | |_|  _|") == '0123456789')
assert (parse("  _  _   _ \n|  |  | |_ \n|  |  | |_|") == '1776')

यह काम किस प्रकार करता है

(ध्यान दें: मैं यहाँ अनप्लग्ड प्रोग्राम की व्याख्या कर रहा हूँ क्योंकि यह अधिक पठनीय है और इसमें सटीक एक ही कोड है, इस अपवाद के साथ कि digitफ़ंक्शन एक मेमने में पंक्तिबद्ध है)

def parse(input):
    lines = list(input.split('\n'))
    numbers = [[]]

मुख्य कार्य है parse। यह पहले इनपुट को लाइनों में विभाजित करता है और numbersसरणी बनाता है ।

    for lst in zip(*lines):
        if all(i==" " for i in lst):
            numbers += [[]]
        else:
            numbers[-1] += lst

यह मेरा पसंदीदा हिस्सा है (क्योंकि यह पता लगाने में इतना समय लगा)। यहां हम zipलाइनें हैं ताकि हम मूल रूप से इनपुट को लंबवत रूप से पार कर सकें। जब लाइन पर वर्ण होता है, तो हम इसे numbersसरणी में अंतिम संख्या में जोड़ देते हैं । यदि उस पर कोई वर्ण नहीं है तो हम सरणी में एक नया नंबर जोड़ते हैं।

    return ''.join(map(digit, numbers))

वास्तव में सरल, numbersdigit फ़ंक्शन के साथ मैप किया गया है और इसे स्ट्रिंग में परिवर्तित किया गया है।

def digit(num):
    fingerprint = 
        "|_ _ ||,|,|___ | ,_ ||,  _  ||, ___  |,|___  |,  ||,|___ ||, ___ ||".split(',')
    return str([''.join(x[2:]) == y for x, y in zip([num]*10, fingerprint)].index(True))

यह (काफी) सरल है। fingerprintपहले 2 वर्णों के ऊपर बनाए गए अंकों का स्ट्रिंग प्रतिनिधित्व है (यह सबसे छोटा फिंगरप्रिंट था जिसे मैं पा सकता था)। हम पहले मैच का इंडेक्स लौटाते हैं।

— जे एटकिन
स्रोत

0

हास्केल, 270 207 बाइट्स

बहुत मुश्किल मत बनो, यह मेरा अब तक का पहला हैस्केल प्रोग्राम है;) मैं लगभग निश्चित हूं कि इसे आगे बढ़ाया जा सकता है, लेकिन मुझे नहीं पता कि भाषा का मेरा सीमित ज्ञान कैसे दिया गया।

import Data.Lists
b n=map c$splitOn["   "]$transpose$lines n
c n|e<-drop 2$concat n,Just r<-elemIndex True[e==f|f<-splitOn",""|_ _ ||,|,|___ | ,_ ||,  _  ||, ___  |,|___  |,  ||,|___ ||, ___ ||"]=(show r)!!0

Ungolfed:

module Main where
import Data.Lists

main :: IO ()
main = print $ parse " _     _  _       _   _  _   _   _ \n| | |  _| _| |_| |_  |_   | |_| |_|\n|_| | |_  _|   |  _| |_|  | |_|  _|"

parse :: String -> String
parse n = let lst = transpose $ lines n
              numbers = splitOn ["   "] lst --"   " lst
              number = map digit numbers
          in number

digit :: [String] -> Char
digit n | e <- drop 2 $ intercalate "" n
        , fingerprint <- ["|_ _ ||","|","|___ | ","_ ||","  _  ||"," ___  |","|___  |","  ||","|___ ||"," ___ ||"]
        , Just res <- elemIndex True [e == finger | finger <- fingerprint]
        = head $ show res

युक्तियों के लिए @nimi के लिए बड़ा धन्यवाद!

— जे एटकिन
स्रोत

बुरी खबर पहले: मुझे डर है कि आपको import Data.Listअपनी बाइट गिनती में शामिल करना होगा । अच्छी खबर: क) यदि आपने Data.Listsस्थापित किया है तो आप इसके बजाय इसे आयात कर सकते हैं और इसके aसाथ बदल सकते हैं splitOn: ...map c$splitOn[" "]$transpose...और ...f<-splitOn",""|_...। ख) intercalate "" nहै concat nया id=<<n। c) resएक अक्षर के नाम के साथ बदलें । घ) के उपयोग की पद्धति के बजाय रक्षा करता है let ... in: c n|e<-drop 2$id=<<n,Just r<-elemIndex ... ]=(show r)!!0।

— 22

हेहेहे, वूप्स! आयात कॉपी / पेस्ट में खो गया था;) सभी युक्तियों के लिए धन्यवाद!

— जे एटकिन

@nimi आपको इसके बारे में परेशान करने के लिए क्षमा करें, लेकिन क्या आप बताते हैं कि आप क्या =<<करते हैं? न तो हॉगल डॉक्स या टाइप सिग्नेचर मेरे लिए बहुत मददगार हैं।

— जे एटकिन

=<<सूची के संदर्भ में concatMap, यानी यह सूची में दिए गए फ़ंक्शन को मैप करता है और परिणामों को एक सूची में जोड़ता है। >>=एक ही करता है लेकिन तर्कों के साथ फ़्लिप किया। id =<< n(या n >>= id) सूची (सूचियों) पर पहचान फ़ंक्शन को मैप करता है, यानी सब्लिस्ट्स के साथ कुछ भी नहीं करता है और उन्हें सहमति देता है। तो यह भी ऐसा ही है concat।

— nimi

एक रेट्रो डिस्प्ले पढ़ें

नंबरों पर नोट

इनपुट

उत्पादन

उदाहरण:

पायथ, 33 30 बाइट्स

रूबी, 184 बाइट्स

व्याख्या

पायथ, 39 बाइट्स

जाप, 119 बाइट्स

व्याख्या

तैयारी

अनुवाद

पायथन 2, 299 261 244 बाइट्स

व्याख्या

उदाहरण

अन्य संस्करण

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

पायथन 3, 281 254 बाइट्स

संपादित करें

यह काम किस प्रकार करता है

हास्केल, 270 207 बाइट्स