11

^{_{यह प्रश्न इस बात पर आधारित है कि मैं दूसरे प्रश्न का उत्तर देने के लिए क्या आया था ।}}

कभी-कभी यहाँ प्रश्न कुछ ASCII कला खींचने के लिए कहते हैं। कला के लिए डेटा संग्रहीत करने का एक सरल तरीका RLE (रन-लेंथ एन्कोडिंग) है । इसलिए:

qqqwwwwweeerrrrrtttyyyy

हो जाता है:

3q5w3e5r3t4y

अब एक बड़ी ASCII कला बनाने के लिए आपको शायद इस तरह से डेटा मिल रहा है (नई पंक्ति वर्णों की अनदेखी):

19,20 3(4)11@1$20 11@19,15"4:20 4)19,4:20 11@
   ^^^
   Note that this is "20 whitespaces"

(Character count: 45)

ASCII कला के लिए उपयोग किए जाने वाले वर्ण कभी भी कम या अपरकेस अक्षर या संख्या नहीं होने वाले हैं, केवल संकेत, चिह्न और प्रतीक लेकिन हमेशा मुद्रण योग्य ASCII वर्ण सेट में।

आप उस स्ट्रिंग में कुछ स्थान बचाना चाहते हैं, इसलिए आप संख्याओं को अपरकेस वर्ण सेट से प्रतिस्थापित करते हैं ('ए' 1 के बराबर है, 'बी' 2 के बराबर है जब तक 'जेड' 26 के बराबर है), क्योंकि आप कभी भी नहीं जा रहे हैं एक चरित्र के 26 से अधिक दोहराव प्राप्त करें। तो आप प्राप्त करें:

S,T C(D)K@A$T K@S,O"D:T D)S,D:T K@

(Character count: 34)

और अंत में आप नोटिस करते हैं कि (अक्षर + प्रतीक) के कुछ समूह दोहरा रहे हैं, इसलिए आप उन समूहों को प्रतिस्थापित करते हैं जो स्ट्रिंग में लोअरकेस कैरेक्टर सेट, क्रम या उपस्थिति में स्ट्रिंग में 3 बार या अधिक दिखाई देते हैं, लेकिन बफर में स्टोर करना किए गए प्रतिस्थापन (प्रत्येक प्रतिस्थापन के लिए प्रारूप "समूह + प्रतिस्थापन चार" में), और बाकी स्ट्रिंग को छोड़ दें जैसा कि है। तो निम्नलिखित समूह:

S, (3 times) 
T  (4 times)
K@ (3 times)

क्रमशः 'a', 'b' और 'c' द्वारा प्रतिस्थापित किया जाता है, क्योंकि दोहराए जाने वाले 26 से अधिक समूह कभी नहीं होंगे। तो अंत में आपको मिलता है:

S,aT bK@c
abC(D)cA$bcaO"D:bD)aD:bc

(Character count: 9+24=33)

_{[अंतिम चरण केवल 1 बाइट बचाता है क्योंकि जिन समूहों को प्रतिस्थापित किए जाने के बाद वास्तव में पात्रों को बचाया जाता है वे 4 गुना या उससे अधिक दिखाई दे रहे हैं।]}

चुनौती

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

ध्यान दें कि यदि स्ट्रिंग को चरण 2 में संपीड़ित नहीं किया जा सकता है, तो एल्गोरिथ्म को पहले रिटर्न मान के रूप में एक खाली स्ट्रिंग वापस करना होगा और चरण 1 का परिणाम दूसरे वापसी मूल्य के रूप में होना चाहिए।

आपको आउटपुट मानों में चरण 1 के परिणाम को शामिल करने की आवश्यकता नहीं है, मैं सिर्फ स्पष्टीकरण उद्देश्यों के लिए उन्हें उदाहरणों में शामिल करता हूं।

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए सबसे कम उत्तर हो सकता है!

एक और परीक्षण मामला

Input:                   15,15/10$15,15/10"10$10"10$10"10$10"15,15/

Output of step 1:        O,O/J$O,O/J"J$J"J$J"J$J"O,O/

Final algorithm output:  O,aO/bJ$cJ"d
                         abcabdcdcdcdab

---

Input:                   15,15/10$15,15/10"

Output of step 1:        O,O/J$O,O/J"

Final algorithm output:  <empty string>
                         O,O/J$O,O/J"

code-golf ascii-art compression

— चार्ली
स्रोत

1

क्योंकि आप एक चरित्र के 26 से अधिक दोहराव पाने के लिए कभी नहीं जा रहे हैं । aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

— Okx

@Okx ऐसा कभी नहीं हो सकता।

— आउटगोल्फर

@ ऑक्स हाँ, वास्तविक दुनिया में। नियम एएससीआईआई कला के एक सीमित सेट के लिए बनाए गए हैं, हालांकि।

— चार्ली

2

एक वास्तविक क्रियान्वयन में, S,aT bK@cसंभवत: S,T K@प्रतिस्थापन पात्रों के नामकरण के बिना ही संग्रहीत किया जाएगा , जो कि उससे मामूली रूप से घटाया जा सकता है।

— अरनुलद

@ अर्नुलड आप पूरी तरह से सही हैं, मैं चूक गया, लेकिन मैं इस सवाल को छोड़ने जा रहा हूं, जैसा कि किसी ने भी उसका जवाब लिखना शुरू कर दिया है।

— चार्ली

3

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

दो स्ट्रिंग्स की एक सरणी देता है [dictionary, compressed_string]:।

s=>[(a=(s=s.replace(/\d+/g,n=>C(n|64),C=String.fromCharCode)).match(/../g)).map(v=>s.split(v)[a[v]||3]>=''?D+=v+(a[v]=C(i++)):0,i=97,D='')&&D,a.map(v=>a[v]||v).join``]

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

कोड स्निपेट दिखाएं

let f =

s=>[(a=(s=s.replace(/\d+/g,n=>C(n|64),C=String.fromCharCode)).match(/../g)).map(v=>s.split(v)[a[v]||3]>=''?D+=v+(a[v]=C(i++)):0,i=97,D='')&&D,a.map(v=>a[v]||v).join``]

console.log(f('19,20 3(4)11@1$20 11@19,15"4:20 4)19,4:20 11@'))
console.log(f('15,15/10$15,15/10"10$10"10$10"10$10"15,15/'))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

3

पायथन 2 , 269 280 268 266 बाइट्स

यहां कुछ भी नहीं चल रहा है। कुछ सरल नियमित अभिव्यक्तियों का उपयोग करने का अच्छा अवसर।

पहला संस्करण विशेष वर्ण वाले स्ट्रिंग्स के लिए विफल रहा, जिसे रेगेक्स के भीतर व्याख्या किया गया था। दूसरा संस्करण (re.escape का उपयोग करके) सभी परीक्षण मामलों के साथ काम करता है। उस सुधार की लागत 11 बाइट्स है।

दूसरा संस्करण क्रमांकन पात्रों को निर्दिष्ट नहीं करता है, जैसा कि समस्या विनिर्देश में आवश्यक है, और जैसा कि @CarlosAlejo ने बताया है। इस प्रकार फिर से ड्राईंग बोर्ड का इस्तेमाल करते हैं।

सही किया गया संस्करण, आगे गोल्फ हुआ

-6 बाइट्स को दो लाइनों पर आउटपुट प्रिंट नहीं करने से बचाया
+3 बाइट्स: निर्दिष्ट के रूप में चुनौती को पूरा करने की अनुमति देने के लिए एक स्ट्रिंग के माध्यम से कोड प्रतिस्थापन पर स्विच करना।
-4 बाइट्स: चूंकि मैं अब दो बार re.findall नहीं कह रहा हूं, मुझे इसका नाम बदलने की आवश्यकता नहीं है
-5 बाइट्स: छोरों से छोरों के लिए स्विच करना।
-2 बाइट्स @ कॉमेड स्पार्कल पोनी को धन्यवाद

import re
S=re.sub
b=a=input()
for i in re.findall('\d{1,2}',a):
 b=S(i, chr(64+int(i)),b)
n,s,p=96,'',0
while p<len(b):
 c=b[p:p+2];f=b.count(c)
 if f>2and not c in s:n+=1;s+=c+chr(n)
 p+=2
p=0
while p<len(s):k=s[p:p+2];v=s[p+2];b=S(re.escape(k),v,b);p+=3
print s,b

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

— CCB60
स्रोत

आप लगभग वहाँ हैं, ध्यान दें कि दूसरे चरण में समूह उचित क्रम में नहीं बने हैं (उदाहरण देखें)। उपस्थिति के क्रम में समूह बनाए जाने चाहिए, इसलिए पहले वाला होना चाहिए O,a।

— चार्ली

@CarlosAlejo मैंने यह उल्लेख नहीं किया था कि एक आवश्यकता के रूप में, चूंकि कार्यात्मक दृष्टिकोण से, विकल्प मनमाने हैं। पायथन के डिफॉल्ट डिक्शनरी, इसे लागू करने का एक प्राकृतिक तरीका, अनियंत्रित हैं। अन्य संभावित डेटा संरचनाओं पर विचार करना होगा ....

— CCB60

आप का उपयोग करके b=a=input()और कुछ बाइट्स नहीं बचा सकता है n,s,p=96,'',0?

— कॉमरेड स्पार्कलेपनी

\d+उपयोग करने के लिए एक छोटा रेगेक्स होगा। आप कभी भी 26 से अधिक जाने वाले नहीं हैं इसलिए यह सुनिश्चित करने का कोई कारण नहीं है कि यह विशेष रूप से 1-2 अंक का है। इसके अलावा, उपयोग करने का re.escapeमतलब है कि एक मूल स्ट्रिंग replaceथोड़ा कम समाप्त होता है: 253 बाइट्स

— मूल्य इंक

0

लूआ, 215 बाइट्स

बस पैटर्न का एक अच्छा सा मिलान।

मुझे लगता है कि जब गोल्फ की बात आती है तो लूआ की अंडरस्टैंडिंग होती है ... उन सभी कथनों को एक साथ देखें!

g,c=string.gsub,string.char
u=g(arg[1],"%d%d?",function(n)return c(n+64)end)l,d=97,""g(u,"..",function(m)n,e=0,g(m,".", "%%%0")g(u,e,function()n=n+1 end)if n>2 then
l,s=l+1,c(l)d,u=d..m..s,g(u,e,s)end
end)print(u,d)

— Trebuchette
स्रोत

0

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

from re import*
S=sub('\d+',lambda m:chr(int(m.group(0))+64),input())
Q=[]
for p in findall('[A-Z].',S):
 if S.count(p)>2:a=chr(len(Q)+97);Q+=[p+a];S=sub(escape(p),a,S)
print''.join(Q),S

मैं आखिरकार इसका उपयोग करने की उम्मीद कर रहा था re.subn: सी

# first step - convert all numbers to uppercase letters
S=sub('\d+',lambda m:chr(int(m.group(0))+64),input())
# empty list to hold encoding of second step
Q=[]
# find every encoded pair (uppercase letter and some char)
for p in findall('[A-Z].',S):
 # if it occures 3 or move times
 if S.count(p)>2:
  # get lowercase letter to substitute with
  a=chr(len(Q)+97)
  # store encoding into list
  Q+=[p+a]
  # update string - substitute pair with lowercase letter
  S=sub(escape(p),a,S)
# output
# encodings of second step, space, result
# if nothing was compressed at step 2, space would prepend result (of step 1)
print''.join(Q),S

चरण 2 पर संकुचित

चरण 2 पर संकुचित नहीं

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

पुन: ssub के उत्तर lambda में किया गया दूसरा चरण। सिर्फ मनोरंजन के लिए।

from re import*
Q=[]
S=sub('\d+',lambda m:chr(int(m.group(0))+64),input())
S=sub('[A-Z].',lambda m:(lambda m:S.count(m)>2and(m in Q or not Q.append(m))and chr(Q.index(m)+97)or m)(m.group(0)),S)
print''.join(Q[i]+chr(i+97)for i in range(len(Q))),S

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

— मृत पोसुम
स्रोत

0

पर्ल 5 `-pl` , 81 बाइट्स

s/\d+/chr$&+64/ge;$b=a;for$a(/([A-Z].)(?=.*\1.*\1)/g){s/\Q$a/$b/g&&($\.=$a.$b++)}

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

पहली पंक्ति पर एन्कोडेड स्ट्रिंग को प्रिंट करता है, दूसरी लाइन पर ट्रिपल

— Xcali
स्रोत

0

रूबी `-p` , 133 बाइट्स

gsub(/(\d+)(.)/){(64+$1.to_i).chr+$2}
c=?`;s=''
$_.scan(/(..)(?=.*\1.*\1)/){s+=$&+c.succ!if !s[$&]}
puts s.scan(/(..)(.)/){gsub$1,$2}

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

— मूल्य स्याही
स्रोत

ASCII कला को आकर्षित करने के लिए RLE डेटा का संपीडन

चुनौती

एक और परीक्षण मामला

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

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

पायथन 2 , 269 280 268 266 बाइट्स

सही किया गया संस्करण, आगे गोल्फ हुआ

लूआ, 215 बाइट्स

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

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

पर्ल 5 -pl , 81 बाइट्स

रूबी -p , 133 बाइट्स

पर्ल 5 `-pl` , 81 बाइट्स

रूबी `-p` , 133 बाइट्स