बारकोडगॉल्फ: एक नंबर का UPC बनाएं

Question

बस हर दुकान के बारे में आजकल यूनिवर्सल उत्पाद कोड (यूपीसी) बारकोड का उपयोग करता है ताकि चेकिंग प्रक्रिया को सरल बनाया जा सके। यदि नाम का आपके लिए कोई मतलब नहीं है, तो आप निश्चित रूप से पहचान लेंगे कि वे क्या दिखते हैं:

स्वरूप

सबसे आम प्रणाली यूपीसी-ए है, जो प्रत्येक विशिष्ट उत्पाद का प्रतिनिधित्व करने के लिए 12 अंकों का उपयोग करती है। प्रत्येक अंक को कोड को सात बिट की लंबाई वाली मशीनों को पढ़ने की अनुमति देने के लिए काले और सफेद धारियों की एक श्रृंखला में एन्कोड किया गया है। बारकोड की शुरुआत, मध्य और अंत को इंगित करने वाले पैटर्न के कुल 11 बिट्स हैं। यह 12 × 7 + 11 = 95 बिट्स की कुल बारकोड लंबाई के लिए आता है। (अब से, जब बाइनरी का उपयोग प्रत्येक बिट के रंग को संदर्भित करने के लिए किया जाता है, 0सफेद है और 1काला है।)

शुरुआत और अंत दोनों का एक पैटर्न है 101। अंकों को फिर 6 के 2 समूहों में विभाजित किया जाता है और नीचे दिखाए गए अनुसार एन्कोड किया जाता है, 01010बाएं और दाएं समूहों के बीच एक पैटर्न के साथ । यह तालिका प्रत्येक संख्या के लिए पैटर्न को सूचीबद्ध करती है। ध्यान दें कि यदि यह अंक दाईं ओर या बाईं ओर है, तो यह पैटर्न अलग-अलग है (यह बारकोड को उल्टा स्कैन करने की अनुमति देता है)। हालाँकि, दाईं ओर का पैटर्न बाईं ओर के सफेद (इसके विपरीत सफेद और इसके विपरीत स्वैप ब्लैक) है।

यदि आप ऊपर की छवि नहीं देख सकते हैं, तो यह प्रत्येक संख्या के बाइनरी समकक्ष है।

#   Left    Right
0   0001101 1110010
1   0011001 1100110
2   0010011 1101100
3   0111101 1000010
4   0100011 1011100
5   0110001 1001110
6   0101111 1010000
7   0111011 1000100
8   0110111 1001000
9   0001011 1110100

उदाहरण

कहते हैं कि आपके पास यूपीसी है 022000 125033। (वे यादृच्छिक संख्याएँ नहीं हैं। यदि आप उनके महत्व का पता लगाते हैं तो एक टिप्पणी छोड़ दें।) आप इस बॉयलरप्लेट से शुरू करते हैं जो हर बारकोड में समान है:

101xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx01010xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx101

अंकों के लिए, आप प्रत्येक को उसी तरफ (बाएं या दाएं) के लिए संबंधित एन्कोडिंग के साथ बदलते हैं। यदि आप अभी भी भ्रमित हैं, तो नीचे दी गई छवि देखें।

यहां बाइनरी में आउटपुट |पाइप के साथ भागों को अलग करता है।

101|0001101|0010011|0010011|0001101|0001101|0001101|01010|1100110|1101100|1001110|1110010|1000010|1000010|101

चुनौती

एक प्रोग्राम लिखें जो उपयोगकर्ता इनपुट के लिए यूपीसी-ए बारकोड को आउटपुट करता है। छवि का आयाम 95 × 30 पिक्सेल होना चाहिए, जिसमें प्रत्येक "बिट" एक पिक्सेल चौड़ा और 30 पिक्सेल लंबा होगा। काली धारियाँ अंदर होती हैं rgb(0, 0, 0)और सफेद धारियाँ लगातार पारदर्शी होती हैं या rgb(255, 255, 255)।

टिप्पणियाँ

• स्टड या कमांड लाइन से इनपुट लें, या एक फ़ंक्शन लिखें जो एक स्ट्रिंग या पूर्णांक लेता है (ध्यान दें कि इनपुट में अग्रणी शून्य हो सकते हैं, और अधिकांश भाषाएं उन्हें हटा देती हैं या संख्या को ऑक्टल में बदल देती हैं)।
• निम्न तरीकों में से किसी एक में आउटपुट करें:
  • इसे अपनी पसंद के नाम और प्रारूप (PNG, PBM, आदि) वाली फ़ाइल में सहेजें।
  • इसे स्क्रीन पर प्रदर्शित करें।
  • स्टडआउट के लिए अपने फ़ाइल डेटा आउटपुट।
• आप पुस्तकालयों या बिल्डरों का उपयोग नहीं कर सकते हैं जो बारकोड उत्पन्न करते हैं ( मैं आपको देख रहा हूं, गणितज्ञ ), हालांकि आप छवि या ग्राफिक्स पुस्तकालयों का उपयोग कर सकते हैं।
• UPC का अंतिम अंक आमतौर पर एक चेक अंक होता है , लेकिन इन उद्देश्यों के लिए आपको इसके बारे में चिंता करने की आवश्यकता नहीं है।

उदाहरण

अपने कोड का परीक्षण करने के लिए यहां कुछ और उदाहरण दिए गए हैं। सुविधा के लिए बाइनरी आउटपुट भी दिया गया है।

इनपुट: 012345678910

आउटपुट:

10100011010011001001001101111010100011011000101010101000010001001001000111010011001101110010101

इनपुट: 777777222222

आउटपुट:

10101110110111011011101101110110111011011101101010110110011011001101100110110011011001101100101

स्कोरिंग

यह कोड गोल्फ है , इसलिए सबसे छोटा सबमिशन (बाइट्स जीत में)। टाईब्रेकर सबसे शुरुआती पद पर जाता है।

Comments

मम्म ... रसीले फल।

— डेनिस

क्या इनपुट को एक सरणी के रूप में लिया जा सकता है? जैसे["777777","222222"]

— डाउगोएट

@vihan हम्म, मुझे लगता है कि थोड़ा खिंचाव है। मैं ना कहने जा रहा हूँ।

— NinjaBearMonkey

पहले UPC बारकोड स्कैन किया गया!

— डेनिस

ये जबरदस्त है। बारकोड ने हमेशा मुझे मोहित किया है

— बीटा डिके

Answer 1

सीजेएम, 58 57 बाइट्स

'P1N95S30N[A1r:~"rflB\NPDHt":i2fbf=:R6<::!0AAR6>A1]s30*S*

एक पोर्टेबल BitMap (ASCII) को STDOUT में प्रिंट करता है। इसे ऑनलाइन आज़माएं।

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

'P1N95S30N     e# Push 'P', 1, '\n', 95, ' ', 30 and '\n'.

[              e#
  A1           e#   Push 10 and 1.
  r            e#   Read a token from STDIN.
  :~           e#   Caluate each character ('0' -> 0).
  "rflB\NPDHt" e#   Push that string.
  :i           e#   Cast each character to integer.
               e#   This pushes [114 102 108 66 92 78 80 68 72 116].
  2fb          e#   Convert each integer to base 2.
               e#   This pushes the representations for the right side.
  f=           e#   Select the proper representation of each digit in the input.
  :R           e#   Save the result in R.
  6<           e#   Keep the representations of the first six digits.
  ::!          e#   Negate each binary digit to obtain the "left" representation.
  0AA          e#   Push 0, 10, 10.
  R6>          e#   Push the representations of the last six digits.
  A1           e#   Push 10, 1.
]s             e# Collect in an array and cast to string.

30*            e# Repeat the resulting string 30 times.
S*             e# Join it, using spaces as separators.

Answer 2

Rev 1 BBC BASIC, 155 ascii char, tokenised filesize 132 बाइट्स

INPUTn$
FORi=91TO185p=i MOD2j=i MOD47IFj<42j+=i DIV141*42p=(j>41EORASC(MID$("XLd^bFznvh",VAL(MID$(n$,j/7+1,1))+1)))>>(j MOD7)AND1
IFp LINEi*2,60,i*2,0
NEXT

43 के ऑफसेट को iलूप में शामिल करके कुछ बाइट्स को बचाया । MOD2अतिरिक्त 47 को तोड़ने से बचने के लिए, कुल 90 के लिए जोड़ा जाना था।

यह बारकोड को मूल से आगे बढ़ाता है, जैसा कि दिखाया गया है, यदि यह स्वीकार्य है:

रेव 0 बीबीसी बेसिक, 157 आस्की चरस, टोकन वाली फाइलें 137 बाइट्स होती हैं

INPUTn$
FORi=1TO95p=i MOD2j=(i+43)MOD47IFj<42j+=i DIV51*42p=(i>50EORASC(MID$("XLd^bFznvh",VAL(MID$(n$,j/7+1,1))+1)))>>(j MOD7)AND1
IFp LINEi*2,0,i*2,60
NEXT

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

डिफ़ॉल्ट स्क्रीन मोड एक सफेद पृष्ठभूमि पर काला पाठ है। यह मूल बीबीसी बीएएससी से अलग है।

परीक्षण मुद्रण के साथ Ungolfed संस्करण

एक डेटा बार की गणना पर निर्भर करता है IF j<42और सभी एक लाइन पर किया जाना चाहिए। अनगुल्ड संस्करण में यह तीन चरणों में किया जाता है। गोल्फ संस्करण में अंतिम दो चरणों को एक ही विशाल अभिव्यक्ति में जोड़ा जाता हैp=...

मुझे बिटमैप्स के क्रम को उल्टा करना पड़ा, क्योंकि मैं >>(j MOD 7)बिट्स का उपयोग करने के लिए उपयोग करता हूं, जिसका अर्थ है कि मैं पहले कम से कम महत्वपूर्ण बिट का उपयोग करता हूं। एक बार ऐसा करने के बाद, सभी बाएं बिटमैप आसानी से ASCII रेंज में हैं।

  INPUTn$
  FOR i=1TO95                            :REM iterate through 95 bars
    p=i MOD2                             :REM calculate colour of format bar 1=black
    j=(i+43)MOD47                        :REM repetition is 42 data bars + 5 format bars. offset and modulo. if j<42 it is a data bar and we must change p.

    REM if i DIV 51=1 we are in the second half, so add 42 to j. Find the bitmap for left hand value, from character j/7 of the input.
    REM i>50 evaluates to false=0 true=-1. XOR this with p to invert bitmap for right hand side. Shift and AND with 1.  
    IF j<42 j+=i DIV51*42:p=ASC(MID$("XLd^bFznvh",  VAL(MID$(n$,j/7+1,1))+1  )) :p=(i>50EORp)>>(j MOD7) AND 1

    IF j MOD 7 = 0 PRINT                  :REM format test output
    PRINT ;p;                             :REM print test output
    IF p LINEi*2-2,0,i*2-2,60             :REM if p=1 plot bar. there are 2 logical units for each pixel.
  NEXT

विशिष्ट आउटपुट, परीक्षण आउटपुट के साथ अनगुल्ड संस्करण

Answer 3

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

s=>`P1
30 90
`+([...`101${(f=(z,j)=>[...j].map(i=>`000${z[+i].toString(2)}`.slice(-7)).join``)([13,25,19,61,35,49,47,59,55,11],s[0])}01010${f([114,102,108,66,92,78,80,68,72,116],s[1])}101`].join` `+`
`).repeat(30).slice(0,-1)

ES7 सुविधाओं के साथ कम हो सकता है, लेकिन मैं उनके समर्थन के बारे में निश्चित नहीं हूं इसलिए मैं ES6 के साथ चिपका रहा हूं। मैं एक सरणी के रूप में एक इनपुट भी मान रहा हूं। आउटपुट एक PBN फाइल है । वहाँ भी बहुत से गोल्फ करना है।

अगर मैंने कुछ भी गलत किया, तो मैं एक टिप्पणी छोड़ दूंगा और इसे ठीक करना सुनिश्चित करूंगा

Comments

मुझे लगता है कि आपका मतलब पीबीएम फ़ाइल है ...

— सर्गियोल

Answer 4

पर्ल, 153 बाइट्स

substr($_=<>,6,0)=A;y/0-9A/=ICmSa_kg;0/;$s.=sprintf("%07b",-48+ord$1^($k++>6?127:0))while/(.)/g;$s=~s/0{7}/01010/;print"P1
95 30
".('101'.$s.'101'.$/)x30

फ़ाइल बारकोड.perl पर कॉपी करें और फिर इस तरह चलाएँ:

perl barcode.perl > output.pbm

फिर बारकोड नंबर इनपुट करें।

स्पष्टीकरण:

बारकोड अंकों के लिए बिट पैटर्न एक स्ट्रिंग में संग्रहीत होते हैं और पर्ल y///ट्रांसलिटरेशन ऑपरेटर का उपयोग करके इनपुट अंकों के लिए प्रतिस्थापित किया जाता है । प्रतिस्थापन स्ट्रिंग में प्रत्येक मान में 48 (ASCII '0') जोड़ा गया है, जो कि अनपेक्षित वर्णों से बचने के लिए है। बारकोड की दूसरी छमाही में अंक पहले छमाही में उन के व्युत्क्रम हैं।

केंद्रीय पैटर्न 0000000 पर सेट होता है (ऐसा पैटर्न जो अन्यथा कभी प्रकट नहीं हो सकता है, जिसे 'ए' और फिर '0' के रूप में एन्कोड किया गया है) और फिर sprintआईएनजी के साथ एक विशेष मामले के रूप में अपनी अलग लंबाई को संभालने के बजाय 01010 के साथ प्रतिस्थापित किया गया है ।

Answer 5

ऑक्टेव, 115 बाइट्स

function b(s)
n='rflB\MPDHt'-0;r=dec2bin(n(s-47)',7)'(:)-48;v=[a=[1 0 1] ~r(1:42)' 0 a r(43:84)' a];v(ones(30,1),:)

बहु-पंक्ति संस्करण:

function b(s)
   n='rflB\MPDHt'-0;
   r=dec2bin(n(s-47)',7)'(:)-48;
   v=[a=[1 0 1] ~r(1:42)' 0 a r(43:84)' a];
   v(ones(30,1),:)

nएएससीआईआई राइट-साइड डिजिट कोड के बराबर है (वे बाईं ओर से प्रवेश करना आसान था क्योंकि वे सभी प्रदर्शन योग्य अक्षर थे)। उसके बाद, एक सीधे दशमलव-से-द्विआधारी रूपांतरण कुछ कष्टप्रद प्रकार के परिवर्तन से चार से संख्यात्मक तक होता है। vअंतिम बाइनरी स्ट्रिंग बनाता है और फिर हम इसे 30 बार और कंसोल को आउटपुट करते हैं।

संक्षिप्तता के लिए दिखाए गए 30 पंक्तियों में से केवल 2 के साथ नमूना आउटपुट:

s = '777777222222';
ans =

 Columns 1 through 30:

   1   0   1   0   1   1   1   0   1   1   0   1   1   1   0   1   1   0   1   1   1   0   1   1   0   1   1   1   0   1
   1   0   1   0   1   1   1   0   1   1   0   1   1   1   0   1   1   0   1   1   1   0   1   1   0   1   1   1   0   1
...

 Columns 31 through 60:

   1   0   1   1   1   0   1   1   0   1   1   1   0   1   1   0   1   0   1   1   1   0   1   1   0   0   1   1   0   1
   1   0   1   1   1   0   1   1   0   1   1   1   0   1   1   0   1   0   1   1   1   0   1   1   0   0   1   1   0   1
...

 Columns 61 through 90:

   1   0   0   1   1   0   1   1   0   0   1   1   0   1   1   0   0   1   1   0   1   1   0   0   1   1   0   1   1   0
   1   0   0   1   1   0   1   1   0   0   1   1   0   1   1   0   0   1   1   0   1   1   0   0   1   1   0   1   1   0
...

 Columns 91 through 94:

   0   1   0   1
   0   1   0   1
...

संपीड़ित उत्पादन:

1010111011011101101110110111011011101101110110101110110011011001101100110110011011001101100101

मैंने मूल रूप से छवि प्रदर्शित करने का इरादा किया था, लेकिन कंसोल को आउटपुट भेजने से मुझे 9 बाइट्स बचाए गए। आप परिणामों का उपयोग करके प्रदर्शित कर सकते हैं imshow, लेकिन यह 1सफेद और 0काले रंग के रूप में प्रदर्शित होता है , इसलिए आपको पहले डेटा को उल्टा करना होगा।

imshow(~v(ones(30,1),:));

Answer 6

कोबरा - 218

do(s='')
    print'P1\n95 30'+('\n'+('101'+(for n in 12get Convert.toString(if((t=139+[2,14,8,50,24,38,36,48,44,0][s[n]to int-48])and n<6,t,~t),2)[-7:]+if(n-5,'','01010')).join('')+'101').toCharArray.join(' ')).repeat(30)

Answer 7

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

n=>`P1 95 30 `+(101+(g=(a,...s)=>(``+1e12+n).slice(...s,-6).split``.map(m=>(1e3+a[m].toString(2)).slice(-7)).join``)(a=[13,25,19,61,35,49,47,59,55,11],-12)+`01010`+g(a.map(i=>~i&127))+101).repeat(30)

Comments

"सबसे छोटा सबमिशन (बाइट्स जीत में)"। आपको अपना कोड बाइट्स में गिनना होगा, इसलिए यदि यूनिकोड का उपयोग किया जाए, तो यह प्रति वर्ण 2 बाइट्स है, मुझे लगता है।

— mbomb007

बाह, हाँ, मुझे लगता है कि मेरा संयुक्त राष्ट्र का यूनिकोड उत्तर छोटा है

— डेंड्रोबियम

Answer 8

पायथन 2, 174 बाइट्स

मुझे पता है कि यह गोल्फ हो सकता है।

स्ट्रिंग sतालिका के बाएँ आधे भाग के साथ प्रश्न में बाइनरी टेबल है। मान पहले से 63 तक एंडेड हैं यदि दाहिने आधे में (पहले 1 को हटा दें), तो 63 को मुद्रण योग्य एएससीआईआई द्वारा स्थानांतरित किया जाता है।

बग: वर्तमान में एक बग को ठीक करने की कोशिश कर रहा है। पहले उदाहरण का आउटपुट बारकोड के एक अंक से बंद है। यदि आप इसका पता लगाते हैं, तो कृपया मुझे बताएं।

I=raw_input()
s="LXR|bpnzvJcekA[MOCGs"
x="".join(format(ord(s[int(I[i])+10*(i>5)])-63|1+63*(i>5),'07b')for i in range(len(I)))
L=len(x)/2
print"101%s01010%s101"%(x[:L],x[L:])

Comments

या, मैंने चुनौती पूरी तरह से गलत कर दी है। मुझे उस मामले में भी बताएं।

— mbomb007