OOP: ओरिएंटेड प्रोग्रामिंग को ओवरलैप करना

Question

कम ज्ञात प्रोग्रामिंग प्रतिमानों में से एक, जो कोड गोल्फिंग के लिए उपयुक्त लगता है, ओवरलैपिंग ओरिएंटेड प्रोग्रामिंग (ओओपी) * है। आंशिक रूप से समान कोड लिखते समय, कई बाइट्स को समान भागों को ओवरलैप करके और किसी तरह से याद करने से बचाया जा सकता है जहां दो मूल लाइनें शुरू होती हैं। आपका काम दो अतिव्यापी कार्यक्रमों या कार्यों को लिखना है compressऔर decompressनिम्नलिखित विनिर्देश के साथ:

^{* उत्पादन कोड में उपयोग न करें, शायद।}

compress

compressकिसी भी सुविधाजनक प्रारूप में दो तार लेता है और उन्हें यथासंभव ओवरलैप करता है। यह sन्यूनतम लंबाई के साथ एक स्ट्रिंग है जैसे कि दोनों इनपुट तार के सबस्ट्रिंग हैं s। इसके अतिरिक्त, कुछ आउटपुट जो दोनों स्ट्रिंग के प्रारंभ और अंत सूचक की पहचान करते हैं, उन्हें लौटा दिया जाता है।

उदाहरण: (सटीक IO- प्रारूप आपके ऊपर है)

compress("abcd", "deab") -> "deabcd" ((2,5),(0,3))
compress("abcd", "bc")   -> "abcd" ((0,3),(1,2))
compress("abc", "def")   -> "abcdef" ((0,2),(3,5)) or "defabc" ((3,5),(0,2))

decompress

decompressके व्युत्क्रम फ़ंक्शन की गणना करता है compress, जिसे एक स्ट्रिंग और दो स्टार्ट एंड एंड इंडिस दिए जाते हैं (उस प्रारूप में जिसमें वे आपके द्वारा लौटाए जाते हैं compress), दो मूल स्ट्रिंग्स को वापस करते हैं। आपको केवल मान्य इनपुट को संभालने की आवश्यकता है। निम्नलिखित समानता सभी स्ट्रिंग्स के लिए धारण करना चाहिए s1, s2:

(s1, s2) == decompress (compress (s1, s2))

उदाहरण: ( उदाहरणों के विपरीत compress)

decompress "deabcd" ((2,5),(0,3)) -> "abcd" "deab" 
decompress "abcd" ((0,3),(1,2))   -> "abcd" "bc"

decompress "abcdef" ((0,2),(3,5)) -> "abc" "def"   
 or (whichever version your "compress" generates)
decompress "defabc" ((3,5),(0,2)) -> "abc" "def"

स्कोरिंग

आपका स्कोर कॉल करके लौटे स्ट्रिंग का आकार है compress("<code of compress>", "<code of decompress>")। चूंकि यह कोड-गोल्फ कम स्कोर बेहतर है।

उदाहरण:

कोड मान लें के लिए अपने कार्य compressहै c=abcdऔर के लिए कोड decompressहै d=efghi। फिर compress("c=abcd", "d=efghi")पैदावार "c=abcd=efghi"(और सूचकांक, लेकिन स्कोरिंग को प्रभावित नहीं करते) इसलिए स्कोर है length "c=abcd=efghi" = 12।

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

• इस चुनौती की भावना में, आपका compressऔर कम से कम एक चरित्र में decompress ओवरलैप होना चाहिए । आप एक टिप्पणी जोड़कर इसे तुच्छ रूप से प्राप्त कर सकते हैं, लेकिन ध्यान दें कि ऐसा करने से आपका स्कोर बढ़ जाएगा और अंतर्निहित ओवरलैपिंग कोड का उपयोग करके छोटे समाधान हो सकते हैं।
• compressऔर decompressकिसी भी मुद्रण योग्य ASCII वर्णों के साथ-साथ उन सभी वर्णों को संभालने में सक्षम होना चाहिए जिन्हें आपने परिभाषित किया था compressऔर decompress।
• सूचकांक शून्य- या एक-अनुक्रमित हो सकते हैं।
• आपका कार्यक्रम या कार्यों वास्तव में नामित किया जाना नहीं है compressऔर decompress।

Comments

क्या आप संपीड़ित और कूट कूट को चलाने के लिए विभिन्न कमांड लाइन तर्कों का उपयोग कर सकते हैं?

— माइल्डलीवेटकास्ट

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

— लकोनी

Answer 1

जीएनयू प्रोलॉग, 105 अंक

s(U,L/M,C):-prefix(A,C),length(A,M),suffix(U,A),length(U,L).
o(A-B,C-X-Y):-length(C,_),s(A,X,C),s(B,Y,C).

(यह जीएनयू Prolog आवश्यकता है क्योंकि prefixऔर suffixपोर्टेबल नहीं कर रहे हैं।)

प्रोलॉग में इस चुनौती के लिए एक दिलचस्प, प्रमुख लाभ है; आप कई कॉल पैटर्न को संभालने के लिए एक फ़ंक्शन लिख सकते हैं (यानी न केवल आप फ़ंक्शन को संबंधित आउटपुट प्राप्त करने के लिए इनपुट दे सकते हैं, आप फ़ंक्शन को संबंधित इनपुट प्राप्त करने के लिए आउटपुट दे सकते हैं)। जैसे, हम एक ऐसे फंक्शन को परिभाषित कर सकते हैं जो कंप्रेशन और डीकंप्रेसन दोनों को हैंडल कर सकता है, जिससे 105-बाइट सबमिशन हो सकता है जो एक फंक्शन को परिभाषित करता है oजो दोनों तरह से काम करता है। (संयोग से, मैंने ज्यादातर इसे एक डिकम्प्रेसर के रूप में लिखा था - जैसा कि यह सरल है - और कंप्रेसर को "मुफ्त में" मिला।) सामान्य तौर पर, हम इस कार्य के लिए प्रोलॉग में एक बहुत ही कम कार्यक्रम की उम्मीद कर सकते हैं, अगर इस तथ्य के लिए नहीं कि यह बहुत बुरा है। स्ट्रिंग हैंडलिंग (लापता प्राइमिटिव के संदर्भ में, और प्रश्न में प्राइमरी के संदर्भ में बहुत लंबे नाम वाले)।

करने के लिए पहला तर्क oतार का एक प्रकार है, जैसे "abcd"-"deab"। दूसरे तर्क का एक रूप है "deabcd"-4/6-4/4; यह एक काफी मानक नेस्टेड टपल है, और इसका अर्थ है कि स्ट्रिंग "डीबीडीसीडी" है, पहले स्ट्रिंग की लंबाई 4 है और छठे वर्ण पर समाप्त होती है, दूसरे स्ट्रिंग की लंबाई 4 है और चौथे वर्ण पर समाप्त होती है। (ध्यान दें कि GNU प्रोलॉग में एक स्ट्रिंग सिर्फ वर्ण कोड की एक सूची है, जो डिबगिंग को कष्टप्रद बनाता है क्योंकि कार्यान्वयन डिफ़ॉल्ट रूप से बाद की व्याख्या को प्राथमिकता देता है।) यदि आप देते हैं।oएक तर्क, यह आपके लिए दूसरे का उत्पादन करेगा (इस प्रकार एक कंप्रेसर के रूप में काम करने पर यदि आप पहला तर्क देते हैं, और एक डिकम्प्रेसर यदि आप दूसरा देते हैं)। यदि आप इसे दोनों तर्क देते हैं, तो यह सत्यापित करेगा कि संपीड़ित प्रतिनिधित्व दिए गए तार से मेल खाता है। यदि आप इसे शून्य तर्क देते हैं, तो यह इस तरह आउटपुट उत्पन्न करेगा:

| ?- o(X,Y).
X = []-[]
Y = []-0/0-0/0 ? ;

X = []-[]
Y = [_]-0/0-0/0 ? ;

X = []-[A]
Y = [A]-0/0-1/1 ? ;

…many lines later…

X = [A]-[B,A,C]
Y = [B,A,C]-1/2-3/3 ? ;

I / O प्रारूप का उपरोक्त विवरण बहुत ही पूरी तरह से सिर्फ कार्यक्रम का विवरण है; कार्यक्रम में बहुत ज्यादा नहीं है। मूल्यांकन आदेश संकेत के साथ करने के लिए एकमात्र सूक्ष्मता है; हमें यह सुनिश्चित करने की आवश्यकता है कि कार्यक्रम केवल एक खोज रणनीति का उपयोग नहीं करता है जिसे समाप्त करने की गारंटी है, लेकिन यह सबसे कम संभव आउटपुट स्ट्रिंग भी पैदा करता है।

संपीड़ित करते समय, हम length(C,_)(" Cएक लंबाई") के साथ शुरू करते हैं , जो एक चाल है जो मैंने कई प्रोलॉग और ब्रेकीलॉग उत्तरों में उपयोग किया है; अगर यह पहली बात है, तो प्रोलॉग देखता है, यह Cकिसी और चीज की लंबाई कम करने को प्राथमिकता देगा । यह सुनिश्चित करता है कि हमारे पास न्यूनतम लंबाई है C। बाधाओं का आदेश sसावधानी से चुना जाता है ताकि खोज प्रत्येक संभावित उम्मीदवार की लंबाई के लिए एक सीमित समय ले C; Aद्वारा विवश है C(हम नहीं जानते C, लेकिन हम लक्ष्य मूल्य इसकी लंबाई के लिए हमारे पास पता है), MसेA , Uद्वारा A, और Lसे Uहै, इसलिए खोज से कोई भी असीमित समय लग सकता है।

डीकंप्रेसिंग के दौरान, हम Cसीधे उपयोगकर्ता द्वारा दिए जाते हैं। यह फिर से सुनिश्चित करता है कि बाधाओं के समान अनुक्रम के कारण कार्यक्रम सीमित समय में चलेगा। (जो लोग प्रोलॉग के मूल्यांकन के आदेश से अवगत हैं, वे ध्यान देंगे कि sडिकम्प्रेस्सिंग, रखने length(A,M)और length(U,L)सबसे पहले तेज होने पर परिभाषा बहुत अक्षम है , लेकिन length(A,M)शुरू करने के लिए हिलने पर एक अनंत लूप पैदा हो सकता है क्योंकि संपीड़ित करना न तो समय पर Aऔर न ही Mकिसी चीज से बाध्य होता है; ।)

Answer 2

ब्रेकीलॉग , 50 46 बाइट्स

{Ċ∧Lċ₂l∧Lgj:?z{tT∧?h~cṪhlI∧ṪbhTl:I+-₁:I↔}ᵐ:L}

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

दबाव हटाना:

~{Ċ∧Lċ₂l∧Lgj:?z{tT∧?h~cṪhlI∧ṪbhTl:I+-₁:I↔}ᵐ:L}

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

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

व्याख्या

घोषणात्मक भाषाओं का अच्छा पक्ष यह है कि हम एक ही कोड को संपीड़ित और विघटित करने दोनों के लिए पुन: उपयोग कर सकते हैं। इस प्रकार, संपीड़ित के लिए कोड ठीक उसी तरह है जैसे कि डिकम्प्रेस के लिए , ~शुरुआत में एक अतिरिक्त के साथ ।

यह ~ब्रेजलॉग को तर्कों के क्रम को उलटने के लिए कहता है (अर्थात इनपुट के रूप में आउटपुट और इनपुट के रूप में आउटपुट का उपयोग करें)। चूंकि संपीड़ित नहीं है ~, यह वास्तव में मानक क्रम में विधेय चलाता है। चूंकि डीकंप्रेस में केवल एक ही है, इसलिए यह इसे इनपुट के रूप में आउटपुट और आउटपुट को इनपुट के रूप में चलाता है।

इस तरह, हम एक ही कोड (modulo that extra ~) को संपीड़ित और डीकंप्रेस दोनों के लिए उपयोग कर सकते हैं : कंप्रेसिंग इनपुट के रूप में दो स्ट्रिंग्स और आउटपुट के रूप में एक चर प्रदान कर रहा है, और डिकम्प्रेसिंग इंडेक्स और संपीड़ित स्ट्रिंग को आउटपुट और इनपुट के रूप में एक चर प्रदान कर रहा है। ।

जाहिर है इसका मतलब यह भी है कि हमें अपने कंप्रेसिंग कोड के बारे में थोड़ा स्पष्ट होना होगा, ताकि दुभाषिया इसे "पीछे" चलाने में सक्षम हो। यही कारण है कि कंप्रेसर खुद ही थोड़ा लंबा है।

यहाँ संपीड़न के लिए कोड का टूटना है (और इस प्रकार डीकंप्रेस का भी):

{……………………………………………………………………}   Call that predicate the normal way (with swapped arguments
                                 for decompress)
   Ċ                           Input has two elements
   ∧Lċ₂l                       L is a string of any length (measuring its length forces it to
                                 take a specific length from 0 to +inf)
   ∧Lgj                        The list [L,L]
       :?z                     The list [[L, First elem of Input],[L,second elem of input]]
          {………………………………}ᵐ:L    Final output is the [M,L] where M is the result of mapping
                                 the predicate below on both elements of the zip
           tT                  The second element of the input is T
           ∧?h~cṪ              Anticoncatenate the first element of the input into [A,B,C]
           hlI                 I = length(A)
           ∧ṪbhTl:I+-₁         J = length(T) + I - 1
           :I↔                 Output = [I,J]

Answer 3

जेली , 58 50 बाइट्स

Ais523 के लिए -1 बाइट धन्यवाद ( ⁾दो बाइट स्ट्रिंग के लिए उपयोग करें )

यह अच्छी तरह से काफी गोल्फ हो सकता है ...

संपीड़न दो स्ट्रिंग तर्क लेता है और एक सूची देता है:
[[[startA, lengthA], [startB, lengthB]], compressedString]

w³;w⁴$
0;J⁸ḣ;€
ç;ç@ÑẠ$ÐfLÐṂṪµ³,⁴L€ż@Ñ,

अपघटन एक तर्क (ऐसी सूची) लेता है और दो * तार देता है:

,
⁾ṫḣżFv
Ḣç€Ṫ

अतिव्यापी कोड:

w³;w⁴$
0;J⁸ḣ;€
ç;ç@ÑẠ$ÐfLÐṂṪµ³,⁴L€ż@Ñ,
⁾ṫḣżFv
Ḣç€Ṫ

एक-अनुक्रमित।

* यह जेली के अंतर्निहित प्रिंट फॉर्मेटिंग के कारण स्पष्ट नहीं हो सकता है, इसलिए ऊपर लिंक किए गए TryItOnline के कोड में एक अतिरिक्त बाइट ( Yअंत में) मुद्रित आउटपुट में दोनों के बीच एक पंक्ति फ़ीड सम्मिलित करने के लिए है।

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

कैसे?

ç;ç@ÑẠ$ÐfLÐṂṪµ³,⁴L€ż@Ñ, - Compression: stringA, stringB
ç                       - call the last link (2) as a dyad
  ç@                    - call the last link (2) as a dyad with reversed arguments
 ;                      - concatenate (gives all overlapping strings)
       Ðf               - filter keep:
      $                 -     last two links as a monad
    Ñ                   -         call the next link (1) as a monad
     Ạ                  -         All? (no zeros exist in that result)
          ÐṂ            - filter keep with minimal:
         L              -     length
            Ṫ           - tail (for when more than one exists)
             µ          - monadic chain separation (we now have the compressed string)
              ³,⁴       - [stringA, stringB]
                 L€     - length of €ach
                   ż@   - zip with reversed arguments with
                     Ñ  - next link (1) as a monad with the compressed string
                      , - paired with the compressed string

J0;⁸ḣ;€ - Link 2, possible overlaps: stringL, stringR
J       - range(length(stringL)) - [1,2,...,length(stringL)]
 0;     - zero concatenate       - [0,1,2,...,length(stringL)]
   ⁸    - stringL
    ḣ   - head (vectorises)      - [empty string, first char, first two, ..., stringL]
     ;€ - concatenate €ach with stringR

w³;w⁴$ - Link 1, substring indexes: stringX
w³     - first index of first program argument in stringX or 0 if not found
  ;    - concatenated with
     $ - last two links as a monad
   w⁴  -     first index of second program argument in stringX or 0 if not found

Ḣñ€Ṫ - Decompression: [[[startA, lengthA], [startB, lengthB]], compressedString], ?
Ḣ    - head - [[startA, lengthA], [startB, lengthB]]
   Ṫ - tail - compressedString
 ç€  - call the last link (2) as a dyad for €ach of the left list
     -- extra Y atom at TIO joins the resulting list of two strings with a line feed.

⁾ṫḣżFv - Link 2, extract a substring: [start, length], string
⁾ṫḣ    - string "ṫḣ"
   ż   - zip with [start, length] to yield [['ṫ', start],['ḣ', length]]
    F  - flatten, making a list of characters
     v - evaluate as Jelly code with the string as an argument
       - this evaluates as string.tail(start).head(length) yielding the substring

, - Link 1: only here to make an overlap with the compression program.

Comments

“ṫḣ”2-वर्ण स्ट्रिंग्स के लिए जेली के सिंटैक्स का उपयोग करके 1 बाइट द्वारा गोल्फ किया जा सकता है।

यह एक प्रश्न है जो पूरी तरह से प्रति उत्तर के लिए असंबंधित है, लेकिन क्या आप कोड की व्याख्या हाथ से लिखते हैं या क्या कोई उपकरण इसे कोड से उत्पन्न कर रहा है?

— tfrascaroli

@tfrascaroli मैं इसे हाथ से लिखता हूं

— जोनाथन एलन