सड़क-लंबाई एनकोडिंग

Question

संयुक्त राज्य में , सड़क पर यातायात के दो विपरीत दिशाओं को एक धराशायी पीली रेखा द्वारा अलग किया जाता है यदि गुजरने की अनुमति दी जाती है और यदि गुजरने की अनुमति नहीं है तो दो ठोस पीले रेखाएं।

(उस तरफ से गुजरने की अनुमति देने के लिए बस एक पक्ष को धराशायी किया जा सकता है, और पीली रेखाओं का मतलब केंद्र या प्रतिवर्ती गलियों जैसी अन्य चीजों से हो सकता है, लेकिन हम उन मामलों में से किसी के साथ चिंतित नहीं हैं।)

एक प्रोग्राम है जो एक में लेता लिखें रन लंबाई इनकोडिंग की स्ट्रिंग Pके लिए गुजर रहा है और Nके लिए नहीं गुजर , और इसी सड़क के एक ASCII संस्करण प्रिंट करता है। केंद्र रेखा को छोड़कर, सड़क पर हमेशा एक ही पैटर्न होता है, जिसे नीचे दिए गए उदाहरणों से आसानी से समझा जा सकता है।

प्रत्येक स्ट्रिंग से पहले Pऔर Nइनपुट स्ट्रिंग में एक सकारात्मक दशमलव संख्या होगी । यह संख्या गुजरने की लंबाई को परिभाषित करती है सड़क के वर्तमान भाग के या न गुजरने ।

उदाहरण

बिना किसी गुजरती सड़क के 12N12 स्तंभों का एक इनपुट होगा (केंद्र की सभी लाइन ):=

____________


============

____________

की एक इनपुट 12Pके 12 कॉलम का उत्पादन होता गुजर सड़क (मध्य रेखा - दोहरा):

____________


- - - - - - 

____________

उत्तीर्ण और कोई उत्तीर्ण नहीं किया जा सकता है, तो संयुक्त किया जाएगा, जैसे 4N4P9N7P1N1P2N2Pउत्पादन होगा:

______________________________


====- - =========- - - -=-==- 

______________________________

ये 4 नो पासिंग कॉलम हैं, फिर 4 पासिंग , फिर 9 नो पासिंग आदि।

ध्यान दें कि एक गुजर क्षेत्र हमेशा एक डैश के साथ शुरू होता है ( -) बाईं ओर, अंतरिक्ष नहीं ( )। यह आवश्यक है।

विवरण

• इनपुट में कभी भी दो Nज़ोन या Pएक पंक्ति में दो ज़ोन नहीं होंगे । जैसे4P5P कभी नहीं होगा।
• आपको एक अग्रणी सकारात्मक संख्या के बिना अक्षरों का समर्थन करने की आवश्यकता नहीं है। सादा Pहमेशा रहेगा 1P, सादा Nहमेशा रहेगा1N ।
• जब तक वे सड़क के अंतिम स्तंभ से आगे नहीं बढ़ जाते, तब तक रिक्त स्थान हो सकते हैं। एक वैकल्पिक अनुगामी न्यूलाइन हो सकती है।
• एक कार्यक्रम के बजाय, आप एक फ़ंक्शन लिख सकते हैं जो रन-लेंथ एन्कोडेड स्ट्रिंग और प्रिंट्स में ले जाता है या एएससीआईआई रोड को लौटाता है।
• किसी भी मानक तरीके से इनपुट लेता है (स्टडिन, कमांड लाइन, फंक्शन आरजी)।

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर पहले की पोस्ट है।

Comments

क्या सड़क को विषम होना चाहिए, या क्या लाइन के प्रत्येक तरफ सड़क के 4 स्थानों को प्रिंट करने की अनुमति है?

— orlp

@orlp यदि आप पूछ रहे हैं कि सड़क 5 पंक्तियों से अधिक चौड़ी हो सकती है, तो नहीं। यदि आप पूछ रहे हैं कि क्या अंतरिक्ष वर्णों को केंद्र रेखा के ऊपर या नीचे खाली लाइनों में रखा जा सकता है, तो हाँ जब तक वे विस्तार की गोली के साथ पकड़ लेते हैं 3.

— केल्विन के

उदाहरण के लिए, मुझे पूछना चाहिए कि क्या इनमें से कोई एक वैध आउटपुट है? gist.github.com/orlp/0e0eae16d6e1fcda5e9b

— orlp

@orlp न तो है।

— केल्विन के

Answer 1

CJam, 38 बाइट्स

"_  - _":N3'=t:P;q~]2/e~z'
*"--"/"- "*

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

हम पहले चर करने के लिए सही सड़क स्तंभ असाइन Nऔर Pऔर फिर बस इनपुट स्ट्रिंग का मूल्यांकन। यह लंबाई की एक जोड़ी और स्टैक पर कॉलम छोड़ देता है। हम उन्हें समूहीकृत करते हैं, पूर्ण स्तंभ प्राप्त करने के लिए उस पर एक RLD चलाते हैं, उनके साथ जुड़ने के लिए स्थानांतरण करते हैं और फिर अंत में, निरंतर --को परिवर्तित करते हैं -।

:_  - _":N                    e# This is the no passing column. We assign it to N
          3'=t:P              e# Replace the '-' in N with '=" and assign it to P
                q~]2/         e# Read the input, evaluate it and then group it in pairs
                     e~       e# Run a run-length-decoder on the pairs
                       z'
*                             e# Transpose and join with new lines.
 "--"/                        e# Split on two continuous occurrence of -
      "- "*                   e# Join by an alternate "- "

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

Answer 2

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

टेम्प्लेट स्ट्रिंग्स का उपयोग करते हुए , 5 लाइनफीड महत्वपूर्ण हैं जिन्हें गिना जाना चाहिए।

f=s=>(b=(s=s.replace(/(\d+)(.)/g,(x,n,b)=>(b<'P'?'=':'- ').repeat(n).slice(0,n))).replace(/./g,'_'))+`


${s}

`+b

Answer 3

rs , 252 chars

हालाँकि यह गिनती नहीं हो सकती है क्योंकि मैंने एक घंटे पहले मार्टिन बोउटनर के रेटिना के रिपॉप के रूप में अभिसरण ऑपरेटर को जोड़ा था ... मैं वास्तव में वैसे भी प्रतिस्पर्धा करने के लिए यहां नहीं हूं। इसके लिए रेगेक्स-आधारित समाधान बनाने में ही मजा है।

(\d+\D)/#\1
+(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)(?=\d*\D)/\1\1\1\1\1\1\1\1\1\1\2\3\4\5\6\7\8\9\10#
\d(?=\d*#N)/=
(^|(?<=\D))\d(?=\d*#P)/-
+(?<=-)\d\d(?=\d*#P)/ -
(?<=-)\d(?=\d*#P)/ 
#\D/
((?:(=|-| ))+)/A\1\n\n\n\1\n\nA\1\n
+(A_*)(.)/\1_
A/

मुझे सालों से प्रोग्रामिंग लैंग्वेज के लिए मार्टिन के रेटिना उत्तर से पंक्ति 2 मिली ।

व्याख्या

(\d+\D)/#\1
+(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)(?=\d*\D)/\1\1\1\1\1\1\1\1\1\1\2\3\4\5\6\7\8\9\10#

यह बहुत जादू करता है। अधिक जानकारी के लिए मैं ऊपर दिए गए उत्तर को देखता हूं।

मूल रूप से, इनपुट के साथ 4N4P9N7P1N1P2N2P, यह परिणाम होगा:

4444#N4444#P999999999#N7777777#P1#N1#P22#N22#P

आगामी:

\d(?=\d*#N)/=

यह समान संकेतों के साथ नो-पासिंग सिंबल (N) से पहले के नंबरों को बदल देता है। पिछले इनपुट के साथ परिणाम:

====#N4444#P=========#N7777777#P=#N1#P==#N22#P

यह:

(^|(?<=\D))\d(?=\d*#P)/-

पहले डैश के साथ पासिंग सिंबल (P) से पहले वाले नंबर को बदल देता है। परिणाम:

====#N-444#P=========#N-777777#P=#N-#P==#N-2#P

अगली दो पंक्तियाँ समान पैटर्न जारी रखती हैं:

+(?<=-)\d\d(?=\d*#P)/ -
(?<=-)\d(?=\d*#P)/ 

पहली पंक्ति डैश-स्पेस पैटर्न के साथ शेष पंक्ति को प्रतिस्थापित करती है। दूसरा एक विषम संख्या को संभालता है; यह अंतिम डैश को एक पूर्णांक (जैसे कि -5) के बाद डैश-स्पेस ( -) के साथ बदल देता है। अब, आउटपुट है:

====#N- - #P=========#N- - - -#P=#N-#P==#N- #P

अब चीजें जगह-जगह गिरने लगी हैं। अगली पंक्ति:

#\D/

बस #Nऔर निकालता है #P।

((?:(=|-| ))+)/A\1\n\n\n\1\n\nA\1\n
+(A_*)(.)/\1_

देने के लिए ऊपर और नीचे पर अंडरस्कोर सेट करें:

A______________________________


====- - =========- - - -=-==- 

A______________________________

अंत में, हम निकालते हैं A:

A/

Answer 4

हास्केल, 165 बाइट्स

k 'N'="="
k _="- "
d c=c>'/'&&c<':'
p[]=[]
p s=take(read$takeWhile d s)(cycle$k a)++p r where(a:r)=dropWhile d s
f s=unlines[q,"\n",p s,"",q]where q=map(\x->'_')$p s

उदाहरण रन ( fएक स्ट्रिंग लौटाता है, इसलिए बेहतर प्रदर्शन के लिए इसे प्रिंट करें):

*Main> putStr $ f "4N4P9N7P1N1P2N2P"
______________________________


====- - =========- - - -=-==- 

______________________________

यह कैसे काम करता है: pइनपुट स्ट्रिंग को फिर से पार्स करके और लुकअप फ़ंक्शन द्वारा दिए गए प्रतीकों की संख्या को संक्षिप्त करके मध्य रेखा लौटाता है k। मुख्य कार्य fनई लाइन के साथ पांच तत्व सूची में शामिल होता है, जिसमें शीर्ष रेखा (मध्य रेखा के हर चार _), एक नई रेखा, मध्य रेखा, एक खाली रेखा और नीचे की रेखा (शीर्ष के समान) शामिल होती है।

Answer 5

पायथन 3, 169 168 बाइट्स। (167 पायथन 2 के साथ)

p,s='',str.split
for _ in s('N '.join(s('P '.join(s(input(),'P')),'N'))):
 v=int(_[:-1]);p+=['='*v,('- '*v)[:v]][_[-1]=='P']
l=len(p)
u='_'*l
print(u+'\n'*3+p+'\n\n'+u)

काफी हद तक असंयमित:

p=''
for i in'N '.join('P '.join(input().split('P')).split('N')).split():

  v=int(i[:-1])         # Get the number from the input section

  if i[-1]=='N':        # Check the letter (last char) from the input section
      p+=('='*v)        # Repeat `=` the number from input (v)
  else:
      p+=('- '*v)[:v]   #Repeat `- ` v times, then take first v chars (half)
l=len(p)                #Get the length of the final line markings
print('_'*l+'\n\n\n'+p+'\n\n'+'_'*l)

---

print('_'*l                          # Print _ repeated the length of p
           +'\n\n\n'                 # 3 new lines
                    +p+              # print out p (the markings)
                       '\n\n'        # 2 new lines
                             +'_'*l) # Print _ repeated the length of p

---

for i in
        'N '.join(
                  'P '.join(
                            input().split('P'))
                                               .split('N'))
                                                           .split():
                            # Split the input into items of list at P
                  # Join together with P and ' '
                                                # Split at N...
         # Join with N and ' '
                                                           # Split at space
# Loop through produced list

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

Comments

आप अपनी बाइट काउंट अपडेट करना भूल गए।

— mbomb007

@ mbomb007 इसने गिनती नहीं बदली: / मैं इसे १६ ९ एटीएम से नीचे नहीं प्राप्त कर सकता

— टिम

लाना p+=['='*v,('- '*v)[:v]][_[-1]=='P']एक पूर्ववर्ती अर्धविराम पिछले पंक्ति के अंत में एक बाइट बचाता है।

— mbomb007

इसके अलावा, पायथन 2 का उपयोग करने के बजाय 1 बाइट बचाता है print।

— mbomb007

@ mbomb007 ने उन्हें :) में जोड़ा है। मुझे लग रहा है कि अजगर 2 है यह और भी छोटा हो सकता है ... लेकिन मुझे यकीन नहीं है।

— टिम

Answer 6

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

हैरानी की बात है, आयात reवास्तव में यहाँ सार्थक लगता है।

import re
s=""
for x,y in re.findall("(\d+)(.)",input()):s+=(("- ","==")[y=="N"]*int(x))[:int(x)]
t="_"*len(s);print t+"\n"*3+s+"\n"*2+t

Answer 7

PHP, 187 बाइट्स

preg_match_all('/(\d+)(\w)/',$argv[1],$m,2);
$o='';
foreach($m as $p)
    $o.=str_replace('--','- ',str_repeat($p[2]<'P'?'=':'-',$p[1]));
$a=preg_replace('/./','_',$o);
echo("$a\n\n\n$o\n\n$a\n");

कोड एक पंक्ति पर रह सकता है; इसे और अधिक पठनीय होने के लिए यहां कई लाइनों पर प्रदर्शित किया गया है (स्वरूपण के लिए उपयोग किए जाने वाले व्हाट्सएप और नएलाइनों की गिनती नहीं की गई थी)।

दो बाइट्स को अनुगामी न्यूलाइन को न प्रिंट करके बचाया जा सकता है। पांच नई बाइट्स को वास्तविक newline वर्णों का उपयोग करके बचाया जा सकता है echo():

echo("$a


$o

$a");

$o( $o='';) के आरंभ को छोड़ कर छह अतिरिक्त बाइट्स को बचाया जा सकता है लेकिन यह एक नोटिस को ट्रिगर करेगा। कमांड लाइन का उपयोग करके स्क्रिप्ट को चलाकर नोटिस को दबाया जा सकता है:

$ php -d error_reporting=0 <script_name> 4N4P9N7P1N1P2N2P

यह इसे 174 बाइट्स में लाता है।

Answer 8

रूबी, 137 135 बाइट्स

कम से कम मैं साथ नहीं आ सकता था, लेकिन सबसे करीब था। ऑप्टिमाइज़र के उत्तर से आंशिक रूप से उधार लिया गया।

require'scanf'
N='_  = _'
P='_  - _'
a=[]
scanf('%d%c'){|l,t|a+=[eval(t).chars]*l}
puts (a.shift.zip(*a).map(&:join)*?\n).gsub'--','- '

Ungolfed:

require 'scanf'

N = '_  = _'
P = '_  - _'
columns = [] # array of columns
# scan stdin for a number followed by a single char
scanf('%d%c') do |length, type|
  columns += [eval(type).chars] * length
done

# Convert to an array of rows, and join into a string
rows = columns.shift.zip(*columns).map(&:join)
str = rows * "\n" # join lines

# Replace '--' by '- ' and print
puts str.gsub(/--/, '- ')

Comments

आपको अंतिम पंक्ति को बदलकर 2 बाइट्स (और अजगर 2 उत्तर को हरा) द्वारा इसे सुधारने में सक्षम होना चाहिए (a.shift.zip(*a).map(&:join)*?\n).gsub'--','- '।

— ब्लुटोरांगे

Answer 9

सी, 155 बाइट्स

main(l,v,k,n,x,s,c)char*s,**v,c;{for(l=6;l--;puts(s))for(s=v[1];*s;s+=k)for(x=sscanf(s,"%d%c%n",&n,&c,&k);n--;)putchar(l%5?l^2?32:c^78?++x&1?45:32:61:95);}

अधिक पठनीय:

main(l,v,k,n,x,s,c)
    char*s,**v,c;
{
    for(l=6;l--;puts(s))
        for(s=v[1];*s;s+=k)
            for(x=sscanf(s,"%d%c%n",&n,&c,&k);n--;)
                putchar(l%5?l^2?32:c^78?++x&1?45:32:61:95);
}

बाहरी लूप 5 से 0 तक की रेखाओं को गिनता है।

मध्य लूप एन्कोडेड स्ट्रिंग के कुछ हिस्सों पर प्रसारित होता है:

4N4P9N7P1N1P2N2P
4P9N7P1N1P2N2P
9N7P1N1P2N2P
7P1N1P2N2P
1N1P2N2P
1P2N2P
2N2P
2P
string is empty - exit

आंतरिक लूप एक भाग को डिकोड करता है, जैसे 7P, और आवश्यक संख्या को पुनरावृत्त करता है (जैसे 7)।

प्रत्येक पुनरावृत्ति एक प्रिंट करता है char। का मान charकोड द्वारा वर्णित है l%5?l^2?32:c^78?++x&1?45:32:61:95:

• यदि पंक्ति संख्या 5 या 0 है, तो 95 प्रिंट करें ( _)
• अन्यथा, यदि पंक्ति संख्या 2 के बराबर नहीं है, तो एक स्थान प्रिंट करें
• अन्यथा, यदि प्रतीक 'एन' है, तो 61 प्रिंट करें ( =)
• अन्यथा, x1 से वृद्धि (इसे 2 से शुरू किया गया था sscanf)
• यदि विषम है, तो प्रिंट 45 ( -), अन्यथा प्रिंट 32 (स्थान)

Answer 10

स्काला, 163 बाइट्स

(s:String)=>{val r=(("\\d+(P|N)"r) findAllIn(s) map(r=>{val l=r.init.toInt;if(r.last=='N')"="*l else ("- "*l).take(l)})).mkString;val k="_"*r.length;s"$k\n\n\n$r\n\n$k"}

पहला प्रयास, कुछ और गोल्फ हो सकता है।

Answer 11

रूबी, 94 बाइट्स

14mRh4X0r के उत्तरgsub'--','- ' से विचार उधार लेता है । मुझे लगता है कि उत्तर अधिक दिलचस्प है, हालांकि, यह कम है।

f=->x{n=?_*x.gsub!(/(\d+)(.)/){($2==?P??-:?=)*$1.to_i}.size
"#{n}


#{x.gsub'--','- '}

#{n}"}

परिक्षण:

f=->x{n=?_*x.gsub!(/(\d+)(.)/){($2==?P??-:?=)*$1.to_i}.size
"#{n}


#{x.gsub'--','- '}

#{n}"}

puts f['4N4P9N7P1N1P2N2P']

पैदा करता है:

______________________________


====- - =========- - - -=-==- 

______________________________

Answer 12

मुझे अपना matlab संस्करण शामिल करने दें

MATLAB (267 बी)

function d=p(V,a),j=numel(V)-1;if (a==0),d=0;return; end,d=(V(a)-48+10*p(V,a-1))*(V(a)<64);fprintf('%c%.*s%c%.*s',(a>=j)*10,(a==j|a==1)*eval(strcat(regexprep(V,'[NP]','+'),48)),ones(99)*'_',(a<3)*10,(V(a+1)>64)*d,repmat((V(a+1)==78)*'=='+(V(a+1)==80)*'- ',[1 99]));end

---

इनपुट

एक ascii- स्वरूपित स्ट्रिंग एक स्थान द्वारा पूंछी जाती है (क्योंकि matlab में श्रृंखला '\ 0' का कोई अंत नहीं है)

उदाहरण V = '12N13P'

---

उत्पादन

सड़क का पैटर्न प्रतिनिधित्व

_________________________


============- - - - - - -

_________________________

समारोह

फ़ंक्शन को इसकी पूंछ -1 से बुलाया जाना चाहिए (खाली वर्ण हटा दिया गया है)

उदाहरण : p (V, numel (V) -1)

सिमुलेशन

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

Answer 13

आर, 132 बाइट्स

इससे बहुत खुश नहीं थे, लेकिन यह करने में बहुत मज़ा आया :) कई gsubएस से छुटकारा पाने की कोशिश की , लेकिन मेरे प्रयास व्यर्थ थे। मुझे संदेह है कि ऐसा करने का एक बेहतर तरीका है।

cat(rbind(nchar(a<-scan(,'',t=gsub('PN','P N',gsub('NP','N P',chartr('- =','PPN',scan(,'',sep='|')[4]))))),substring(a,1,1)),sep='')

• scanSTDIN से तार मिलता है और 4 वें को पकड़ लेता है। ध्यान दें कि इनपुट प्राप्त करने के लिए स्कैन के लिए खाली लाइनों के लिए एक स्थान (या कुछ) की आवश्यकता होती है।

  "==== - - ========= - - - - = - == -"

• यह =s के साथ Ns को बदलता है , -और s के साथ P।

  "NNNNPPPPNNNNNNNNNPPPPPPPNPNNPP"

• फिर यह प्रत्येक NPऔर के बीच एक स्थान सम्मिलित करता हैPN

  "एनएनएनएन पीपीपीपी एनएनएनएनएनएनएनएनएन पीपीपीपीपीपी एनपी एनएन पीपी"

• स्कैन रिक्त स्थान पर स्ट्रिंग को विभाजित करता है

  "एनएनएनएन" "पीपीपीपी" "एनएनएनएनएनएनएनएनएन" "पीपीपीपीपीपीपी" "एन" "पी" "एनएन" "पीपी"

• स्ट्रिंग की लंबाई तब rbindप्रत्येक स्ट्रिंग के पहले वर्ण के साथ बंधी ( ) है

  4 4 9 7 1 1 2 2
  "एन" "पी" "एन" "पी" "एन" "एन" "पी" "एन" "एन"

• सरणी तो उत्पादन का उपयोग कर रहा है cat।

परीक्षण चालन

cat(rbind(nchar(a<-scan(,'',t=gsub('PN','P N',gsub('NP','N P',chartr('- =','PPN',scan(,'',sep='|')[4]))))),substring(a,1,1)),sep='')
1: ____________
2:  
3:  
4: ============
5:  
6: ____________
7: 
Read 6 items
Read 1 item
12N
> 
> cat(rbind(nchar(a<-scan(,'',t=gsub('PN','P N',gsub('NP','N P',chartr('- =','PPN',scan(,'',sep='|')[4]))))),substring(a,1,1)),sep='')
1: ____________
2:  
3:  
4: - - - - - - 
5:  
6: ____________
7: 
Read 6 items
Read 1 item
12P
> cat(rbind(nchar(a<-scan(,'',t=gsub('PN','P N',gsub('NP','N P',chartr('- =','PPN',scan(,'',sep='|')[4]))))),substring(a,1,1)),sep='')
1: ______________________________
2:  
3:  
4: ====- - =========- - - -=-==- 
5:  
6: ______________________________
7: 
Read 6 items
Read 8 items
4N4P9N7P1N1P2N2P