एक छोटे से एक्सप्लोरर

Question

आप एक अनजान दुनिया की मैपिंग करने वाले एक खोजकर्ता हैं। आपके जहाज को हवा पर ले जाया जाता है। यह कहां जाता है, कौन जानता है?

प्रत्येक दिन, आपके गुप्तचरों में, आपको उत्तर, दक्षिण, पूर्व और पश्चिम की विशेषताएं दिखाई देती हैं। आप हमेशा कार्डिनल दिशाओं के अनुरूप चार ऐसी विशेषताएं देखते हैं। आपका स्पाई ग्लास इस तरह से ASCII प्रतीकों की रिपोर्ट करता है:

~~.*, ~~~~, ~.^^,~#~#

प्रतीक क्रम में हैं (उत्तर, दक्षिण, पूर्व, पश्चिम)।

ये प्रतीक हैं: ~= समुद्र, .तट, ^= पहाड़, *= पेड़, #= अवैध (कोई अवलोकन नहीं, यह तब होता है जब भी आप दुनिया के किनारे देखते हैं, या परिदृश्य कोहरे से अस्पष्ट है)। आपका स्पाईग्लास हर दिशा में ठीक एक इकाई को देखता है।

हर रात, आप सितारों को देखते हैं कि आपने कितनी दूर की यात्रा की है। सितारों को देखकर इस तरह से एक आस्की प्रतीक की रिपोर्ट करता है:

n, s, e,w

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

~~.*n~~~~s~~.*s~.**

आपका कार्य दुनिया के 2 डी मानचित्र का उत्पादन करना है (जहां नक्शे के ?अज्ञात भाग हैं, उत्तर ऊपर है, पूर्व सही है):

?~~~??????
?~~~??????
?~~~.^^.??
?~~.***.~~
~~.*^^*.~~
~~~..~~~~~
~~~~~~~~~~
~~~~~~~~~~

सादगी के लिए मान लेते हैं कि आप नक्शे के निचले बाएँ कोने में शुरू करते हैं। मान लें कि सभी नक्शे 8x8 हैं।

यहाँ एक सरल 3x3 उदाहरण है। मान लीजिए कि नक्शा इस प्रकार है:

~.~
~^~
~.~

निम्नलिखित इनपुट के साथ: ~#.#n~~^#s

आपको यह आउटपुट मिलेगा:

~??
~^?
~.?

अधिक उदाहरण इनपुट और आउटपुट:

इनपुट ~#~#n~~~#n~~~#n~~~#n~~~#n~~.#n~~.#n#~~#e#.~~e#.~~e#.~~e#.~~e#~~~e#~~~e#~#~s~~#~s~~#~s~~#~s~~#.s~~#~s~~#~s~##~w~#~~w.#~~w^#~~w.#~~

उत्पादन

~~~~~~~~ 
~....~~~ 
~.????~~ 
~~????~~ 
~~????.~ 
~~????~~ 
~~?.^.~~ 
~~~~~~~~

इनपुट:

~#~#e~#~~e~#~~e.#~~e^#~~n.~..n~^~.n~.~~n.~~.n.~~*n~.~.n#.~~w#.~~w#.~~s~*..s..*.s*~.~s.~~~s

आउटपुट:

?~~~~~?? 
?....~?? 
?.**.~?? 
?~..~~?? 
?~~~~~?? 
?~~..~?? 
~~~.^.?? 
~~~~~~?? 

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक अच्छी पहली चुनौती है। कुछ बातें मेरे लिए अस्पष्ट हैं: हालांकि क्या आउटपुट के सभी प्रतीकों को अलग करना चाहिए? ऐसा लगता है कि उदाहरण आउटपुट में मामला है, लेकिन यह स्पष्ट रूप से कहीं भी नहीं कहा गया है। इसके अलावा, स्टार के निर्देश किस उद्देश्य की पूर्ति करते हैं? मैंने सोचा कि शायद वे नियंत्रित करते हैं कि नक्शे पर प्रतीक कहां जाते हैं, लेकिन उदाहरणों का पालन करते हुए और नीचे बाईं ओर शुरू करते हुए, ऐसा प्रतीत नहीं होता है। क्या आप इसे विस्तार में बताने में सक्षम हैं?

— एलेक्स ए।

आउटपुट को अलग-थलग करने की ज़रूरत नहीं है, यह मेरी ओर से एक त्रुटि है। "#" "कोई अवलोकन नहीं" का प्रतिनिधित्व करता है। वे तब भी होते हैं जब आप नक्शे की सीमा पर होते हैं, लेकिन यादृच्छिक रूप से भी हो सकते हैं।

— user52676

अति उत्कृष्ट। जैसा कि एलेक्स ने कहा, यह एक महान पहली चुनौती है। मैं भविष्य में आपसे और अधिक देखने की उम्मीद करता हूं! :) (FYI करें, सैंडबॉक्स भविष्य की चुनौतियों पर प्रतिक्रिया प्राप्त करने के लिए एक शानदार जगह है।)

— एल'एंडिया स्ट्रैटन

मुझे पहले उदाहरण पर संदेह है (जहां इनपुट है ~#~#n~~~#n~~~#n~~~#n~~~#n~~.#n~~.#n#~~#e#.~~e#.~~e#.~~e#.~~e#~~~e#~~~e#~#~s~~#~s~~#~s~~#~s~~#.s~~#~s~~#~s~##~w~#~~w.#~~w^#~~w) गलत है, और आउटपुट को ??यह कहना चाहिए कि कहां है?.

— लीकी नून

यह एक जादुई हवाई जहाज है ;)

— user52676

Answer 1

MATL , 68 59 58 बाइट्स

'?'7XJQtX"'s'jh5e"@2#1)t35>)-1l8t_4$h9M)b'nsew'=8M*sJ+XJ+(

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

व्याख्या

मानचित्र को ढेर के तल में रखा जाता है और धीरे-धीरे भरा जाता है। एक्सप्लोरर की वर्तमान स्थिति क्लिपबोर्ड जे में संग्रहीत है।

मानचित्र मैट्रिक्स निर्देशांक का उपयोग करता है, इसलिए (1,1) ऊपरी बाएँ है। इसके अलावा, स्तंभ-प्रमुख रैखिक अनुक्रमण का उपयोग किया जाता है। इसका मतलब यह है कि नक्शे का प्रतिनिधित्व करने वाले 8 × 8 मैट्रिक्स के तत्व निम्नानुसार एकल सूचकांक के साथ एक्सेस किए जाते हैं :

1  9 17 25 33 41 49 57
2 10 18 26 34 42 50 58
3 11 19 27 35 43 51 59
4 12 20 28 36 44 52 60
5 13 21 29 37 45 53 61
6 14 22 30 38 46 54 62
7 15 23 31 39 47 55 63
8 16 24 32 40 48 56 64

इसलिए उदाहरण के लिए मैट्रिक्स का तत्व (3,2) रैखिक सूचकांक 11 वाला तत्व है। क्रमशः उत्तर, दक्षिण, पूर्व और पश्चिम की ओर आंदोलन -1, 1, 8 या -8 को रैखिक सूचकांक में जोड़ने से मेल खाता है। सरणी [१ १ array -8] दो अलग-अलग चीजों को एनकोड करने का कार्य करती है:

• खोजकर्ता के संभावित विस्थापन।
• विशेषताओं के सापेक्ष स्थिति, स्पाईग्लास के साथ पाए गए। ये स्थिति खोजकर्ता की वर्तमान स्थिति के सापेक्ष हैं।

इनपुट स्ट्रिंग को 5वर्णों के क्रम में व्यवस्थित किया गया है । चूंकि पहला हिस्सा पहला चरित्र याद कर रहा है (जो कि आंदोलन को इंगित करता है), एक प्रारंभिक sमनमाने ढंग से सभी चूजों को समान आकार बनाने के लिए शामिल किया गया है। इसकी भरपाई करने के लिए, एक्सप्लोरर की स्थिति 7 से शुरू होती है, न कि 8 से, इसलिए दक्षिण का प्रारंभिक विस्थापन (रैखिक सूचकांक में 1 जोड़ें) उन्हें स्थिति 8 पर छोड़ देता है।

5 वर्णों के विखंडन को एक लूप में संसाधित किया जाता है। पहला चरित्र स्थिति को अद्यतन करता है, और शेष 4, यदि भिन्न है #, तो मैट्रिक्स की पर्याप्त प्रविष्टियों में लिखा जाता है जो मानचित्र का प्रतिनिधित्व करता है।

'?'          % push '?'. The map will initially be filled with this
7XJ          % push 7: initial position of the explorer. Copy into clipboard J
Qt           % add 1. Duplicate
X"           % 8x8 matrix containing '?'
'n'jh        % take input string. Prepend 'n'
5e           % reshape into a 5-column matrix
"            % for each column (chunk)
  @          %   push current chunk
  2#1)       %   split chunk into its first char and an array with the other 4
  t35>       %   duplicate. Logical index of chars different than #
  )          %   apply that index to keep characters different than #
  -1l8t_4$h  %   array [-1 1 8 -8]
  9M         %   push logical index again
  )          %   apply that index to keep only relevant relative positions
  b          %   bubble up in stack: move first char of chunk to top
  'nsew'=    %   logical index that tells if that char is 'n', 's', 'e' or 'w'
  8M         %   push array [-1 1 8 -8] again
  *          %   multiply element-wise. Only one of the four results will be nonzero
  s          %   sum of the array. Gives displacement of the explorer
  J+         %   push position of the explorer and add to compute new position
  XJ         %   update position in clipboard J
  +          %   add updated position of explorer to relative positions of features
  (          %   write those fearttures into the indexed entries of the map
             % end for each. Implicitly display

Comments

यह एक चतुर चाल है! मैं यह देखने के लिए कुछ कार्यक्रमों के खिलाफ आपके कार्यक्रम का परीक्षण करूंगा कि क्या यह मेरी अपेक्षा है।

— user52676

Answer 2

सी, 210 208 207 बाइट्स

यह एक इनपुट पढ़ने के लिए प्रिंटफ और स्कैनफ का उपयोग करता है, और एक्स, वाई के बजाय एक रैखिक सरणी; इसलिए मुझे लगता है कि यह मिलीबाइट से काफी अलग है ।

golfed:

 main(p){char*i,*j,m[80];for(p=73,i=m+p;p--;m[p]=63);for(p=8;scanf("%5s",i)>0;p+=*j=='n'?8:*j=='s'?-8:*j=='e'?1:-1)for(j=i;j-i<4;j++)if(*j^35)m[p+"qajh"[j-i]-'i']=*j;for(p=72;m[p]=0,p-=8;)printf("%s\n",m+p);}

कुछ हद तक-ungolfed:

main(p){
    char*i,*j,m[80];
    for(p=73,i=m+p;p--;m[p]=63);                   // fill with ?
    for(p=8;scanf("%5s",i)>0;
            p+=*j=='n'?8:*j=='s'?-8:*j=='e'?1:-1)  // read 5-at-a-time
        for(j=i;j-i<4;j++)
            if(*j^35)m[p+"qajh"[j-i]-'i']=*j;      // update map positions
    for(p=72;m[p]=0,p-=8;)printf("%s\n",m+p);      // output line-by-line
}

प्रतिनिधित्व:

  // board: (vertically reversed when printed)
    0  1  2  3  4  5  6  7
    8  9  10 ...
    16 18 19 ...
    ...
    56 57 58 59 60 61 62 63

  // offsets and offset order, or why "qajh": 
    s2      -8       a
  w4  e3  -1 0+1   h i j
    n1      +8       q   <- offset by +'i'

इसके अलावा, आप 8 की स्थिति पर शुरू करते हैं क्योंकि यह प्रिंट-लूप को बंद करता है।

Answer 3

फोरट्रान, 263 251 247 235 234 216 बाइट्स

1D संस्करण (डॉन मूसली के समान):

#define R read(*,'(a)',advance='no',eor=1)c
#define F(x)R;if(c/='#')a(x+i)=c
program t
character::a(64)='?',c
integer::k(4)=[8,-8,1,-1],i=57
do
F(-8)
F(8)
F(1)
F(-1)
R
i=i+k(index('snew',c))
enddo
1 print'(8a)',a
end

2 डी संस्करण:

#define R read(*,'(a)',advance='no',eor=1)c
#define F(x,y)R;if(c/='#')a(x+m,y+l)=c
#define G(x,y)j=index(x,c);if(j==2)j=-1;y=y+j
program t
character::a(8,8)='?',c
l=8;m=1
do
F(,-1)
F(,1)
F(1,)
F(-1,)
R
G('sn',l)
G('ew',m)
enddo
1 print'(8a)',a
end

मुक्त रूप और पूर्व-प्रसंस्करण को सक्षम करने के लिए, फ़ाइल को एक्सटेंशन की आवश्यकता होती है .F90, जैसे explorer.F90। इनपुट STDIN से पढ़ा जाता है:

echo "~#~#e~#~~e~#~~e.#~~e^#~~n.~..n~^~.n~.~~n.~~.n.~~*n~.~.n#.~~w#.~~w#.~~s~*..s..*.s*~.~s.~~~s" | ./a.out 
?~~~~~??
?....~??
?.**.~??
?~..~~??
?~~~~~??
??~..~??
~~~.^.??
~~~~~~??

Comments

तो क्या फोरट्रान में भी रैखिक अनुक्रमण है?

— लुइस मेन्डो

@DonMuesli नहीं, वास्तव में नहीं। मैं सीधे 1D सरणी पर काम कर रहा हूं। वर्णों के सरणी को मुद्रित करने के लिए, मैं इस तथ्य का उपयोग कर रहा हूं कि सरणी को स्मृति में संचित रूप से संग्रहीत किया गया है।

— अलेक्जेंडर वोग्ट

Answer 4

सी, 265 226 224 बाइट्स

a[8][8];x;y;i;main(c){for(;c=getchar(),c+1;y+=(c=='n')-(c=='s'),x+=(c=='e')-(c=='w'))for(i=5;--i;c=getchar())i&&c-35&&(a[x+(i==2)-(i==1)][y-(i==3)+(i==4)]=c);for(y=8;y--;putchar(10))for(x=0;x<8;)putchar((i=a[x++][y])?i:63);}

नक्शा 8x8 है, मैंने पहले ऐसा नहीं देखा था। और यहां 265 बाइट्स समाधान है जो चर आयामों के साथ नक्शे के लिए काम करता है:

a[99][99];c;x;X;y;i;k;p;main(Y){for(;c=getchar(),c+1;y+=(c=='n')-(c=='s'),x+=(c=='e')-(c=='w'))for(i=5;--i;c=getchar())i&&c-35&&(a[k=x+(i==2)-(i==1),X=X<k?k:X,k][p=y-(i==3)+(i==4),Y=Y<p?p:Y,p]=c);for(y=Y+1;y--;putchar(10))for(x=0;x<=X;)putchar((i=a[x++][y])?i:63);}

Comments

a[8][8]पर्याप्त नहीं होना चाहिए ?

— अलेक्जेंडर वोग्ट

@ अलेक्सेंडर वोग्ट - ओह, सही है! धन्यवाद, यह दो और बाइट्स को कम करता है।

— mIllIbyte

मुझे वास्तव में पसंद है कि आप एक्स और वाई के लिए वेतन वृद्धि / गिरावट की गणना कैसे करते हैं। हमारे सी कोड की तुलना में, स्थैतिक int a[8][8]आपको मुफ्त मैप इनिशियलाइज़ेशन मिलता है, और चार का उपयोग करने से m[64]मुझे मैप आउटपुट के लिए महान छूट मिलती है। वास्तव में करीबी मायने रखता है, हालांकि

— tucuxi

यदि आप रिवर्स eऔर wअपने मैप प्रतिनिधित्व में हैं, तो आप for(x=8;x--;)putchar((i=a[x][y])?i:63)आउटपुट पर दो बाइट्स शेव करने के लिए उपयोग कर सकते हैं ।

— tucuxi

के c=getchar(),c+1बराबर नहीं है getchar(),c++या इसमें कुछ प्रवंचना शामिल है?

— जोनाथन फ्रीच

Answer 5

रूबी, 169 147 बाइट्स

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

सभी तारों को एक में डालकर और फिर बाद में उन्हें विभाजित करके एक टन की छंटनी की।

m=??*64
d=0
x=56
gets.each_char{|c|d<4?(w=x+(d>2?-1:d>1?1:d<1?-8:d<2?8:0)
m[w]=c if c>?$):x+=c>?v?-1:c<?f?1:c>?q?8:-8
d+=1;d%=5}
puts m.scan /.{8}/

Ungolfed:

m = ?? * 64                 # 64 "?" symbols
                            # y axis counts downwards; 0-7 is top row
d = 0                       # Keep track of which direction we're looking
x = 56                      # Position, bottom left corner (0,7)
gets.each_char do |c|       # For each character from first line of STDIN
    if d < 4                # Looking in a direction
        if    d > 2         # d == 3; looking west
            w = x - 1
        elsif d > 1         # d == 2; looking east
            w = x + 1
        elsif d < 1         # d == 0; looking north
            w = x - 8
        else                # d == 1; looking south
            w = x + 8
        end
        m[w] = c if c > ?$  # Only '#' gets rejected by this step
    else                    # Moving in a direction
        if    c > ?v        # c == 'w'
            x -= 1
        elsif c < ?f        # c == 'e'
            x += 1
        elsif c > ?q        # c == 's'
            x += 8
        else                # c == 'n'
            x -= 8
        end
    end
    d = (d + 1) % 5         # Look in the next direction
end
puts m.scan /.{8}/          # Split map into rows of 8

Answer 6

लुआ, 354 बाइट्स ( इसे ऑनलाइन आज़माएं )

golfed:

n=(...)r={}y=8x=1q="?"for i=1,8 do r[i]={q,q,q,q,q,q,q,q}end for u in n:gsub("#",q):gmatch(".....")do a,b,c,d,e=u:match("(.)(.)(.)(.)(.)")if a~=q then r[y-1][x]=a end if b~=q then r[y+1][x]=b end if c~=q then r[y][x+1]=c end if d~=q then r[y][x-1]=d end y=y+(("n s"):find(e)or 2)-2x=x+(("w e"):find(e)or 2)-2 end for i=1,8 do print(table.concat(r[i]))end

थोड़ा अपराजित:

n = "~#~#e~#~~e~#~~e.#~~e^#~~n.~..n~^~.n~.~~n.~~.n.~~*n~.~.n#.~~w#.~~w#.~~s~*..s..*.s*~.~s.~~~s"

r={} y=8 x=1 q="?"
for i=1,8 do r[i]={q,q,q,q,q,q,q,q} end
for u in n:gsub("#",q):gmatch(".....") do
  a,b,c,d,e=u:match("(.)(.)(.)(.)(.)")
  if a~=q then r[y-1][x]=a end
  if b~=q then r[y+1][x]=b end
  if c~=q then r[y][x+1]=c end
  if d~=q then r[y][x-1]=d end
  y=y+(("n s"):find(e)or 2)-2
  x=x+(("w e"):find(e)or 2)-2
end
for i=1,8 do print(table.concat(r[i])) end

Comments

कर सकते हैं x=x+(("w e"):find(e)or 2)-2 endनहीं हो x=x-2+(("w e"):find(e)or 2)end?

— जोनाथन फ्रीच

Answer 7

कोटलिन, 242 बाइट्स

{val m=Array(8){Array(8){'?'}}
var d=7
var i=0
for(c in it)(mapOf('n' to{d--},'s' to{d++},'w' to{d-=8},'e' to{d+=8},'#' to{i++})[c]?:{m[d%8+listOf(-1,1,0,0)[i%4]][d/8+listOf(0,0,1,-1)[i%4]]=c
i++})()
m.forEach{for(c in it)print(c);println()}}

यदि वांछित हो तो नई सूचियों को अर्धविराम से प्रतिस्थापित किया जा सकता है।

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