कोड 39 बारकोड एनकोडर

Question

एक फ़ंक्शन या प्रोग्राम लिखें जो एक स्ट्रिंग को कोड 39 प्रारूप बारकोड में एन्कोड करता है, जहां प्रत्येक चरित्र को चार बार द्वारा अलग किए गए पांच बार के रूप में एन्कोड किया गया है। या तो दो बार और अंतराल में से एक चौड़ा है और अन्य संकीर्ण (10 * 4 कोड) हैं, या अंतराल के तीन विस्तृत हैं और सलाखों में से कोई भी (4 कोड) हैं। यह 44 अलग-अलग कोड देता है, जिसमें से एक आरक्षित कोड है जिसका उपयोग एन्कोडेड स्ट्रिंग के प्रारंभ और अंत को दर्शाने के लिए किया जाता है।

चुनौती

इनपुट एक स्ट्रिंग है जिसमें सेट से केवल वर्ण होते हैं

1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ-. +/$%

आउटपुट एक बारकोड स्ट्रिंग के रूप में एन्कोडेड स्ट्रिंग है। संकीर्ण अंतराल और इंटरचैकर गैप एक एकल स्थान है और एक विस्तृत अंतराल तीन रिक्त स्थान है। संकीर्ण बार यूनिकोड वर्ण "पूर्ण ब्लॉक" के लिए UTF-8 बाइट अनुक्रम है, █, यानी 0xE2 0x96 0x88और विस्तृत बार तीन ऐसे बाइट अनुक्रम / वर्ण ( ███) है। कोड की पूरी सूची है:

      Spaces
      0100 0010 0001 1000 1011 1101 1110 0111
Bars
00000                       +    /    $   %
10001   1    A    K    U
01001   2    B    L    V
11000   3    C    M    W
00101   4    D    N    X
10100   5    E    O    Y
01100   6    F    P    Z
00011   7    G    Q    -
10010   8    H    R    .
01010   9    I    S  space          1=wide
00110   0    J    T  start/end      0=narrow

बार और रिक्त स्थान को एक दूसरे से जोड़ा जाता है, एक बार में शुरू होता है, इसलिए उदाहरण के लिए क्यू है

bar   0 0 0  1     1 
code  █ █ █ ███   ███
space  0 0 0    1

सभी वर्णों को एन्कोड करने के बाद, स्ट्रिंग को दोनों सिरों पर सीमांकित किया जाता है █ █ ███ ███ █। इंटरचैकर गैप, एक सिंगल स्पेस, हर अक्षर के बीच में डाला जाता है। आपका समाधान अनुगामी रिक्त स्थान और एक अनुगामी नईलाइन (उस क्रम में) का उत्पादन कर सकता है।

उदाहरण

""     → "█   █ ███ ███ █ █   █ ███ ███ █"

"A"    → "█   █ ███ ███ █ ███ █ █   █ ███ █   █ ███ ███ █"

"C++"  → "█   █ ███ ███ █ ███ ███ █   █ █ █   █ █   █   █ █   █ █   █   █ █   █ ███ ███ █"

"GOLF" → "█   █ ███ ███ █ █ █ █   ███ ███ ███ █ ███ █   █ █ ███ █ █   ███ █ ███ ███   █ █ █   █ ███ ███ █"

मानक इनपुट / आउटपुट प्रारूप की अनुमति है और मानक खामियों को रोक दिया जाता है। यह कोड-गोल्फ है , इसलिए बाइट्स जीत में मापा जाने वाला सबसे छोटा कोड है!

Comments

क्या हम a के बजाय एक मुद्रण योग्य ASCII चरित्र का उपयोग कर सकते हैं (आप किसको अनुमति दे सकते हैं)?

— एग्री आफ द आउटरीक

ब्रेनफैक जैसी भाषा के लिए, "एक उपयोग" के रूप में क्या गिना जाता है?

— l4m2

@ मेरे पास मूल रूप से आउटपुट पर था, कोड में नहीं। #चरित्र का उपयोग करने के लिए दंड देना बहुत उचित नहीं है , उदाहरण के लिए, "#"केवल एक ही कारण नहीं है कि इसे किसी भाषा में इस्तेमाल किया जा सकता है।

— बाहर निकलना

@EriktheOutgolfer मेरा मतलब था कि स्ट्रिंग शाब्दिक और पसंद है, लेकिन l4m2 के बिंदु को देखते हुए इसे अस्वीकार करना सबसे अच्छा हो सकता है। आखिरकार, क्या कोई भाषाएं हैं जो तीन बाइट्स का उत्पादन नहीं कर सकती हैं?

— एंगेज

यदि यह किसी की मदद करता है, तो यहां सभी वर्णों के लिए 9-बिट बाइनरी स्ट्रिंग्स और दशमलव रूपांतरण के साथ एक पास्टबिन है ।

— केविन क्रूज़सेन

Answer 1

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

@ L4m2 के लिए धन्यवाद 4 बाइट्स सहेजे गए

s=>`#${s}#`.replace(/./g,c=>'0202020202'.replace(/./g,(j,k)=>[C='█',C+C+C,' ','   '][(i="%+/$U1AKV2BLW3CMX4DNY5EOZ6FP-7GQ.8HR 9IS#0JT".indexOf(c),[170,257,260,5,272,17,20,320,65,68,80][i>>2]^2<<i%4*2)>>k&1|j]))

इसे ऑनलाइन आज़माएं!

कैसे?

तालिका को इस तरह से पुनर्व्यवस्थित किया जा सकता है कि चरित्र के 9-बिट बाइनरी मास्क को जल्दी से अपनी पंक्ति और स्तंभ से घटाया जाता है:

n = m XOR (2 << k)

साथ में:

  m  | k: 0   2   4   6
-----+------------------      Examples:
 170 |    %   +   /   $
 257 |    U   1   A   K         'G' = 320 XOR (2 << 4) = 320 XOR 32 = 352
 260 |    V   2   B   L
   5 |    W   3   C   M         '+' = 170 XOR (2 << 2) = 170 XOR 8  = 162
 272 |    X   4   D   N
  17 |    Y   5   E   O
  20 |    Z   6   F   P
 320 |    -   7   G   Q
  65 |    .   8   H   R
  68 |   spc  9   I   S
  80 |    #   0   J   T

Comments

s=>`#${s}#`.replace(/./g,c=>'0202020202'.replace(/./g,(j,k)=>[C='#',C+C+C,' ',' '][(i="%+/$U1AKV2BLW3CMX4DNY5EOZ6FP-7GQ.8HR 9IS#0JT".indexOf(c),[,257,260,5,272,17,20,320,65,68,80][i>>2]|(2<<i%4*2^(i<4)*170))>>k&1|j]))(221)

— l4m2

@ l4m2 जो मान्य प्रतीत नहीं होता है। हालाँकि, मैं 221 बाइट्स के लिए एक फिक्स खोजने में कामयाब रहा ।

— एरिक द आउटलिफ़र

@EriktheOutgolfer मुझे लगता है कि मूल रूप से '#' के बजाय पूर्ण ब्लॉक के साथ l4m2 क्या प्रस्तुत किया गया है। या क्या मैं कुछ न कुछ भूल रहा हूं?

— अरनौलद

@Annauld उनका मूल ठीक से जगह नहीं देता है।

— एर्गेल आउटफर

Answer 2

लाल , 452 445 बाइट्स

func[s][q: func[x y z][append/dup x y z]append insert s"*""*"b:
func[n][v: copy[]until[append v n % 2 * 2 + 1
1 > n: n / 2]q v 1 5 - length? v
reverse v]a: q":1234567890:ABCDEFGHIJ:KLMNOPQRST:UVWXYZ-. *"" "44
a/45: #"+"a/56: #"/"a/67: #"$"a/78: #"%"foreach t s[i: index? find a t
k: b pick[0 17 9 24 5 20 12 3 18 10 6]either 0 = j: i % 11[11][j]m:
b pick[8 4 2 16 22 26 28 14]i - 1 / 11 + 1 z: copy""repeat n 5[q z"█"k/(n)
q z" "m/(n)]prin z]]

इसे ऑनलाइन आज़माएं!

मैं इसे और आगे बढ़ाने की कोशिश करूँगा, लेकिन मुझे इस भोले समाधान से बहुत उम्मीद नहीं है।

Answer 3

जावा 10, 455 बाइट्स

s->{String r="",R=r;for(var c:("~"+s+"~").split(""))r+=r.format("%9s",Long.toString(new int[]{148,289,97,352,49,304,112,37,292,100,52,265,73,328,25,280,88,13,268,76,28,259,67,322,19,274,82,7,262,70,22,385,193,448,145,400,208,133,388,196,138,162,168,42}["~1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ-. +/$%".indexOf(c)],2)).replace(' ','0');for(int l=r.length(),i=0,c;i<l;R+=""+(i%9%2<1?c<49?"█":"███":c<49?" ":"   ")+(i%9>7&++i<l?" ":""))c=r.charAt(i);return R;}

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

s->{                     // Method with String as both parameter and return-type
  String r="",           //  Temp-String, staring empty
         R=r;            //  Result-String, starting empty as well
  for(var c:("~"+s+"~")  //  Prepend and append "~" to the input
            .split(""))  //  And loop over each character
    r+=r.format("%9s",Long.toString( 
                         //   Convert the following integer to a 9-bit binary String:
       new int[]{148,289,97,352,49,304,112,37,292,100,52,
                 265,73,328,25,280,88,13,268,76,28,259,67,322,
                 19,274,82,7,262,70,22,385,193,448,145,400,208,
                 133,388,196,138,162,168,42}
                         //    Array containing all decimal values of the binary Strings
       ["~1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ-. +/$%".indexOf(c)]
                         //    with the index based on the current character
   ,2)).replace(' ','0');
                         //   (also part of the integer to 9-bit binary String conversion)
  for(int l=r.length(),i=0,c;i<l;
                         //  Loop `i` over the temp-String
      R+=                //    After every iteration: append the following to the result:
         ""+(i%9%2<1?    //     If `i` modulo-9 modulo-2 is 0:
              c<49?      //      And `c` is '0':
               "█"       //       Append a single block
              :          //      Else:
               "███"     //       Append three blocks
             :c<49?      //     Else-if `c` is '0':
              " "        //      Append a single space
             :           //     Else:
              "   ")     //      Append three spaces
         +(i%9>7         //     If `i` modulo-9 is 8,
           &++i<l?       //     and this is not the very last character
            " "          //      Append a space delimiter
           :             //     Else:
            ""))         //      Append nothing more
    c=r.charAt(i);       //   Set `c` to the current character in `r`
  return R;}             //  Return the result

Answer 4

सी (जीसीसी) , 311 , 303 बाइट्स

(*P)()=printf;i;j;w;m[]={170,257,260,5,272,17,20,320,65,68,80};char*b=" \0\xE2\x96\x88",*t="%+/$U1AKV2BLW3CMX4DNY5EOZ6FP-7GQ.8HR 9IS#0JT",*c;p(x){j=256;w=2;while(j){P(b+w);if(x&1){P(b+w);P(b+w);}x/=2;j>>=1;w=2*!w;}P(" ");}f(char*_){p(82);for(c=_;*c;c++){i=strchr(t,*c)-t;p(m[i>>2]^(2<<(i&3)*2));}p(82);}

इसे ऑनलाइन आज़माएं!

-8 सीलिंगकैट के लिए धन्यवाद

Arnauld के उत्तर से एन्कोडिंग रणनीति का उपयोग करता है। TIO लिंक में -wचेतावनी को हटाने के लिए स्विच और बॉयलरप्लेट शामिल हैं, ये अनावश्यक हैं और इस तरह स्कोर में शामिल नहीं हैं।

अर्नुलड द्वारा बताई गई एन्कोडिंग योजना के अलावा, दूसरी चाल यहां wचर को 2 और 0 ( w=2*!w) के बीच टॉगल करने के लिए बनाए रखना है । यह मुझे पहले और दूसरे तार के बीच चयन करने की अनुमति देता है b। पहला एक स्थान है, दूसरा भरा हुआ आयत है।

Comments

चतुर, आपको इसे पोस्ट करना चाहिए :)

— लैंबडाटा

Answer 5

सी (जीसीसी) , 241 239 227 213 207 बाइट्स

#define P printf(i%2?" ":"█")
i;p(x){for(i=9;i--;x/=2)P,x&1&&P+P;P;}f(char*_){p(82);for(char*t="%+/$U1AKV2BLW3CMX4DNY5EOZ6FP-7GQ.8HR 9IS#0JT";*_;p(L"ªāĄ\5Đ\21\24ŀADP"[i/4]^2<<i%4*2))i=index(t,*_++)-t;p(82);}

इसे ऑनलाइन आज़माएं!

@ लैम्ब्डाबेटा के कार्यान्वयन के आधार पर ।

थोड़ा कम गोल्फ:

#define P printf(i%2?" ":"█")
i;
p(x){
 for(i=9;i--;x/=2)
  P,
  x&1&&
   P+
   P;
 P;
}
f(char*_){
 p(82);
 for(char*t="%+/$U1AKV2BLW3CMX4DNY5EOZ6FP-7GQ.8HR 9IS#0JT";*_;p(L"ªāĄ\5Đ\21\24ŀADP"[i/4]^2<<i%4*2))
  i=index(t,*_++)-t;
 p(82);
}

Answer 6

चारकोल , 90 बाइट्स

⪫ＥＥ⪫**Ｓ⌕⁺⁺⭆…αχ﹪⊕μχα-. *+/$%ι⪫Ｅ⁵⁺⎇μ× ∨⁼›ι³⁹⁼²﹪⁻÷ι∨›ι³⁹χμ⁴¦³ω×█∨›ι³⁹∨§↨℅§.6':+3<-59ι²⊕μ³ω 

इसे ऑनलाइन आज़माएं! नोट: अनुगामी स्थान। लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

⪫ＥＥ⪫**Ｓ...⪫Ｅ⁵⁺...ω 

इनपुट स्ट्रिंग को *s में लपेटें और फिर दो बार उस पर मैप करें, अंत में रिक्तियों के साथ परिणाम में शामिल हों। दूसरे नक्शे के लिए, फिर निहित सीमा पर एक अतिरिक्त नक्शा होता है 0..4, जहां दो सब्सट्रेट को समतल किया जाता है, और फिर उन परिणामों को पूर्वनिर्धारित खाली स्ट्रिंग स्थिरांक के साथ जोड़ा जाता है।

⌕⁺⁺⭆…αχ﹪⊕μχα-. *+/$%ι

पहले आंतरिक मानचित्र के लिए, बढ़े हुए अंकों, अपरकेस वर्णमाला और प्रतीकों को लेकर एक स्ट्रिंग का निर्माण करें -. *+/$%, और मैप किए गए इनपुट चरित्र की स्थिति को देखें। उदाहरण के लिए, C++मैप करेगा [12, 40, 40]।

⎇μ× ∨⁼›ι³⁹⁼²﹪⁻÷ι∨›ι³⁹χμ⁴¦³ω

पहला सबरिंग सलाखों से पहले रिक्त स्थान का प्रतिनिधित्व करता है। पहली बार से पहले कुछ भी नहीं है, लेकिन अन्य बार मैप किए गए इनपुट चरित्र की स्थिति पर निर्भर करते हैं: यदि यह 39 से अधिक है, तो केवल एक जगह में एक ही स्थान है, जबकि यदि यह 40 से कम है, तो केवल एक स्थान में तीन हैं रिक्त स्थान, और स्थिति को भी एक स्तंभ में बदलकर 10. से विभाजित किया जाता है। यदि कॉलम और लूप इंडेक्स 2 (मॉडुलो 4) से भिन्न होता है तो वह विषम स्थान है।

×█∨›ι³⁹∨§↨℅§.6':+3<-59ι²⊕μ³

दूसरा सबरिंग सलाखों का प्रतिनिधित्व करता है। यदि स्थिति 39 से अधिक है, तो हमेशा एक पट्टी होती है अन्यथा स्थिति वर्णों के लिए मैप की गई बिट्स की एक सरणी में देखी जाती है। उदाहरण के लिए, यदि स्थिति 12 वर्ष की है, तो वह वर्ण के लिए गोलाकार रूप से अनुक्रमित होती है ', जो कि 100111बाइनरी में होती है, जो कॉलम 1 और 2 में व्यापक सलाखों को दर्शाती है (अग्रणी 1को अनदेखा किया जाता है, यह बस एक सुसंगत बिट गणना सुनिश्चित करता है।)

Answer 7

पर्ल 5 , 244 बाइट्स

$l="{ ,   ,...,.........}"x9;@h{$",qw($ % + - . /),0..9,'',A..Z}=(<"$l">)[q{..=9...Z.>>...J=9..j.%r1...=).[.>=-..Ux?V.^=8.>.6o+ax_.=(..B=,..Yx6..b=(..#r'p.^...G.<=,..Sx5B.\=(.V.It..z:..-z.=<6.}=~s/./ord$&/gre=~/.{6}/g];s/^|./$h{$&} /g;$\=$h{''}

इसे ऑनलाइन आज़माएं!

कई unprintables और उच्च-बाइट वर्ण शामिल हैं, TIO लिंक एक xxdप्रतिनिधित्व प्रदान करता है। मुझे उम्मीद है कि यह छोटा हो गया होगा, और मैं अभी भी डेटा को अधिक कुशल तरीके से पैक करने में सक्षम हो सकता हूं इसलिए मैं देखूंगा कि मैं कैसे जाता हूं। यह सभी क्रमपरिवर्तन बनाता है " "," ","█","███"और फिर सूची के संकेतों को संबंधित वर्णों में मैप करता है।

Answer 8

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

z=0:z
x!0=[]
x!n=mod n x:x!div n x
e c|Just a<-lookup c.zip"W3YZ56C$EF. 89*HM/ORU1QGNTDJ7%40LSBIP2-+XVKA".((++)<*>(reverse<$>))$take 9.(++z).(2!)<$>scanl(+)7(67!0x117CDBC49F9EEEF11C3A659CACB31236)=zipWith(\l c->c<$[1..2*l+1])(a++[0])(cycle"█ ")>>=id
f s='*':s++"*">>=e

इसे ऑनलाइन आज़माएं!

ऑपरेटर x!nजो n के x- आधार अंकों की गणना करता है, कोड को डिकम्प्रेस करने के लिए दो बार उपयोग किया जाता है। कोड पहले संकुचित होते हैं बाइनरी स्ट्रिंग्स के साथ विस्तृत = 1 और संकीर्ण = 0, रंग के संबंध में नहीं, जैसे R↔10000110↔262। इन नंबरों को क्रमबद्ध किया जाता है और [3,66] रेंज में नंबर प्राप्त करने के लिए अलग-अलग किया जाता है, जो कि बाइनरी डिजिट अल्गोरिद्म के रिवर्स के साथ संपीड़ित होते हैं 0x117CDBC49F9EEEF11C3A659CACB31236। इसमें केवल आधे कोड होते हैं, बाकी इनमें से उलट होते हैं।

Ungolfed:

z=0:z                       -- infinite zeroes for padding
x!0=[]                      -- digits of n in base x, recursion base case
x!n=mod n x:x!div n x       -- digits of n in base x
e c | Just a                -- read upwards from (*)
  <-lookup c                -- lookup code, given letter
  . zip"W3YZ56C$EF. 89*HM/ORU1QGNTDJ7%40LSBIP2-+XVKA" 
                            -- combine codes with correct letters
  . ((++)<*>(reverse<$>))   -- concatenate list and list with reverse codes
  $ take 9                  -- take nine
  . (++z)                   -- pad with infinite zeroes on right
  . (2!)                    -- convert to binary digits – [[1,1,1],[1,0,1,1]…]
  <$> scanl (+) 7           -- cumulative sum starting from 7 – [7,13,19,22,25…]
        (67!0x117CDBC49F9EEEF11C3A659CACB31236)       
                            -- (*) digits in base 67 – [6,6,3,3,3,9,5,7…]
  = zipWith
      (\l c->c<$[1..2*l+1]) -- combine width and color, length is 2*l+1
      (a++[0])              -- list of widths as 0/1, 0 added for interchar gap
      (cycle"█ ")           -- infinite list of bar colors, leftovers are unused
  >>=id                     -- concatenate
f s='*':s++"*">>=e          -- surround string with delimiters, map e and concat