एक एन्कोडेड स्ट्रिंग का विस्तार करें

Question

क्लासिक रन लंबाई एन्कोडिंग और डिकोडिंग है।

input   output
a3b2c5  aaabbccccc

और यह काफी सीधे आगे और पहले किया गया है।

यह चुनौती गैर-मानक व्यवहार के लिए भी है, जब कई अक्षर रन की लंबाई ( 0-9 से एक अंक) से पहले होते हैं। रन लंबाई अंक से पहले प्रत्येक चरित्र (एक गैर-अंक या स्ट्रिंग के अंत से पहले अंतिम अंक) में वह मूल्य व्यक्तिगत रूप से लागू होता है और क्रम में मुद्रित होता है।

कुछ परीक्षण इनपुट और आउटपुट जिसमें कुछ किनारे मामले शामिल हैं:

input   output
ab3c5   aaabbbccccc
a0b3    bbb  
13b1    111b
a13b1   aaa111b
a123b1  aaa111222b
aa2a1b1 aaaaab

• एक चरित्र अनुक्रम ( [a-zA-Z0-9]+) को इसकी रन लंबाई लंबाई ( [0-9]) द्वारा पालन किया जाना चाहिए
• केवल वैध इनपुट पर विचार किया जाना चाहिए ( ([a-zA-Z0-9]+[0-9])*)
  • हाँ, खाली स्ट्रिंग मान्य इनपुट है।
• इनपुट मानक इनपुट के माध्यम से है, मानक आउटपुट के माध्यम से आउटपुट

यह कोड गोल्फ है, बाइट्स की संख्या विजेता को निर्धारित करती है।

Comments

@AlexA। सही बात। वहाँ कुछ esolangs है कि मैं समय-समय पर देखने का आनंद लेता हूं जो अन्यथा बाइट काउंट द्वारा दंडित किए जाते हैं। (मैं सुझाव के लिए निश्चित रूप से खुला हूं कि इस तरह से गिनने की गलती क्यों हो सकती है)

@MichaelT वर्णों द्वारा स्कोरिंग स्रोत कोड को UTF32 में संपीड़ित करने के लिए दृढ़ता से प्रोत्साहित करता है, जो प्रति वर्ण 4 बाइट तक एन्कोडिंग की अनुमति देता है, लेकिन पूरी तरह से अपठनीय है।

— इसहाक

@ आइसाकग फेयर 'नफ। मैं बाइट्स में बदलने के लिए संपादित करूँगा। मैं भविष्य की चुनौतियों के लिए स्वीकार्य होने की शैली को व्यक्त करने के तरीके पर प्रकाश डालूंगा।

यदि इनपुट खाली स्ट्रिंग है तो क्या हमारा सबमिशन बिना किसी त्रुटि के पूरा होना चाहिए? मेटा पर आम सहमति यह है कि STDERR के आउटपुट को अनदेखा किया जा सकता है, लेकिन चूंकि आपने स्पष्ट रूप से इसका उल्लेख किया है, इसलिए मुझे पूछना होगा।

— डेनिस

@ डेनिस एक खाली स्ट्रिंग के रूप में इनपुट चाहिए, रुक जाना चाहिए। यह एक अनंत लूप में नहीं जाना चाहिए या अन्य पाठ को मानक आउटपुट पर प्रिंट नहीं करना चाहिए।

Answer 1

पिप, 22 + 1 = 23 बाइट्स

-rध्वज का उपयोग करता है । ध्यान दें कि इसके लिए आपको या तो 1) इनपुट के बाद एक EOF दर्ज करना होगा (लिनक्स पर Ctrl-D, विंडोज पर Ctrl-Z) या 2) इनपुट को कहीं और से इनपुट करें।

(^_@<v)X_@vMa@`\D*\d+`

स्पष्टीकरण:

                        a is first line of stdin (from -r flag) and v is -1 (implicit)
              `\D*\d+`  Pattern (regex) object that matches zero or more non-digits
                        followed by at least one digit
            a@          Find all non-overlapping matches in a, returning a list of strings
           M            To that list, map a lambda function:
  _@<v                    Argument sans last character (equivalent to Python a[:-1])
(^    )                   Split into a list of characters
        _@v               Last character of argument
       X                  Repeat each character of the list that many times
                          (String multiplication X, like most operators, works item-wise
                          on lists)
                        Auto-print (implicit)

मैप ऑपरेशन का परिणाम वास्तव में सूचियों की एक सूची है, लेकिन डिफ़ॉल्ट सूचियों को मुद्रित करते समय केवल एक साथ समेटा जाता है, इसलिए स्ट्रिंग के लिए कोई भी मैन्युअल रूपांतरण आवश्यक नहीं है।

उदाहरण, इनपुट के साथ a13b1:

Var a gets        "a13b1"
After regex match  ["a13" "b1"]
After map          [["aaa" "111"] ["b"]]
Final output       aaa111b

पिप के पास मूल रेगेक्स समर्थन है ... 2 दिन पहले । महान समय!

Comments

यह -rध्वज के साथ एक काम करता है (और इसलिए मास्टर) । (प्रश्न निर्दिष्ट करता है कि इनपुट को STDIN से आना है।)

— डेनिस

@ डेनिस उफ़, वह चूक गया। बाइट काउंट में झंडा जोड़ा। मुझे बिना किसी अतिरिक्त झंडे qके aसाथ विशेष चर का उपयोग करने में सक्षम होना चाहिए , लेकिन एक बग लगता है और यह दो बार इनपुट के लिए पूछ रहा है।

— DLosc

रेगेक्स समर्थन के साथ अंत में एक गोल्फ भाषा!

— डेनिस

@ डेनिस मैं तुम्हें अब पाइप करने के लिए शिफ्ट कर रहा हूँ!

— ऑप्टिमाइज़र

Answer 2

पर्ल / बैश 54 40 + 1 = 41 बाइट्स

perl -pe's:(\D*\d*)(\d):"\$1=~s/./\$&x$2/egr":ege'

यह मूल रूप से एक रेगेक्स के भीतर एक रेगीक्स है। और थोड़ा सा जादू।

व्याख्या

बाहरी रेगेक्स /(\D*\d*)(\d)/gप्रत्येक रन-लंबाई एन्कोडेड समूह को निकालता है। हम $1पुनरावृत्ति की संख्या और अंदर दोहराव की संख्या पर कब्जा कर लेते हैं $2। अब हम उस समूह के विस्तार के साथ प्रत्येक ऐसे समूह को प्रतिस्थापित करते हैं। उसके लिए, हम "\$1=~s/./\$&x$2/egr" दो बार कोड का मूल्यांकन करते हैं ( /eeबाहरी प्रतिस्थापन पर ध्वज द्वारा )।

पहला मूल्यांकन केवल पुनरावृत्ति की संख्या को स्ट्रिंग में प्रक्षेपित करेगा - अन्य चर एक बैकस्लैश द्वारा संरक्षित हैं। इसलिए इनपुट मानते हुए a14, अब हमारे पास कोड $1=~s/./$&x4/egrहोगा, जिसका मूल्यांकन फिर से किया जाएगा।

यह $1(दोहराने के लिए सामग्री) की सामग्री के प्रतिस्थापन को लागू करेगा a1। प्रतिस्थापन प्रत्येक वर्ण से मेल खाता है .। $&चर पूरे मैच है, जो हम दोहराने रखती x4बार। हम इसे /gप्रत्येक मैच के लिए लॉबली करते हैं और चर /rको संशोधित करने के बजाय प्रतिस्थापित स्ट्रिंग $1(जो केवल-पढ़ने के लिए है) को बदल देते हैं। तो भीतर के प्रतिस्थापन का परिणाम है aaaa1111।

-pझंडा प्रत्येक इनपुट लाइन के लिए प्रतिस्थापन लागू होता है और परिणाम बाहर प्रिंट करता है।

Comments

यह एक पर्ल समाधान के रूप में स्कोर करने के लिए प्रथागत है, जहां आप -pसंशोधक के लिए सिर्फ 1 बाइट जोड़ते हैं । मैं 45 बाइट्स गिनता हूं। इसके अलावा, आपको \Dइसके बजाय उपयोग करने में सक्षम होना चाहिए [a-z], जिससे इसकी आवश्यकता भी समाप्त हो गई i।

— डेनिस

Answer 3

CJam, 33 31 27 बाइट्स

ऊघ, नियमित भावों की कमी इसे बहुत लंबा बनाती है ...

qN+{:XA,s&L\:L>{])~e*[}&X}%

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

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

(थोड़ा पुराना कोड विस्तार)

q{                       }%        e# Read the input (q) and loop through each character
  L                                e# Put variable L (initially empty character) on stack
   A,                              e# Put variable A (equals 10) and create an array 0..9
     s                             e# Convert the array to string "0123456789"
      &                            e# Do a set intersect b/w previous char and 0-9 string
                                   e# If numeric, it gives 1 char string, otherwise 0
       \:LA,s&                     e# Swap to bring current character on top. Store it in L
                                   e# and do the same set intersect with it
              >                    e# Means we are checking that current char is non-numeric
                                   e# and previous numeric
               {      }&           e# Run this block if above is true
                ])~                e# Wrap everything not already repeated in an array and
                                   e# take out the last character and convert it to integer.
                                   e# This is the run length of the preceding string
                   e*              e# Repeat each character in the string, run length times
                     [             e# Start a new array to help when next run length is found
                        L          e# Restore the current character back on stack to be used
                                   e# in next iteration
                           )~e*    e# The last string-run-length pair is not decoded..
                                   e# So we do that now

इसे यहाँ ऑनलाइन आज़माएँ

Comments

मैं उस समस्या के प्रदर्शन की सराहना करता हूं जो बाइट्स क्वालीफायर का कारण बनती है। धन्यवाद। मैं इस बारे में थोड़ा सोच रहा हूं कि योग्यता को कैसे वाक्यांशित किया जाए, जहां एक एकल निर्देश बहु-बाइट चरित्र है, जो कि यूटीएफ एन्कोडिंग की अनुमति के बिना भाषा की उस शैली के लिए दंडित नहीं किया जाता है जिसे आपने खामियों के माध्यम से प्राप्त करने के लिए दिखाया था। PS मुझे वास्तव में आपके द्वारा प्रदान किए गए एल्गोरिदम को देखना पसंद है।

Answer 4

rs , 43 71 चार्ट

खैर, यह बहुत जल्दी बदल गया। बेवकूफ नंबर ...

(\d)(\D)/\1 \2
+(\w)(\w+?)(\d)(?= |$)/\1\3 \2\3
(\w)(\d)/(\1)^^(\2)
 /

यहाँ कोशिश करो!

मूल संस्करण (इनपुट की तरह काम नहीं किया 123):

+(\D)(\D+)(\d)/\1\3\2\3
(\D)(\d)/(\1)^^(\2)

व्याख्या

पहली पंक्ति संख्या से युक्त, जैसे मोड़ रन के बीच रिक्त स्थान देता है a313में a3 13।

दूसरी पंक्ति लगातार संपीड़ित एन्कोडिंग की तरह फैलती aa5है a5a5।

तीसरी लाइन के प्रत्येक उदाहरण धर्मान्तरित a5में aaaaaका उपयोग कर पुनरावृत्ति ऑपरेटर ।

अंतिम पंक्ति रिक्त स्थान को हटा देती है।

Comments

कैसे संभालती है a123b1?

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र ठीक नहीं है। मुझे इसे थोड़ा ट्वीक करने की ज़रूरत है ...

— kirbyfan64sos

@ ऑप्टिमाइज़र फिक्स्ड।

— kirbyfan64sos

Answer 5

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

alert(prompt().replace(/(.+?)(\d)(?!\d)/g,(a,b,c)=>b.replace(/./g,y=>y.repeat(c))))

टिप्पणी की:

alert( // output final result
    prompt(). // take input
    replace(/(.+?)(\d)(?!\d)/g, // replace ungreedy capture group of any characters 
                                // followed by a digit (captured)
                                // and not followed by a digit (negative lookahead)
        (a, b, c)=> // replace with a function
            b.replace(/./g, // replace all characters in b
                y=>y.repeat(c) // with that character repeated c times
            )
    )
)

Comments

alert(prompt().replace(/(.+?)(\d)(?!\d)/g,(a,b,c)=>Array(c+1).join(b)))एक ही नहीं करेंगे ? यह केवल 71 बाइट्स लंबा है।

— इस्माइल मिगुएल

@IsmaelMiguel केवल तभी काम करेगा जब अंक से पहले एक ही चरित्र हो। सरणी समझ प्रत्येक चरित्र को व्यक्तिगत रूप से दोहराती है।

— अंडरस्कोर

कोशिश करो Array(6).join('12')और यह वापस आ जाएगी '1212121212'।

— इस्माइल मिगुएल

यह एक काम करता है: alert(prompt().replace(/(.+?)(\d)(?!\d)/g,(a,b,c)=>Array(-~c).join(b)))(एक ही 71 बाइट्स लंबी, es6fiddle.net/ia7gocwg पर परीक्षण किया गया )

— इस्माइल मिगुएल

मुझे 3 बाइट्स कहने का एक अलग (स्पष्ट) तरीका मिला: D

— nderscore

Answer 6

सीजेएम, 27 25 बाइट्स

r_'A+1>.{64&1$>{])~f*o}&}

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

r_                        e# Read a token from STDIN and push a copy.
  'A+                     e# Append the character A to the copy.
     1>                   e# Discard the first character of the copy.
       .{               } e# For each character C of the input string and the
                          e# corresponding character D of the copy:
         64&              e#   Take the bitwise and of D and 64. This pushes @
                          e#   if D is a letter and NUL if it is a digit.
            1$>           e#   Compare the result to a copy of C. This pushes 1
                          e#   if and only if D is a letter and C is a digit.
               {      }&  e#   If the result was 1, do the following:
                ]         e#     Wrap the stack in an array.
                 )~       e#     Pop and evaluate the last character.
                   f*     e#     Repeat each char in the array that many times.
                     o    e#     Print all characters.

Answer 7

पायथ, 33 32 28 बाइट्स

ssmm*vedkPdPcz-hMJf<@zT\=UzJ

इसे ऑनलाइन आज़माएं: प्रदर्शन या टेस्ट हार्नेस

व्याख्या

मैं उदाहरण इनपुट का उपयोग करके कोड समझाता हूं aa1a23b2। उम्मीद है कि इसके बिना पालन करना थोड़ा आसान है।

                               implicit: z = input string = 'aa1a23b2'
                         Uz    the indices of z: [0, 1, 2, 4, 5, 6, 7]
                  f            filter for indices T, which satisfy:
                   <@zT\=        z[T] < "="
                               this gives us the list of indices [2, 4, 5, 7], 
                               which correspond to digits in z. 
                 J             assignment, J = [2, 4, 5, 7]
               hMJ             increment all element in J: [3, 5, 6, 8]
              -            J   and remove the elements of J:
                                 [3, 5, 6, 8] - [2, 4, 5, 7] = [3, 6, 8]
            cz                 split z at these indices: ['aa1', 'a23', 'b2', '']
           P                   remove last element: ['aa1', 'a23', 'b2']
  m                            map each string d to:
   m     Pd                      map each string k of d-without-last-char to:
     ved                           int(last element of d)
    *   k                          * k
                               this creates [['a', 'a'], ['aaa', '222'], ['bb']]
 s                             sum the lists: ['a', 'a', 'aaa', '222', 'bb']
s                              sum the strings: 'aaaaa222bb'

Answer 8

रूबी 73

gets.split(/(\d)(?!\d)/).each_slice(2){|s,i|s.chars.map{|c|$><<c*i.to_i}}

टेस्ट: http://ideone.com/L1fssb

Answer 9

जावास्क्रिप्ट 112

alert(prompt().replace(/.*?\d+/g,function(m){for(i=n=m.length-1,o="";i--;){j=m[n];while(j--)o=m[i]+o}return o}))

Answer 10

पायथन 2.7, 98 बाइट्स

import re
print"".join(c*int(m[-1])for m in 
re.findall(r".+?\d(?!\d)",raw_input())for c in m[:-1])

यह सिर्फ उन अंकों के लिए एक सरल रेगेक्स खोज करता है जो एक अंक का अनुसरण नहीं करते हैं, और फिर प्रत्येक समूह पर स्ट्रिंग अंकगणित करते हैं और उन सभी को वापस एक साथ जोड़ते हैं।

Comments

आप अजगर 2 से 3 पर स्विच करके 2 बाइट्स बचा सकता है raw_inputहो जाता है input, लेकिन printजरूरत है कोष्ठकों।

— एलेक्स ए

यह सच है, लेकिन मैं अजगर 2.7 में गोल्फ पसंद करता हूं।

— पुनरावर्ती

Answer 11

जूलिया, 105 99 95 87 बाइट्स

s->join([join([string(b)^(int(p[end])-48)for b=chop(p)])for p=matchall(r"\D*\d*\d",s)])

यह एक अनाम फ़ंक्शन बनाता है जो इनपुट के रूप में एक स्ट्रिंग लेता है एक स्ट्रिंग देता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदाf=s->... ।

दो सरणी समझ का उपयोग यहां किया जाता है, एक दूसरे के भीतर निहित है। बाहरी अभिव्यक्ति नियमित अभिव्यक्ति के खिलाफ इनपुट स्ट्रिंग के प्रत्येक मैच पर कार्य करती है \D*\d*\d। आंतरिक समझ मैच के प्रत्येक चरित्र को अनुगामी अंक के अनुसार दोहराती है। आंतरिक सरणी के तत्व एक स्ट्रिंग में शामिल हो जाते हैं, इसलिए बाहरी सरणी स्ट्रिंग की एक सरणी है। ये जुड़ गए और वापस लौट आए।

जूलिया में, तार को चरित्र सरणियों की तरह माना जा सकता है। हालांकि, ध्यान दें कि जूलिया में Charऔर Stringप्रकारों को परिभाषित समान तरीके नहीं हैं; विशेष रूप से, ^वर्णों के लिए पुनरावृत्ति के लिए कोई विधि नहीं है । यह एक जटिल वर्कअराउंड का उपयोग करता है:

• अंतिम चरित्र को छोड़ने वाले स्ट्रिंग पर लूप, जिसे उपयोग करके हटा दिया जाता है chop()।
• वर्तमान वर्ण का उपयोग करके स्ट्रिंग में कनवर्ट करें string()।
• अनुगामी अंक, जो एक वर्ण भी है, पूर्णांक में परिवर्तित करें। हालाँकि, ध्यान दें कि, उदाहरण के लिए, int('4')4. वापस नहीं आता है। बल्कि, यह कोडपॉइंट लौटाता है, जो इस मामले में 52 है। इस प्रकार हम वास्तविक पूर्णांक को वापस लाने के लिए 48 घटा सकते हैं।
• दोहराना string(b) अनुसारint(p[end]) - 48 ।

उदाहरण:

julia> f("ab3c5")
"aaabbbccccc"

julia> f("a0b3")
"bbb"

julia> f("13b1")
"111b"

Answer 12

पायथन 3, 148 144 136 135 बाइट्स

w,o,r,d=''.join,'',[],[]
for c in input()+' ':
 if'/'<c<':':d+=[c]
 elif d:o+=w(x*int(w(d))for x in r);r=[c];d=[]
 else:r+=[c]
print(o)

सुझाव के लिए Pietu1998 और mbomb007 का धन्यवाद।

अजगर 2, 161 151 147 139 138 बाइट्स

हो सकता है कि आज का दिन काम पर एक लंबा दिन हो, लेकिन मैं अपने जीवन के लिए यह पता नहीं लगा सकता कि यह कैसे करना है।

w,o,r,d=''.join,'',[],[]
for c in raw_input()+' ':
 if'/'<c<':':d+=[c]
 elif d:o+=w(x*int(w(d))for x in r);r=[c];d=[]
 else:r+=[c]
print o

Comments

पायथन 3 में बदलने से बाइट्स ( raw_आउट, कोष्ठक print) की एक जोड़ी बचती है । len(d)>0द्वारा प्रतिस्थापित किया जा सकता है dक्योंकि एक खाली सूची गलत है और एक खाली सूची सत्य है। list(...)सीधे जा सकते हैं for। वर्ग ब्रैकेट w([...])अनावश्यक हैं क्योंकि यह एकमात्र तर्क है। आप में जगह निकाल सकते हैं ) for। मैं अब तक जितनी भी छोटी-छोटी चीजें लेकर आया हूं।

— पुरकाकूदरी

@ Pietu1998 मदद के लिए धन्यवाद!

— काडे

अपने दृष्टिकोण को बहुत अधिक बदले बिना, आप इससे छुटकारा पा सकते हैं list()क्योंकि तार चलने योग्य हैं। आप उपयोग कर सकते हैं w=r=''। यदि आप इसे बहुत बदलने के लिए तैयार हैं, तो मेरा समाधान देखें। :)

— पुनरावर्ती

if c.isdigit()if'/'<c<':'अगर मैं गलत नहीं हूँ, बन सकता है ।

— DLosc

@DLosc धन्यवाद, जो काम करने लगता है।

— केडे

Answer 13

जावा 7, 175 बाइट्स

String c(String s){String r="",a[];for(String x:s.split("(?<=(\\d)(?!\\d))")){a=x.split("");for(int i=0,j,l=a.length-1;i<l;i++)for(j=0;j++<new Short(a[l]);r+=a[i]);}return r;}

चुनौती कठिन से अधिक लग रहा है, imo ..

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

class M{
  static String c(String s){
    String r = "",
           a[];
    for(String x : s.split("(?<=(\\d)(?!\\d))")){
      a = x.split("");
      for(int i = 0, j, l = a.length-1; i < l; i++){
        for(j = 0; j++ < new Short(a[l]); r += a[i]);
      }
    }
    return r;
  }

  public static void main(String[] a){
    System.out.println(c("ab3c5"));
    System.out.println(c("a0b3"));
    System.out.println(c("13b1"));
    System.out.println(c("a13b1"));
    System.out.println(c("a123b1"));
    System.out.println(c("aa2a1b1"));
    System.out.println(c("123"));
  }
}

आउटपुट:

aaabbbccccc
bbb
111b
aaa111b
aaa111222b
aaaaab
111222