Bzip2 के रन-लंबाई एन्कोडिंग को लागू करें

Question

पृष्ठभूमि

BWT (जैसा कि बर्रो, व्हीलर और बैक में देखा जाता है) और MTF (जैसा कि मूवेबल ASCII फ्रंट में मूव में देखा जाता है) को लागू करने के बाद , bzip2 कंप्रेसर रन-लेंथ एन्कोडिंग के बजाय एक अनोखा रूप लागू करता है।

परिभाषा

इस चुनौती के उद्देश्य के लिए, हम बीआरएलई को इस प्रकार परिभाषित करते हैं:

एक इनपुट स्ट्रिंग s को देखते हुए जिसमें केवल 0x20 और 0x7A के बीच कोड बिंदुओं के साथ ASCII वर्ण होते हैं, निम्न कार्य करें:

1. वर्ण की एक ही घटना द्वारा समान वर्णों के प्रत्येक रन को बदलें और पहले के बाद पुनरावृत्ति की संख्या को स्टोर करें।

2. चरित्र की पहली घटना के बाद पुनरावृत्ति की संख्या को सांकेतिक शब्दों में बदलना , विशेषण आधार -2 संख्या और प्रतीकों {का उपयोग करना }।

   एक गैर-नकारात्मक पूर्णांक n को स्ट्रिंग b _{k के} रूप में एन्कोड किया गया है ... b ₀ ऐसा n = 2 ^k i (b _k ) + ... + 2 ⁰ i (b ₀ ) , जहाँ i ( {) = 1 और i ( }) = 2 ।

   ध्यान दें कि यह प्रतिनिधित्व हमेशा अनूठा होता है। उदाहरण के लिए, संख्या 0 एक रिक्त स्ट्रिंग के रूप में एन्कोडेड है।

3. घुंघराले ब्रैकेट की स्ट्रिंग डालें जो संबंधित चरित्र की एकल घटना के बाद दोहराव की संख्या को एन्कोड करता है।

चरण-दर-चरण उदाहरण

Input:  "abbcccddddeeeeeffffffggggggghhhhhhhh"
Step 1: "abcdefgh" with repetitions 0, 1, 2, 3, 4, 5, 6, 7
Step 2: "" "{" "}" "{{" "{}" "}{" "}}" "{{{"
Step 3: "ab{c}d{{e{}f}{g}}h{{{"

कार्य

एक अचूक कार्यक्रम या फ़ंक्शन को लागू करें जो STDIN से एक स्ट्रिंग को पढ़ता है या कमांड-लाइन या फ़ंक्शन तर्क और प्रिंट या BRLE या इनपुट स्ट्रिंग के इसके व्युत्क्रम के रूप में रिटर्न करता है।

यदि इनपुट में कोई घुंघराले कोष्ठक नहीं हैं, तो BRLE लागू करें। यदि इनपुट में घुंघराले कोष्ठक हैं, तो इसका व्युत्क्रम लागू करें।

उदाहरण

INPUT:  CODEGOLF
OUTPUT: CODEGOLF

INPUT:  PROGRAMMING
OUTPUT: PROGRAM{ING

INPUT:  PUZ{LES
OUTPUT: PUZZLES

INPUT:  444488888888GGGGGGGGGGGGGGGGWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
OUTPUT: 4{{8{{{G{{{{W{{{{{

INPUT:  y}}}{{
OUTPUT: yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy

अतिरिक्त नियम

• आप BRLE या इसके स्ट्रिंग के व्युत्क्रम की गणना करने वाले किसी भी बिल्ट-इन का उपयोग नहीं कर सकते ।

• आप बिल्ट-इन का उपयोग कर सकते हैं:

  • एक स्ट्रिंग के RLE या RLD की गणना करें, जब तक कि दोहराव की संख्या जीवनी आधार -2 में संग्रहीत नहीं होती है।

  • किसी भी प्रकार का आधार रूपांतरण करें।

• यदि आप आउटपुट के लिए STDOUT का चयन करते हैं तो आपका कोड एक अनुगामी न्यूलाइन प्रिंट कर सकता है।

• आपके कोड को 0x20 से 0x7A, प्लस कर्ली कोष्ठक (0x7B और 0x7D) की सीमा में 1000 या उससे कम ASCII वर्णों के किसी भी इनपुट के लिए काम करना होगा।

• यदि इनपुट में घुंघराले कोष्ठक हैं, तो आप मान सकते हैं कि यह BRLE को स्ट्रिंग पर लागू करने का एक मान्य परिणाम है।

• मानक कोड गोल्फ नियम लागू होते हैं। बाइट्स में सबसे कम सबमिशन जीतता है।

Comments

बिल्डरों को अनुमति क्यों नहीं है?

— MilkyWay90

Answer 1

सीजेएम, 50 48 बाइट्स

l_{}`:T&1${_T#)_(@a?)+}%{(\2b)*}%@e`{(2b1>Tf=}%?

2 बाइट बचाने के लिए डेनिस के लिए धन्यवाद।

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

व्याख्या

l_              e# Read and duplicate input.
{}`:T           e# T = "{}"
&               e# If the input has '{ or '}:
    1$          e# Input.
    {           e# For each character:
        _T#)    e# If it is '{ or '}:
            _(  e# Return 0 for '{ or 1 for '}.
            @a  e# Otherwise, convert the character itself to an array (string).
        ?
        )+      e# If it is a number, increment and append to the previous array.
                e# If it is a string with at least 1 character, do nothing.
    }%
    {(\         e# For each character and bijective base 2 number:
        2b)*    e# Repeat the character 1 + that many times.
    }%
                e# Else:
    @           e# Input.
    e`          e# Run-length encoding.
    {(          e# For each character and length:
        2b1>    e# Convert the length to base 2 and remove the first bit.
        Tf=     e# Map 0 to '{ and 1 to '}.
    }%
?               e# End if.

Answer 2

पायथ, 48 50 बाइट्स

J`Hs?m*hdi+1xLJtd2tczf-@zTJUz@Jzsm+ed@LJtjhd2rz8

2 बाइट्स @Maltysen को धन्यवाद।

प्रदर्शन। दोहन ​​परीक्षण।

स्पष्टीकरण:

J`Hs?m*hdi+1xLJtd2tczf-@zTJUz@Jzsm+ed@LJtjhd2rz8
                                                    Implicit: z = input()
                                                    H is empty dict.
J`H                                                 J = repr(H) = "{}"
   s                                                Print the concatenation of
    ?                        @Jz                    If z and J share any chars:
                     f     Uz                       Filter range(len(z))
                      -@zTJ                         On the absence of z[T] in J.
                   cz                               Chop z at these indices.
                                                    just before each non '{}'.
                  t                                 Remove empty initial piece.
     m*hd                                           Map to d[0] *
         i       2                                  the base 2 number                             
            xLJtd                                   index in J mapped over d[:-1]
          +1                                        with a 1 prepended.
                                             rz8    Otherwise, run len. encode z
                                 m                  map over (len, char)
                                         jhd2       Convert len to binary.
                                        t           Remove leading 1  
                                     @LJ            Map to element of J.
                                  +ed               Prepend char.
                                s                   Concatenate. 

Comments

इसके बजाय "{}"आप `HCJam के साथ बंधे उपयोग कर सकते हैं :)

— Maltysen

@Jakube मिक्सअप के लिए क्षमा करें।

— ईसैक

Answer 3

ओकेएमएल, 252

t वह कार्य है जो परिवर्तन करता है।

#load"str.cma"open Str
let rec(!)=group_beginning and
g=function|1->""|x->(g(x/2)^[|"{";"}"|].(x mod 2))and($)i s=if g i=s then i else(i+1)$s and
t s=global_substitute(regexp"\(.\)\1*\([{}]*\)")(fun s->String.make(1$matched_group 2 s)s.[!1]^g(!2- !1))s

पहले मैं सोच रहा था कि मुझे घुंघराले ब्रेस की उपस्थिति की जांच करनी है, लेकिन यह अनावश्यक निकला। डिकोडिंग का स्पष्ट रूप से उन स्ट्रिंग्स पर कोई प्रभाव नहीं पड़ता है जो पहले से ही डिकोड किए गए हैं, और एन्कोडिंग भाग उन लोगों के लिए समान रूप से हानिरहित साबित हुआ जो पहले से ही एन्कोडेड थे।

Comments

the encoding part proved equally harmlessक्या यह? एन्कोडिंग 4{{8{{{G{{{{W{{{{{आपको नहीं मिलता है 4{{8{}G{{{W{{}?

— edc65

@ edc65 नहीं, मुझे उदाहरणों में निर्दिष्ट उत्तर मिलता है। आप इसे कैसे परख रहे हैं?

— feersum

"4 {{8 {{{G {{{W {{{{" इनपुट के रूप में उदाहरण में से एक नहीं है। क्या आपने इसकी कोशिश की?

— edc65

@ edc65 यह एक उदाहरण का विलोम है और मैंने दोनों तरीकों से उनका परीक्षण किया। हां, मैंने कोशिश की, पोस्ट करने से पहले और आपकी टिप्पणी के बाद दोनों।

— feersum

ठीक अच्छा। मैंने उद्धृत वाक्य को "सीधा" एन्कोडिंग के रूप में बताया (मेरा के रूप में) दिए गए परीक्षण मामले के साथ बिल्कुल भी हानिरहित नहीं होगा। स्पष्ट रूप से आपका एन्कोडिंग भाग अधिक चतुर है।

— edc65

Answer 4

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

f=s=>
(t=s[R='replace'](/[^{}][{}]+/g,n=>n[0].repeat('0b'+n[R](/./g,c=>c!='{'|0))))==s
?s[R](/(.)\1*/g,(r,c)=>c+r.length.toString(2).slice(1)[R](/./g,c=>'{}'[c])):t

// TEST
out=x=>O.innerHTML += x + '\n';

test=s=>O.innerHTML = s+' -> '+f(s) +'\n\n' + O.innerHTML;

[['CODEGOLF','CODEGOLF']
,['PROGRAMMING','PROGRAM{ING']
,['PUZ{LES','PUZZLES']
,['444488888888GGGGGGGGGGGGGGGGWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW','4{{8{{{G{{{{W{{{{{']
,['y}}}{{','yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy']]
.forEach(v=>{
  w=f(v[0])  
  out('Test ' + (w==v[1]?'OK':'Fail')+'\nInput:    '+v[0]+'\nExpected: '+v[1]+'\nResult:   '+w)
})  

Your test: <input id=I style='width:300px'><button onclick='test(I.value)'>-></button>
<pre id=O></pre>

कुछ स्पष्टीकरण

0 और 1 का उपयोग करके BB2 के लिए संख्या n :(n+1).toString(2).slice(1)

BB2 से संख्या में स्ट्रिंग: to_number ("0b1" + string) - अर्थात, बाईं ओर 1 बाइनरी अंक जोड़ें और बाइनरी से कन्वर्ट करें (और 1 से घटाएं, इस विशिष्ट उदाहरण में आवश्यक नहीं)।

किसी भी चरित्र को खोजने के लिए नियमित अभिव्यक्ति {या उसके बाद }:/[^{}][{}]+/g

दोहराए गए पात्रों को खोजने के लिए नियमित अभिव्यक्ति: /(.)\1*/g

प्रतिस्थापित करने में उस regexp का उपयोग करते हुए, पहला पैराम "दोहराया" वर्ण है (अंततः केवल 1 बार दोहराएं), दूसरा परम कुल दोहराया स्ट्रिंग है, जिसकी लंबाई वह संख्या है जिसे मुझे BB2 में पहले से ही संलग्न द्वारा एन्कोड करने की आवश्यकता है 1

... फिर सब एक साथ ...