मार्क माय मेल चैलेंज में आपकी मदद के लिए धन्यवाद , PPCG-Post ने अपने सभी पार्सल को उत्पन्न बारकोड के साथ सफलतापूर्वक बंद कर दिया है!

अब, उन्हें डिकोड करने का समय आ गया है।

इस चुनौती में आपके प्रोग्राम ने मार्क माय मेल चैलेंज से उत्पन्न बारकोड दिया , इसे डिकोड किया और एन्कोडेड पूर्णांक वापस लौटाया।

लेकिन बाहर देखो! बारकोड उल्टा हो सकता है ...

4-राज्य बारकोड

मामले में आप एन्कोडिंग चुनौती से चूक गए, आपको यह जानना होगा कि हम किस तरह के बारकोड के बारे में बात कर रहे हैं। 4-राज्य बारकोड चार संभावित राज्यों के साथ बार की एक पंक्ति है, प्रत्येक आधार -4 पूर्णांक का प्रतिनिधित्व करता है:

            |       |
Bar:    |   |   |   |
                |   |

Digit:  0   1   2   3

ASCII में रेंडर किया गया, बारकोड पाठ के तीन पंक्तियों को उठाएगा, |एक बार के भाग का प्रतिनिधित्व करने के लिए पाइप ( ) वर्ण और एक खाली खंड का प्रतिनिधित्व करने के लिए एक स्थान ( ) का उपयोग करेगा। प्रत्येक बार के बीच एक एकल स्थान होगा। एक उदाहरण बारकोड इस तरह दिख सकता है:

| | | | | | | | | |
| | | | | | | | | | | | | | | | |
    | | | | | | | |

बारकोड को पूर्णांक में परिवर्तित करने के लिए जो इसे एनकोड करता है, प्रत्येक बार को इसके संबंधित बेस -4 अंक पर मैप करें, इन्हें संक्षिप्त करें, और इसे दशमलव में बदलें।

जैसा कि प्रत्येक बारकोड उल्टा होने पर एक अलग बारकोड का भी प्रतिनिधित्व करता है, हम एक स्टार्ट / स्टॉप सीक्वेंस को लागू करते हैं ताकि ऑरिजन की गणना की जा सके। इस चुनौती के उद्देश्य के लिए, हम ऑस्ट्रेलिया पोस्ट द्वारा निर्दिष्ट स्टार्ट / स्टॉप अनुक्रम का उपयोग करेंगे: प्रत्येक बारकोड एक 1 0अनुक्रम के साथ शुरू और समाप्त होता है ।

चुनौती

आपका कार्य, ASCII 4-स्टेट बारकोड दिया गया है, इसे पार्स करें और पूर्णांक को एनकोड करें - अनिवार्य रूप से मार्क माय मेल के पीछे ।

लेकिन चीजों को मसाला देने के लिए, एक पकड़ है - बारकोड को उल्टा दिया जा सकता है। वास्तविक दुनिया की तरह, यह बारकोड रीडर (आपका प्रोग्राम) पर छोड़ दिया जाएगा ताकि स्टार्ट / स्टॉप सीक्वेंस का उपयोग करके सही ओरिएंटेशन निर्धारित किया जा सके ।

उदाहरण:

निम्नलिखित बारकोड को देखते हुए:

    | | | |
| | | | | | | | | | |
  | | | | |

हम स्पष्ट रूप से देख सकते हैं कि अंकों के पहले और अंतिम जोड़े हैं 0, 2और नहीं 1, 0। इसका मतलब है कि बारकोड उल्टा है - इसलिए हमें सही ओरिएंटेशन प्राप्त करने के लिए इसे 180 डिग्री (प्रत्येक बार फ्लिप न करें) से घुमाना चाहिए :

| | | | |  
| | | | | | | | | | |
    | | | |

अब, हम डिकोडिंग शुरू कर सकते हैं। हम प्रत्येक बार को उसके संबंधित आधार -4 अंक पर मैप करते हैं, जो स्टार्ट / स्टॉप दृश्यों को अनदेखा करते हैं क्योंकि वे डेटा को एनकोड नहीं करते हैं।

| | | | |  
| | | | | | | | | | |
    | | | |    

- - 2 1 0 3 0 2 3 - -

हम इसे आधार -4 पूर्णांक तक पहुंचाते हैं 2103023, फिर 9419अंतिम परिणाम के लिए इसे अपने दशमलव प्रतिनिधित्व में परिवर्तित करते हैं ।

नियम

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

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

| | | | | | | | | | |
  | | |

= 4096 (फ़्लिप)

      | | | | | | | |
| | | | | | | | | | | | | | | |
  | | | | | | | | | |

= 7313145 (फ़्लिप)

    | | | |
| | | | | | | | | | |
  | | | | |

= 9419 (फ़्लिप)

| | | | | |   
| | | | | | | | |
    | | | |

= 990 (फ़्लिप नहीं)

| | | | |   
| | | | | | | | | | |
    | | |

= 12345 (फ़्लिप नहीं)

— FlipTack
स्रोत

-1 दो पदों पर शीर्षक समान प्रारूप नहीं हैं। ("पी द पी" बनाम "एम

— माय

1

"लाइनों की सूची" के किसी भी होगा [String], [{#Char}], [{Char}], [[Char]]?, यह देखते हुए कि Stringबराबर करने के लिए है{#Char}

— Οurous

3

@ ओरोस क्या है? मुझे दृढ़ता से संदेह है कि उत्तर "हाँ" है, क्योंकि डेटा प्रकार भाषाओं के बीच बहुत भिन्न होते हैं, इसलिए कोडिंग चुनौतियां आम तौर पर स्वीकार करती हैं "जो भी आपकी भाषा में समतुल्य है", लेकिन मुझे नहीं पता कि आप किस प्रतिनिधित्व का प्रतिनिधित्व करने की कोशिश कर रहे हैं।

— IMSoP

1

आगे क्या होगा? ईमेल फेंकना है? टेलीग्राम को प्रसारित करें? पोस्ट को प्रोसेस करें?

— सांचीस

1

@ सामान्य हाँ, डेटा प्रकार लचीला है, जैसा कि IMSoP वर्णित है।

— FlipTack

6

जेली , 18 बाइट्स

>⁶m2Zm2UFUi¡1ṫ4Ḅ:⁴

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

— लीक नन
स्रोत

5

भूसी , 16 बाइट्स

ḋṁẊ=hhttĊ2T§▼↔m↔

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

इनपुट लाइनों की एक सूची है (TIO लिंक स्पष्टता के लिए एक बहुस्तरीय स्ट्रिंग का उपयोग करता है)। लाइनों की लंबाई समान होनी चाहिए, और अतिरिक्त अनुगामी स्थान नहीं होना चाहिए।

व्याख्या

ḋṁẊ=hhttĊ2T§▼↔m↔  Input is a list of strings x.
           §▼     Lexicographic minimum of
             ↔    x reversed and
              m↔  x with each line reversed.
          T       Transpose. Now we have a list of columns.
        Ċ2        Get every second column, removing the blank ones.
    hhtt          Remove first 2 and last 2 (the orientation markers).
 ṁ                Map and concatenate
  Ẋ=              equality of adjacent pairs.
                  This turns a column like "|| " into [1,0], and these pairs are concatenated.
ḋ                 Convert from binary to integer.

— Zgarb
स्रोत

4

SOGL V0.12 , 40 32 बाइट्स

K@=«I⁷G@Κ¹;⌡I2n{j_{@≠}«+}¹jkjk4│

यह कोशिश करो!

— dzaima
स्रोत

3

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

lambda x:int(''.join([`2*(c>'#')+(a>'#')`for a,b,c in zip(*x[::1-2*(x[-1]>'#')].split('\n'))][4:-4:2]),4)

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

— छड़ी
स्रोत

2

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

lambda a:int(`[2*(r==q)+(p==q)for p,q,r in zip(*a[::(a>'|')*2-1].split('\n'))[4:-4:2]]`[1::3],4)

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

— लिन
स्रोत

2

रेटिना , 71 बाइट्स

(.).
$1
sO$^`^\|.*|.

^..|..¶.*¶..|..$
¶
\|
 |
+`\| 
 ||||
.*¶$
$&$&
\|

इसे ऑनलाइन आज़माएं! लिंक में छोटे परीक्षण मामले शामिल हैं। मध्य रेखा की लंबाई के लिए अंतरिक्ष-पैडेड होने के लिए पहली और अंतिम लाइनों की आवश्यकता होती है। स्पष्टीकरण:

(.).
$1

अनावश्यक स्थानों को हटा दें।

sO$^`^\|.*|.

कोड में वर्णों को उल्टा करें, लेकिन यदि बार कोड a से शुरू होता है |, तो पूरे कोड का चयन करें, अन्यथा इसे वर्णों में विभाजित करें। फिर, उन्हें उल्टा करें। अगर यह एक साथ शुरू होता है यह कोड flips 0।

^..|..¶.*¶..|..$
¶

प्रारंभ / रोक अनुक्रम और मध्य पंक्ति (जो हमारे लिए किसी काम का नहीं है) को हटा दें।

\|
 |
+`\| 
 ||||

रिक्त स्थान को परिवर्तित करें और |आधार 4 से यूरी तक।

.*¶$
$&$&

अंतिम पंक्ति को डबल करें।

\|

दशमलव में परिवर्तित करें।

— नील
स्रोत

2

जावा (ओपनजेडके 8) , 181 160 बाइट्स

एक जावा समाधान के लिए भी जर्जर नहीं, मुझे यकीन है कि ऐसे अनुकूलन हैं जो मैं कर सकता हूं, लेकिन मैं पहले से ही बहुत लंबे समय से इसे घूर रहा हूं।

सबस्ट्रिंग का उपयोग करने के बजाय लूप को छोटा करके कुछ बाइट्स को काटें।

golfed

c->{String r="";Integer i,j,l=c[0].length;for(i=4;i<l-4;i+=2){j=c[0][0]>32?i:l-1-i;r+=c[0][j]%8/4*(j==i?1:2)+c[2][j]%8/4*(j==i?2:1)+"";}return l.parseInt(r,4);}

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

Ungolfed

String r = "";
Integer i, j, l = c[0].length;
for(i=4; i<l-4; i+=2){
    j = c[0][0]>32 ? i : l-1-i;
    r += c[0][j]%8/4 * (j==i?1:2) + c[2][j]%8/4 * (j==i?2:1) + "";
}
return l.parseInt(r, 4);

— ल्यूक स्टीवंस
स्रोत

बस अपने कोड की कोशिश की, लेकिन उदाहरण के उलट बारकोड के साथ "| | | |" "| | | | | | | | | | | |" और मुझे 1024 दे दो, ठीक है मैं यह प्रारूप नहीं कर सकता, लेकिन उदाहरण पर एक लेकिन, आपके पास जो छूट है उसे आज़माएं, लेकिन इसे उलट दिए बिना, शायद मैंने एक बुरा इनपुट किया :)

— जावा गोंजर

@JavaGonzalezArribas मैंने पहला उदाहरण (गैर फ़्लिप) की कोशिश की और यह ठीक काम करता है। क्या आप इनपुट की पहली पंक्ति में बहुत कम स्थान रख सकते हैं?

— ल्यूक स्टीवंस

शायद यही समस्या है, महान जवाब :)

— जावा गोंजर

सुझाएँ l+~iबजायl-1-i

— ceilingcat

2

जावा 8 , 208 166 157 151 बाइट्स

इसकी कोशिश करना, शायद बेहतर हो सकता है, अनावश्यक चेक के कारण 42 को कम कर दिया, -9 हटाने वाले चर, -6 ल्यूक स्टीवंस के लिए धन्यवाद

इनपुट एक है char[][3]

(a)->{int i=2,c,s=0;c=(a[0][0]>32)?1:-1;for(;i<a.length-2;i++){s+=((a[i][1-c]>32?1:0)+(a[i][1+c]>32?2:0))*Math.pow(4,c==1?a.length-i-3:i-2);}return s;}

ungolfed:

int b(char[][] a) {
    int i=2,c,s=0;                      //i for looping, c to check if it's reversed, s is the sum, n the number
    c=(a[0][0]>32)?1:-1; //Check if must be reversed

    for(;i<a.length-2;i++){         //Looping elements

            //(Checking value for 1 + Checking value for 2) * Power, if reversed increasing, else decreasing
        s+=((a[i][1-c]>32?1:0)+(a[i][1+c]>32?2:0))*Math.pow(4,c==1?a.length-i-3:i-2);   
    }
    return s;
}

— जावा गोंजर
स्रोत

1

यदि आप स्ट्रिंग्स के बजाय वर्णों की एक सरणी का उपयोग करते हैं, तो आप जांच कर सकते हैं | का उपयोग करके> 32 के बजाय == "|" जो प्रत्येक उपयोग के लिए 2 बाइट्स बचाता है (कुल मिलाकर 6)। जब आप लैम्बडा को एक और दो बाइट्स के लिए घोषित करते हैं, तो आप कोष्ठक भी निकाल सकते हैं।

— ल्यूक स्टीवंस

2

क्लीन , 191 ... 161 144 बाइट्स

import StdEnv
?' '=0;?_=1
r=reverse
$a b|hd a<'|'= $(r b)(r a)=[?(b!!n)*2+ ?(a!!n)\\n<-[4,6..length b-4]]
@[a,_,b]=sum[d*4^p\\d<- $a b&p<-[0..]]

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

— Οurous
स्रोत

1

पिप , 46 43 42 बाइट्स

IsQ@@gg:RV*RVgY^gR'|1(J@UW2*y@2+@y)TM2FB:4

बारकोड की पंक्तियों को तीन कमांड-लाइन तर्कों के रूप में लेता है। पहली और तीसरी पंक्ति को दूसरी पंक्ति की लंबाई के साथ रिक्त स्थान के साथ गद्देदार करना चाहिए। इसे ऑनलाइन आज़माएं!

व्याख्या

पहले कुछ तैयारी:

IsQ@@gg:RV*RVg Y^gR'|1

                        g is cmdline args; s is space (implicit)
IsQ                     If space equals
   @@g                  the first character of the first line, then:
           RVg           Reverse the order of the rows in g
        RV*              then reverse the characters in each row
      g:                 and assign the result back to g
                 gR'|1  In g, replace pipe character with 1
                ^       Split each row into a list of characters
               Y        Yank the result into y

अब निरीक्षण करें कि यदि हम मध्य पंक्ति को अनदेखा करते हैं और |1 और 0 के रूप में मानते हैं , तो प्रत्येक बार सिर्फ 2-बिट बाइनरी नंबर है:

(J@UW2*y@2+@y)TM2FB:4

       y@2             Third row
     2*                Multiply by 2, turning 1 into 2 and space into 0
           @y          First row
          +            Add
   UW                  Unweave: creates a list of two lists, the first containing all
                       even-indexed elements (in our case, the actual data), the second
                       containing all odd-indexed elements (the space separators)
  @                    First item of that list
 J                     Join the list of digits into a string
(            )TM2      Trim 2 characters from the beginning and end
                 FB:4  Convert from base 4 (: makes the precedence lower than TM)
                       Autoprint

— DLosc
स्रोत

1

भूसी , 39 38 बाइट्स

B4ththmȯ%4+3%5f≠192Ḟz+zṀ·*cN?↔m↔(='|←←

इनपुट को स्ट्रिंग्स की सूची के रूप में लेता है: इसे ऑनलाइन आज़माएं या परीक्षण-सूट आज़माएं!

व्याख्या

B4ththm(%4+3%5)f≠192Ḟz+zṀ·*cN?↔m↔(='|←←)
                             ?   (='|←←)  -- if the very first character == '|'
                              ↔           --   reverse the lines
                                          -- else
                               m↔         --   reverse each line
                       zṀ·*cN             -- zip the lines with [1,2,3..] under..
                        Ṁ·*c              --   convert each character to its codepoint and multiply by one of [1,2,3]
                    Ḟz+                   -- reduce the lines under zipWith(+) (this sums the columns)

               f≠192                      -- only keep elements ≠ 192 (gets rid of the separating lines)

-- for the example from the challenge we would now have:
--   [652,376,468,652,376,744,376,468,744,652,376]

      m(      )                           -- map the following function
        %4+3%5                            --   λx . ((x % 5) + 3) % 4
-- this gives us: [1,0,2,1,0,3,0,2,3,1,0]
    th                                    -- remove first & last element
  th                                      -- remove first & last element
B4                                        -- interpret as base4 number

— ბიმო
स्रोत

1

पर्ल 5 , 152 + 2 ( `-F`) बाइट्स

push@a,[@F]}{for$i(0..$#{$a[1]}){$_.=($a[0][$i]eq'|')+2*($a[2][$i]eq'|')}$_=reverse y/12/21/r if/^0/;s/^0*1000|10*$//g;s/.\K0//g;$\=$_+$\*4for/./g;say$\

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

— Xcali
स्रोत

0

ऑक्टेव , 80 75 68 बाइट्स

@(b)bi2de({rot90(t=~~(b-32)([3,1],[1:2:end]),2),t}{2-t(2)}(5:end-4))

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

मजे की बात है, bi2deहै, है ना बजाय बाईं तरफ डिफ़ॉल्ट MSB है कुछ सिर दर्द के लिए अग्रणी है, जबकि मैं इस बनाया ... मुझे लगता है कि मैं इसे का अनुक्रमण से पहले सरणी flipping के इष्टतम तरीका होना चाहिए, लेकिन देखते हैं अत्यंत यह करने के लिए कई तरह से ( या तो पहले अनुक्रमण में, या के साथ flipud, fliplr, rot90, '(पक्षांतरित), अंतिम अनुक्रमण ...)। रिक्त स्थान और |एस के साथ एक आयताकार सरणी लेता है (इसलिए, अनुगामी रिक्त स्थान आवश्यक है)

@(b)                    % Define anonymous function taking input b

t=                      % Inline-define t,
~~(b-32)                % which is the input, converted to 1's and 0's,
([3 1],[1:2:end])       % but only keep the relevant rows (1 and 3 flipped vertically) and columns (only odd) 

{rot90(t,2),t}          % Flip 180 degrees
{2-t(2)                 % depending on whether the second element of t is 1 or 0.}

(5:end-4)               % Flatten array, discarding control bits
bi2de( ... )            % and convert from binary to decimal,

— Sanchises
स्रोत

0

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

मैं एक अनुभवी गोल्फर नहीं हूँ - मुझे यकीन है कि इसमें सुधार किया जा सकता है, लेकिन मुझे यह चुनौती पसंद थी! मैंने हमेशा उन निशानों के बारे में सोचा है।

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

f=t=>((o=[[...t[0]],[...t[2]]])[0][0]=='|'?o:(z=a=>a.reverse())(o.map(z)))
.map((a,r)=>a.filter((_,i)=>~i%2).map(e=>(1+r)*(e=='|')).slice(2,-2))
.reduce((a,b)=>a+parseInt(b.join``,4),0)

प्रयोग

t=['                     ','| | | | | | | | | | |','  |             |   |']
console.log(f(t)) // 4096

स्पष्टीकरण के साथ अनप्लग्ड संस्करण

// take list of strings, t, as input:
f = t => ( 

  // create output variable o, discard middle row, turn other rows into lists:
  ( o = [ [...t[0]], [...t[2]] ] )

  // if top-left position isn't a pipe, rotate 180 degrees.
  // Alias [].reverse to save 3 bytes :D
  [0][0] == '|' ? o : ( z = a=> a.reverse() )( o.map(z) )

).map( (a,r) => 

  // remove even-numbered positions (non-encoding spaces):
  a.filter( (_,i) => ~i%2 )

  // convert non-pipes into zeros, and pipes into 1 or 2;
  // top row becomes the base4 1-component, bottom row is 2:
  .map( e => (1+r) * (e=='|') ).slice(2,-2)

// convert rows to base4 component strings, then decimal, then sum them:
).reduce( (a,b) => a + parseInt(b.join``,4),0)

— क्रिस एम
स्रोत

पार्सल को पार्स करें

4-राज्य बारकोड

चुनौती

उदाहरण:

नियम

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

जेली , 18 बाइट्स

भूसी , 16 बाइट्स

व्याख्या

SOGL V0.12 , 40 32 बाइट्स

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

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

रेटिना , 71 बाइट्स

जावा (ओपनजेडके 8) , 181 160 बाइट्स

जावा 8 , 208 166 157 151 बाइट्स

क्लीन , 191 ... 161 144 बाइट्स

पिप , 46 43 42 बाइट्स

व्याख्या

भूसी , 39 38 बाइट्स

व्याख्या

पर्ल 5 , 152 + 2 ( -F) बाइट्स

ऑक्टेव , 80 75 68 बाइट्स

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

प्रयोग

स्पष्टीकरण के साथ अनप्लग्ड संस्करण

पर्ल 5 , 152 + 2 ( `-F`) बाइट्स