वन पथ

Question

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

वन एक के रूप में वर्णित किया जा सकता nद्वारा n( n > 5पात्रों में से) वर्ग है, जो केवल छोटे अक्षरों से मिलकर बनता है a-z। एक उदाहरण वन:

anehcienwlndm
baneiryeivown
bnabncmxlriru
anhahirrnrauc
riwuafuvocvnc
riwnbaueibnxz
hyirorairener
ruwiiwuauawoe
qnnvcizdaiehr
iefyioeorauvi
quoeuroenraib
cuivoaisdfuae
efoiebnxmcsua

आपने देखा होगा कि इस जंगल में, aऊपर बाएं कोने से नीचे दाएं कोने तक चलने वाले वर्णों की एक विकर्ण रेखा होती है । यह जंगल के माध्यम से एक "रास्ता" है जो आपको कहीं और ले जाएगा यदि आप इसका पालन करते हैं। आपका कार्य एक कार्यक्रम लिखना है जो विलक्षण पथ को खोजेगा। मैं अब और अधिक विशेष रूप से वर्णन करूंगा कि इस चुनौती में एक "पथ" क्या है।

एक "पथ", इस चुनौती में, एक पंक्ति के रूप में परिभाषित किया गया है, जो कि ब्रेसेनहैम एल्गोरिथ्म के साथ उत्पन्न हो सकता है , लेकिन अतिरिक्त आवश्यकताओं के साथ:

• लाइन न्यूनतम 6 वर्णों की होनी चाहिए
• प्रत्येक कोलियरियर (पूरी तरह से समीप) लाइन में वर्णों के समूह की लंबाई समान होनी चाहिए ।
• यह जंगल के एक किनारे पर शुरू होगा और विपरीत किनारे पर समाप्त होगा ( विस्तार के लिए मेरी टिप्पणी यहां देखें )

दूसरी आवश्यकता को अधिक स्पष्ट रूप से समझाने के लिए, निम्नलिखित पंक्ति पर विचार करें:

aaa
   aaa
      aaa
         aaa
            aaa

यह पंक्ति वर्णों के "खंड" खंडों से बनी है, जिनमें से प्रत्येक ठीक तीन वर्ण लंबे हैं। यह एक मार्ग के रूप में योग्य है। अब इस पंक्ति पर विचार करें:

a
 aa
   a
    aa
      a
       aa

यह रेखा कोलिनियर "सेगमेंट" से बनी है जो सभी वर्णों की समान लंबाई नहीं है (उनमें से कुछ 1 वर्ण लंबे हैं और उनमें से कुछ 2 हैं)। इस प्रकार, यह एक मार्ग के रूप में योग्य नहीं है।

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

13  anehcienwlndmbaneiryeivownbnabncmxlriruanhahirrnraucriwuafuvocvncriwnbaueibnxzhyirorairenerruwiiwuauawoeqnnvcizdaiehriefyioeorauviquoeuroenraibcuivoaisdfuaeefoiebnxmcsua

इसके लिए आउटपुट होगा:

a

क्योंकि पथ पत्र का उपयोग करके बनता है a। जंगल में एक ही रास्ता होगा। यह कोड गोल्फ है, इसलिए सबसे कम संख्या में अक्षर जीतते हैं। यदि आपके कोई प्रश्न हैं, तो टिप्पणियों में पूछें।

Comments

यदि कई रास्ते हैं तो क्या होगा?

— एरिक ट्रेसलर 19'14

@ EricTressler किसी भी जंगल में केवल एक ही रास्ता होगा। मैं यह दर्शाने के लिए विनिर्देशन संपादित करूँगा।

— अबिन्थे

क्या पथ पत्र का उपयोग कहीं और किया जा सकता है जहाँ वह पथ से संबंधित नहीं है?

— मार्टिन एंडर

उदाहरण वन में ऐसा संभव है। उदाहरण के जंगल में इस लाइन पर पहले एक रास्ता anhahirrnrauc का हिस्सा नहीं है

— कुदाल

@ मार्टिनबटनर हाँ। लेकिन वे किसी भी बिंदु पर एक ही अक्षर से बने दो रास्ते नहीं होंगे।

— अबिन्थे

Answer 1

APL (Dyalog 14) (70)

⎕ML←3⋄Z/⍨1=≢¨Z←∪¨(↓⍉F),(↓F),{(⍳≢⍵)⌷¨↓⍵}¨(⊂F),⊂⌽F←⊃{⍵⍴⍨2/⍎⍺}/I⊂⍨' '≠I←⍞

स्पष्टीकरण:

• ⎕ML←3: पर सेट MLहै 3, जिसका अर्थ ⊂है उसका APL2 अर्थ।
• I←⍞: कीबोर्ड से एक लाइन पढ़ें और इसे स्टोर करें I
• I⊂⍨' '≠I: Iरिक्त स्थान पर विभाजित
• {... }/: इस फ़ंक्शन को दो परिणामी स्ट्रिंग्स पर लागू करें:
  • 2/⍎⍺: बाईं ओर के तर्क का मूल्यांकन करें और मैट्रिक्स का आकार देते हुए इसे दो बार दोहराएं
  • ⍵⍴⍨: उस आकार का उपयोग करके सही तर्क प्रारूपित करें
• F←⊃: इसे अनबॉक्स करें और इसमें स्टोर करें F।
• {(⍳≢⍵)⌷¨↓⍵}¨(⊂F),⊂⌽F: विकर्ण प्राप्त करें: दोनों में प्रत्येक पंक्ति से Fऔर ⌽F(लंबवत रूप से प्रतिबिंबित F), स्तंभ X पर मान प्राप्त करें, जहां X इसकी संख्या निर्धारित करता है।
• (↓⍉F),(↓F),: की पंक्तियाँ और स्तंभ प्राप्त करें F
• Z←∪¨: प्रत्येक पंक्ति, स्तंभ और विकर्ण पर अद्वितीय मान खोजें और उन्हें संग्रहीत करें Z।

चूंकि 'वन' आयताकार है, अगर कोई वैध रास्ता है तो इसका मतलब है कि इनमें से एक में केवल एक ही पात्र होगा, जो कि पथ वर्ण है, इसलिए:

• Z/⍨1=≢¨Z: इनमें से वे सबरेज़ लें जिनमें Zकेवल एक तत्व हो।

यह सभी मान्य रास्तों के लिए वर्ण प्रदर्शित करेगा, लेकिन चूंकि केवल एक ही होना चाहिए जो कोई फर्क नहीं पड़ता।

Answer 2

लुआ - 506 380 - बाइट्स

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

a=io.read"*l"n=a:match("%d+")+0 m=a:match"[a-z]+"o=""for i=1,n do for k=1,n^2,n do o=o..m:sub(i+k-1,i+k-1)end end q={m,o}for g=1,n^2 do for u=1,2 do l=q[u]:sub(g,g)for r=1,n do i=1 t=0 e=0 while i do s,e=q[u]:find(l:rep(r),e+1)if s then x=s-(e-s)-i-1 print(s,i,r,n,r)if x==n or x==n-2 or t==0 then t=t+1 i=s end else i=nil end end if t*r==n then print(l)os.exit()end end end end

इसके साथ परीक्षण किया जा सकता है:

lua divisorPath.lua "input"

यदि कोई जंगली चैलेंजर दिखाई देता है, तो मैं अपने कोड को गोल्फ के लिए देखूंगा जो इसके लायक है।

अद्यतन : उन लोगों के सम्मान में गोल्फ जो हमारे ऊपर उठेंगे। जब मैं इसके साथ था तब मुझे अपने कोड को दाईं ओर से बाईं ओर जाने वाले मान्यता प्राप्त मार्ग पर ठीक करना था। उफ़।

Answer 3

MATLAB - 270 अक्षर

निम्नलिखित एक फ़ंक्शन को परिभाषित करता है xजो एक वन स्ट्रिंग को एक तर्क के रूप में स्वीकार करता है और दिए गए नियमों के अधीन वन विषय के माध्यम से वैध "पथ" का प्रतिनिधित्व करने वाला चरित्र लौटाता है।

function F=x(s),A=sscanf(s,'%d%s');n=A(1);A=reshape(A(2:end),n,n);for c=A(:)',B=A==c;for i=1:n,if~mod(n,i),C=[kron(eye(i),ones(n/i,1)),zeros(n,n-i)];for j=0:n-i,f=@(B)sum(sum(B&circshift(C,[0,j]))==n;D=fliplr(B);if f(B)|f(B')|f(D)|f(D'),F=char(c);end;end;end;end;end;end

गैर-छोटा संस्करण है

function F = x(s)
    A = sscanf( s, '%d %s' );
    n = A(1);
    A = reshape( A(2:end), n,n );
    for c = A(:)'
        B = A==c;
        for i = 1:n
            if ~mod( n, i )
                C = [kron( eye(i), ones( n/i,1 ) ), zeros( n,n-i )];
                for j = 0:n-i
                    f = @(B) sum(sum( B & circshift( C, [0 j] ))) == n;
                    D = fliplr(B);
                    if f(B) | f(B') | f(D) | f(D')
                        F = char(c);
                    end
                end
            end
        end
    end
end

मूल आधार हर संभव वैध रास्ते के लिए बूलियन मास्क का निर्माण करना है और मैट्रिक्स में किसी भी वर्ण को शामिल करना है जो किसी भी मुखौटा को कवर करता है। इसे पूरा करने के लिए, केवल ऊर्ध्वाधर या शीर्ष-से-नीचे बैकस्लैश के आकार के मुखौटे बनाए जाते हैं, लेकिन सभी चार अभिविन्यासों में वन मैट्रिक्स की तुलना की जाती है: पहचान, फ़्लिप, 90 ° घुमाया गया, 90 ° फ़्लिप किया गया।

फ़ंक्शन किसी भी के लिए चलता है n। इसका एक उदाहरण कमांडलाइन पर लगाया जा रहा है

x('13 anehcienwlndmbaneiryeivownbnabncmxlriruanhahirrnraucriwuafuvocvncriwnbaueibnxzhyirorairenerruwiiwuauawoeqnnvcizdaiehriefyioeorauviquoeuroenraibcuivoaisdfuaeefoiebnxmcsua')

ans =

    a

Answer 4

अजगर - 384 325 275

यह एल्गोरिथ्म मूल रूप से वर्णों के मिलान के लिए मैट्रिक्स की पहली और अंतिम पंक्ति की जांच करता है और फिर प्रत्येक पंक्ति खंड की लंबाई की गणना करता है

012345
------
aaVaaa|0
aaVaaa|1
aaaVaa|2
aaaVaa|3
aaaaVa|4
aaaaVa|5

ऊपर दिए गए उदाहरण में:
पहली पंक्ति में V, अनुक्रमणिका 2 पर है, V पिछली पंक्ति में 4 है।
इसलिए प्रत्येक पंक्ति खंड की लंबाई n = 6 के साथ n / (4-2) +1 = 2 होगी। ।

यह तब जांचता है कि क्या लाइन वैध है।

बाएं से दाएं का रास्ता खोजने के लिए, यह पंक्तियों को स्तंभों के साथ स्वैप करता है और फिर से वही काम करता है।

संपादित करें: 270 तक बहुत कुछ नहीं मिल सकता (लानत है आप अजगर और आपके लानत इंडेंटेशन !!)

n,m=raw_input().split()
n,r=int(n),range
t=r(n)
a=[m[i:i+n]for i in r(0,n*n,n)]
for v in a,["".join([a[i][j]for i in t])for j in t]:
 for i in t:
  for j in t:
   p=1-2*(j-i<0);d,c=p*(j-i)+1,v[0][i]
   if 6<=sum([v[z][i+(z/(n/d))*p*(n%d==0)]==c for z in t])==n:print c;exit()