मैग्रैथिया 2.0 - भवन पर्वत

50

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

पहाड़ों ग्राहक की योजना के अनुसार (उर्फ अंक और डॉट्स के तार) का निर्माण कर रहे हैं और ascii अत्याधुनिक का उपयोग कर वितरित (से मिलकर , /, \, ^और v)।

कार्य

एक पूरा कार्यक्रम लिखें जो इनपुट (एकल स्ट्रिंग) को या तो STDIN से या तर्क और STDOUT को आउटपुट के रूप में लेता है। यह पहेली एक कोड-गोल्फ है इसलिए कृपया गोल्फिंग में कुछ प्रयास करें।

इनपुट

पर्वत श्रृंखला के लिए आधार प्रदान करने वाले बिंदुओं और अंकों की एक स्ट्रिंग। प्रत्येक स्ट्रिंग पहाड़ों को सहारा देने के लिए बिल्कुल आवश्यक है और प्रत्येक चोटी को डॉट के बजाय अंक द्वारा दिया जाता है, जो चोटी की ऊंचाई को दर्शाता है।

उत्पादन

पर्वत श्रृंखला का एक असिसी संस्करण।

  • इनपुट में प्रत्येक अंक बिल्कुल एक चोटी का प्रतिनिधित्व करता है ( ^) अंक द्वारा इंगित ऊंचाई पर (यानी 9 उच्चतम ऊंचाई है)।
  • आउटपुट में अतिरिक्त चोटियां नहीं होनी चाहिए (यानी उन स्थानों पर जहां इनपुट में एक डॉट है)।
  • पर्वत त्रिकोणीय आकार के होते हैं, अर्थात ढलान का उपयोग कर /और \वर्ण बनाए जाते हैं ।
  • गुजरता है जहां चरित्र का उपयोग करते हुए दो पर्वत ओवरलैप के आकार के होते हैं v।
  • न कोई शानदार नई खबरें और न ही खाली लाइनें।
  • अनुगामी स्थानों के साथ पैडिंग लाइनें वैकल्पिक हैं।

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

उदाहरण

पहली पंक्ति इनपुट दिखाती है, अन्य सभी लाइनें वांछित आउटपुट का गठन करती हैं। (वास्तव में पहाड़ यहाँ से मेरे सांत्वना में बहुत अच्छे लगते हैं।)

1
^

11
^^

1.2.
  ^
^/ \

.2.3..
   ^
 ^/ \
/    \

.2..3..
    ^
 ^ / \
/ v   \

...4...3...3..
   ^
  / \  ^   ^ 
 /   \/ \ / \
/        v   \
code-golf  ascii-art 
— हावर्ड
स्रोत
1
कविता और कला का क्या संयोजन! मुझे यह पसंद है।
— devnull
क्या अतिरिक्त newlines ठीक है? दूसरे शब्दों में, के इनपुट के 1लिए \n\n\n\n\n\n\n\n^अनुमति है?
— डुर्रोन 597
@ durron597 आउटपुट में कोई अतिश्योक्ति नहीं होनी चाहिए, उदाहरणों पर एक नज़र रखना चाहिए।
— हावर्ड
अंतरिक्ष पात्रों के बारे में क्या? क्या यह ठीक है अगर सभी लाइनें मूल स्ट्रिंग के समान लंबाई हैं, जो रिक्त स्थान के साथ गद्देदार हैं?
— पॉल प्रेस्टिज
@ क्रॉन हाँ, यह ठीक है।
— हावर्ड

जवाबों:

11

जावास्क्रिप्ट: 272 268 233 232 201 192 189 188 178 180 वर्ण

@Sam को 268 से 233 वर्णों तक कम करने के लिए, और @manatwork के लिए एक और 1 वर्ण के लिए धन्यवाद। बग को इंगित करने के लिए @VadimR

p=prompt(r=t='');s=' ';for(d=10;d--;r=s+q+s,t+=q.trim()?q+'\n':'')for(q='',i=0;i<p.length;)q+=' \\/v^'[p[i++]==d?4:(/\^|\\/.test(r[i-1])+2*/\^|\//.test(r[i+1]))*(r[i]==s)];alert(t)

टिप्पणियों के साथ उचित रूप से पहचाना और कुछ असम्बद्ध संस्करण:

// The output initialization is just a golfing trick suggested by @manatwork.
input = prompt(state = output = '');
space = ' ';

// Repeat for each line, from the top (the highest peak, highest digit) to the floor (digit 1). Start at 10 to avoid a bug.
for (digit = 10; digit--;

      // Update the state of our automaton, at the end of the iteration.
      // Add a space after and before to simplify the future pattern recognization.
      state = space + line + space,

      // Add the line to the output if it is not an empty line, at the end of the iteration.
      output += line.trim() ? q + '\n' : '')
{ // This curly brace was added for readability, it is not in the golfed source.

  // Analyze each character in the current state to produce a new state, like a cellular automaton.
  for (line = '', i = 0; i < input.length;)
  { // This curly brace was added for readability, it is not in the golfed source.
    line +=

        // If the input is the current digit number, evaluate to 4 and put a peak in this character.
        // Otherwise evaluate this expression with those rules:
        // 1 means that the hill is higher only at right in the previous iteration, we do climb it to the right in this one.
        // 2 means that the hill is higher only at left in the previous iteration, we do climb it to the left in this one.
        // 3 means that the hill is higher at both sides in the previous iteration, we are in a v-shaped valley.
        // 0 means nothing to do here. If the middle is not a space, it will be multiplied by 0 and become 0.
        ' \\/v^'[input[i++] == digit ? 4 : (/\^|\\/.test(state[i - 1]) + 2 * /\^|\//.test(state[i + 1])) * (r[i] == space)];
    } // This curly brace was added for readability, it is not in the golfed source.
} // This curly brace was added for readability, it is not in the golfed source.

// Give the final output.
alert(output);

जैसा कि आप कोड से नोट कर सकते हैं, यह सेलुलर ऑटोमेटन के रूप में काम करता है, जहां प्रत्येक कोशिका इनपुट में एक नंबर की जांच करती है, अपने आप को और अपने दो पड़ोसियों को यह तय करने के लिए देखती है कि अगला पुनरावृत्ति क्या होगा। प्रत्येक पल में एक सेल एक हो सकता है ^, /, \, vया । परीक्षण मामलों में प्रदान किया गया इनपुट अपेक्षित आउटपुट का उत्पादन करता है।

ध्यान दें कि alertबॉक्स बेकार का उपयोग कर रहा है, क्योंकि यह सामान्य रूप से एक मोनोस्पेस नहीं है। आप से कॉपी कर सकते हैं और पेस्ट पाठ alertउत्पादन का एक बेहतर सराहना के लिए कहीं और करने के लिए बॉक्स, या आप अंतिम पंक्ति की जगह ले सकती alertद्वारा console.log, लेकिन जब से इस कोड गोल्फ है, alertकम है।

इसके अलावा, यह इनपुट में कुछ भी मान्य नहीं करता है। यह केवल अपरिचित वर्णों को वैसा ही मानता है, जैसा कि यह करता है कि रिक्त स्थान .(वास्तव .में एक अपरिचित वर्ण भी है)।

— विक्टर स्टैफ़ुसा
स्रोत
: वहाँ 1 चरित्र को कम करने के एक पुराने गोल्फ चाल है के रूप में रिक्त स्ट्रिंग के साथ चर प्रारंभ prompt()के पैरामीटर ।
— मैनटवर्क
@manatwork धन्यवाद। किया हुआ।
— विक्टर स्टैफुसा
क्षमा करें, शायद मुझे कुछ याद आ रहा है, लेकिन मुझे एफएफ और क्रोमियम दोनों में लगातार परिणाम मिल रहे हैं। मैं एक ब्राउज़र लॉन्च करता हूं, # 14 संशोधन से जेएस कोड चलाता हूं, और त्रुटि संदेश प्राप्त करता हूं। फिर मैं # 1 संशोधन से कोड चलाता हूं - यह ठीक चलता है। फिर से मैं 14 का कोड चलाता हूं - और कोई त्रुटि संदेश नहीं, यह ठीक चलता है। तो संशोधन # 14 का कोड स्वयं नहीं चलाया जा सकता है?
— user2846289
1
@VadimR धन्यवाद, निश्चित। यह एक विकृत वातावरण के साथ परीक्षण के लिए एक साइड-इफेक्ट था। delete r; delete s; delete q; delete p; delete t; delete i; delete d;यह सुनिश्चित करने के लिए कि इसे पॉलेट नहीं किया गया है , के साथ कोड को उपसर्ग करने की आवश्यकता है ।
— विक्टर स्टैफुसा
q.trim()?q+'\n':''हो सकता है q.trim()&&q+'\n', दो को बचा रहा हो । इसके अलावा, i<p.lengthबस हो सकता है p[i]।
— निकोलस पिपिटोन
6

माणिक, 208 201 189

बहुत मजेदार चुनौती! यहाँ एक वैकल्पिक रूबी समाधान है।

gets.size.times{|x|0.upto(h=$_[x].to_i-1){|d|r=$*[h-d]||=' '*~/$/
[x+d,x-d].map{|o|r[o]=r[o]>?!??v:o<x ??/:?\\if r[o]<?w}
d<1?r[x]=?^:r[x-d+1,w=2*d-1]=?w*w}}
puts$*.reverse.*($/).tr(?w,' ')

एक बोनस के रूप में, यहाँ 162 पात्रों में विक्टर के बहुत ही चतुर "सेल्युलर ऑटोमेटन" एल्गोरिदम का एक रूबी कार्यान्वयन है:

s=gets
9.downto(1){|h|$0=(-1..s.size).map{|x|$_=$0[x,3]
s[x]=="#{h}"??^:~/  [\^\/]/??/:~/[\^\\]  /??\\:~/[\^\\] [\^\/]/??v:' '}*''
$*<<$0[1..-2]if$0=~/\S/}
puts$*

उदाहरण आउटपुट:

....5.....6..6.....
          ^  ^
    ^    / \/ \
   / \  /      \
  /   \/        \
 /               \
/                 \
— पॉल प्रेस्टिज
स्रोत
1
मुझे लगता है कि आप $/न्यूलाइन के लिए उपयोग कर सकते हैं ।
— हॉवर्ड
4

सी # - 588 अक्षर - हालांकि रे के 321 के रूप में अच्छे नहीं हैं!

class P{static void Main(string[] a){char[,] w=new char[a[0].Length+1,10];int x=0;foreach(char c in a[0]){if(c!='.'){int h=int.Parse(c+"");if(w[x,h]=='\0')w[x,h]='^';int s=1;for(int l=h-1;l>0;l--){for(int m=x-s;m<=x+s;m++){if(w[m,l]!='\0'){if(w[m,l]=='^')w[m,l]='/';if(w[m,l]=='\\')w[m,l]='v';}else{if(m==x-s)w[m,l]='/';else if(m==x+s)w[m,l]='\\';else w[m,l]='\0';}bool t=false;for(int f=9;f>0;f--){if(t)w[m,f]='\0';if(w[m,f]!='\0')t=true;}}s++;}}x++;}for(int k=9;k>0;k--){string u="";for(int j=0;j<w.GetLength(0);j++){u+=w[j,k];}if(u.Replace("\0","")!="")System.Console.WriteLine(u);}}}

उदाहरण आउटपुट:

F:\>mountains ".2..3..4..."
       ^
    ^ / \
 ^ / v   \
/ v       \

या अब और अधिक जटिल एक ...

F:\>mountains ".2..3..6.....5...3......1..3..4....2."
       ^
      / \    ^
     /   \  / \               ^
    /     \/   \ ^         ^ / \
 ^ /            v \       / v   \  ^
/ v                \    ^/       \/ \

शानदार पहेली ... जितना आसान लगता है उतना आसान नहीं है ... इसे प्यार करता था!

— user17567
स्रोत
2
"जटिल एक" बीमार है, "3" के लिए कोई चोटी नहीं है।
— user2846289
सभी 3एस वहाँ हैं। यदि आप पहले एक के बारे में बात कर रहे हैं, तो यह ढलान का हिस्सा है।
— हेन वेसल्स
4

एपीएल, 65 बाइट्स

⍉⌽↑⌽¨h↑¨'^/v\'[1+(~×a)×2+×2+/2-/0,0,⍨h←¯1+⊃⌈/a-↓|∘.-⍨⍳⍴a←11|⎕d⍳⍞]

⍞ यह प्रतीक वर्ण सरणी के रूप में कच्चा (मूल्यांकन नहीं किया गया) इनपुट देता है।

एक एपीएल सत्र में, अंतःक्रियात्मक रूप से हल करना:

      s←'...4...3...3..' ⍝ let's use s instead of ⍞
      ⎕d ⍝ the digits
0123456789
      ⎕d⍳s ⍝ the indices of s in ⎕d or 11-s if not found
11 11 11 5 11 11 11 4 11 11 11 4 11 11
      11|⎕d⍳s ⍝ modulo 11, so '.' is 0 instead of 11
0 0 0 5 0 0 0 4 0 0 0 4 0 0
      a←11|⎕d⍳s ⍝ remember it, we'll need it later
      ⍴a ⍝ length of a
14
      ⍳⍴a
1 2 3 4 5 6 7 8 9 10 11 12 13 14
      ⍝ ∘.-    subtraction table
      ⍝ ∘.-⍨A  same as: A ∘.- A
      ⍝ |      absolute value
      |∘.-⍨⍳⍴a
 0  1  2  3 4 5 6 7 8 9 10 11 12 13
 1  0  1  2 3 4 5 6 7 8  9 10 11 12
 2  1  0  1 2 3 4 5 6 7  8  9 10 11
 ...
13 12 11 10 9 8 7 6 5 4  3  2  1  0
      ⍝ ↓      split the above matrix into rows
      ⍝ a-     elements of "a" minus corresponding rows
      ⍝ ⊃⌈/    max them together
      ⊃⌈/a-↓|∘.-⍨⍳⍴a
2 3 4 5 4 3 3 4 3 2 3 4 3 2
      ⍝ This describes the desired landscape,
      ⍝ except that it's a little too high.
      ⍝ Add -1 to correct it:
      ¯1+⊃⌈/a-↓|∘.-⍨⍳⍴a
1 2 3 4 3 2 2 3 2 1 2 3 2 1
      ⍝ Perfect!  Call it "h":
      h←¯1+⊃⌈/a-↓|∘.-⍨⍳⍴a
      0,⍨h ⍝ append a 0 (same as h,0)
1 2 3 4 3 2 2 3 2 1 2 3 2 1 0
      0,0,⍨h ⍝ also prepend a 0
0 1 2 3 4 3 2 2 3 2 1 2 3 2 1 0
      2-/0,0,⍨h ⍝ differences of pairs of consecutive elements
¯1 ¯1 ¯1 ¯1 1 1 0 ¯1 1 1 ¯1 ¯1 1 1 1
      ⍝ this gives us slopes between elements
      2+/2-/0,0,⍨h ⍝ sum pairs: left slope + right slope
¯2 ¯2 ¯2 0 2 1 ¯1 0 2 0 ¯2 0 2 2
      ×2+/2-/0,0,⍨h ⍝ signum of that
¯1 ¯1 ¯1 0 1 1 ¯1 0 1 0 ¯1 0 1 1
      2+×2+/2-/0,0,⍨h ⍝ add 2 to make them suitable for indexing
1 1 1 2 3 3 1 2 3 2 1 2 3 3
      ⍝ Almost ready.  If at this point we replace
      ⍝ 1:/ 2:v 3:\, only the peaks will require fixing.
      ~×a ⍝ not signum of a
1 1 1 0 1 1 1 0 1 1 1 0 1 1
      (~×a)×2+×2+/2-/0,0,⍨h ⍝ replace peaks with 0-s
1 1 1 0 3 3 1 0 3 2 1 0 3 3
      ⍝ Now replace 0:^ 1:/ 2:v 3:\
      ⍝ We can do this by indexing a string with the vector above
      ⍝ (and adding 1 because of stupid 1-based indexing)
      '^/v\'[1+(~×a)×2+×2+/2-/0,0,⍨h]
///^\\/^\v/^\\
      ⍝ Looks like our mountain, only needs to be raised according to h
      r←'^/v\'[1+(~×a)×2+×2+/2-/0,0,⍨h] ⍝ name it for convenience
      h¨↑r ⍝ extend r[i] with spaces to make it h[i] long
 /  /   /    ^     \    \   /   ^    \   v  /   ^    \   \
      ↑⌽¨h¨↑r ⍝ reverse each and mix into a single matrix
/
 /
  /
   ^
  \
 \
 /
  ^
 \
v
 /
  ^
 \
\
      ⍉⌽↑⌽¨h¨↑r ⍝ reverse and transpose to the correct orientation
   ^
  / \  ^   ^
 /   \/ \ / \
/        v   \
— NGN
स्रोत
3

रूबी, 390 अक्षर

वाह, यह एक मुश्किल था।

मैं एक चर का उपयोग कर, हर किरदार के लिए एक नया स्ट्रिंग को संलग्न करने के लिए समाप्त हो गया sहै कि मतलब जो प्रसंस्करण के लिए की जरूरत थी "अगले चरित्र को छोड़" ^और \।

यह आउटपुट परीक्षण के सभी मामलों के लिए दिए गए नमूना आउटपुट के बिल्कुल समान है।

m=[gets.chomp]
a=m[0].scan(/\d/).max.to_i
m[0].gsub!(/./){|n|n==?. ? ' ':a-n.to_i}
s=nil
until a==0
o=''
m[-1].chars{|c|o+=case c
when ?0;?^
when ' ';t=s;s=nil;t ? '':' '
when /\d/;(c.to_i-1).to_s
when ?^;s=1;o.slice! -1;"/ \\"
when ?/;t=s;s=nil;t ? "#{o.slice! -1;' '}":o.slice!(-1)=='\\' ? 'v ':"/ "
when ?\\;s=1;' \\'
when ?v;' '
end}
m.push o
a-=1
end
puts (m[1..-1]*"\n").gsub /\d/,' '

चर का मतलब क्या है:

m | The mountain array.
a | The highest height of a mountain. Used for counting when to stop.
s | Whether or not to skip the next character. 1 for yes, nil for no.
o | Temp string that will be appended to mountain.
t | Temp variable to hold the old value of s.

मुझे यकीन है कि मैं इसे और अधिक नीचे ले जा सकता हूं , लेकिन मुझे अभी जाना है। बाद में सुधार होगा!

— Doorknob
स्रोत
मैं इनपुट से जूझ रहा हूं .2.2.और यह नहीं देख सकता कि यह काम क्यों नहीं करता है।
— हॉवर्ड
2

जावा, 377 407

संपादित करें: @Victor ने बताया कि इसके लिए एक संपूर्ण कार्यक्रम होना चाहिए, इसलिए मैंने इसे संकलित और चलाने योग्य बनाने के लिए कुछ दर्जन पात्रों को जोड़ा। कार्यक्रम को निष्पादित करते समय पहले पैराम के रूप में "खरीद आदेश" पास करें, जैसे:java M ..3.4..6..4.3..

मुझे लगता है कि यह अन्य उत्तरों के लिए आत्मा के समान है, मूल रूप से हर संभव ऊंचाई के लिए बार-बार "पर्वत क्रम" का पता लगाता है, और पहाड़ों को सबसे ऊपर से नीचे बनाता है। इस तरह मुझे केवल चार परिस्थितियों से निपटना है यदि चोटी नहीं बन रही है - या तो एक ढलान '/', नीचे ढलान '\', संयुक्त 'v', या खाली ''। मैं अपने ऊपर-नीचे निर्माण में अपनी वर्तमान स्थिति "ऊपर" केंद्रित तीन स्थानों को देखकर उस सरल को खोज सकता हूं।

ध्यान दें कि अन्य सबमिशन की तरह, मैं एक नंबर के अलावा किसी भी चीज को 'के बराबर' मानता हूं। इनपुट में, संक्षिप्तता के लिए।

गोल्फ संस्करण:

class M{public static void main(String[]m){char[]n=m[0].toCharArray();int e=n.length,h=9,x=-1,p;char[][]o=new char[11][e];char l,r,u;boolean a,b,c;for(;h>=0;h--){for(p=0;p<e;p++){if(n[p]-49==h){o[h][p]=94;if(x==-1)x=h;}else{l=(p>0)?o[h+1][p-1]:0;r=(p<e-1)?o[h+1][p+1]:0;u=o[h+1][p];a=l>91&&l<99;b=r==94||r==47;c=u<33;o[h][p]=(char)((a&&b)?'v':(c&&b)?47:(c&&a)?92:32);}}if(x>=h)System.out.println(o[h]);}}}

मानव पठनीय रूप (और गोल्फ के रूप को प्राप्त करने के लिए कुछ समान संक्रमणीयताओं के बिना):

class Magrathea2 {
    public static void main(String[] mountain) {
        String out = "";
        char[][] output = new char[11][mountain[0].length()];
        int height = 9; int maxheight = -1;
        int position = 0;
        char left,right,up;
        char[] mount = mountain[0].toCharArray();
        for (; height >= 0; height--) {
            for (position=0; position < mount.length; position++) {
                if (mount[position]-49 == height) {
                    output[height][position] = '^';
                    if (maxheight==-1) {
                        maxheight=height;
                    }
                } else { // deal with non-numbers as '.'
                    left=(position>0)?output[height+1][position-1]:0;
                    right=(position<mount.length-1)?output[height+1][position+1]:0;
                    up=output[height+1][position];
                    if ((left=='^'||left=='\\')&&(right=='^'||right=='/')) {
                        output[height][position]='v';
                    } else if ((up==' '||up==0)&&(right=='/'||right=='^')) {
                        output[height][position]='/';
                    } else if ((up==' '||up==0)&&(left=='\\'||left=='^')) {
                        output[height][position]='\\';
                    } else {
                        output[height][position]=' ';
                    }
                }
            }
            if (maxheight >= height) {
                out+=new String(output[height]);
                if (height > 0) {
                    out+="\n";
                }
            }
        }
        System.out.println(out);
    }
}

का आनंद लें।

उदाहरण आउटपुट:

$ java M ..3..4...6...5....1
         ^
        / \  ^
     ^ /   \/ \
  ^ / v        \
 / v            \
/                \^
— ProgrammerDan
स्रोत
प्रश्न में उल्लेख है कि एक पूरा कार्यक्रम लिखें , इसलिए कृपया, लापता को जोड़ें class X{public static void main(String[]z){।
— विक्टर स्टैफुसा
सही पर। मुझे उस वाक्य के अगले भाग - "या तर्क के रूप में" गलत तरीके से समझा गया और पूरा कार्यक्रम भाग से चूक गया। मैं इसे शीघ्र ही अपडेट करूंगा।
— प्रोग्रामरडैन
2

पर्ल 6, 264 224 216 206 200 194 124 बाइट्स

$_=get;my$a=10;((s:g/$a/^/;s:g/\s\.\s/ v /;s:g'\.\s'/ ';s:g/\s\./ \\/;$!=say TR/.1..9/ /;tr'^\\/v' ')if .match(--$a)|$!)xx 9

/// समाधान के रूप में दिखाने के लिए @JoKing का धन्यवाद। यह पर्ल 6 में tr /// बग को ठीक करने के बाद थोड़ा और आगे बढ़ा है।

विकल्प के साथ मेरा मूल समाधान:

my$t=get;for 9...1 {if $t.match($_)|$! {$t=$t.subst($_,'^',:g).subst(' . ',' v ',:g).subst('. ','/ ',:g).subst(' .',' \\',:g);$!=say $t.subst(/<[\.\d]>/,' ',:g);$t.=subst(/<[^\\/v]>/,' ',:g)};}

Ungolfed:

my $t=slurp;
my $s;
for 9...1 {
    if $t.match($_)||$s {                    # match number or latched
        $t=$t.subst($_,'^',:g)               # peaks
        .subst(' . ',' v ',:g)               # troughs
        .subst('. ','/ ',:g)                 # up slope
        .subst(' .',' \\',:g);               # down slope
        $s=say $t.subst(/<[\.\d]>/,' ',:g);  # clean, display, latch
        $t=$t.subst(/<[^\\/v]>/,' ',:g)      # wipe for next line
    }
}

आउटपुट:

...4...3...33..4..4....2.3.22.33.5..22...333.222.3..
                                 ^                  
   ^           ^  ^             / \                 
  / \  ^   ^^ / \/ \     ^    ^^   \     ^^^     ^  
 /   \/ \ /  v      \  ^/ \^^/      ^^  /   \^^^/ \ 
/        v           \/               \/           \
— donaldh
स्रोत
1
मुझे नहीं लगता कि पर्ल को सख्ती से एक मुख्य फ़ंक्शन की आवश्यकता है, प्रवेश बिंदु केवल एक फ़ंक्शन के बाहर पहली चीज हो सकती है।
— निसा
मैंने मुख्य रूप से पैरामीटर हैंडलिंग के लिए उपयोग किया। अब स्टड का उपयोग कर। धन्यवाद।
— डोनाल्ड
एक प्रक्रियात्मक समाधान। मुझे यकीन है कि कोई रेगेक्स और हाइपरॉप्स के साथ बेहतर कर सकता है।
— 9
1
131 बाइट्स का उपयोग कर s///और tr///। मुझे लगता है कि पिछले एक के trबजाय उपयोग कर सकते हैं , sलेकिन मैं बैकस्लैश का अनुवाद करने के लिए काफी समझ नहीं पा रहा हूं। हो सकता है कि पहला भी
— जो किंग
अच्छा काम @JoKing - जब मैंने s /// और TR /// का उपयोग करने की कोशिश की तो मैं एक विषय गड़बड़ कर गया। मैं देखता हूं कि ब्लॉक से बचना ही उत्तर है।
— डोनाल्ड
1

पर्ल, 254 218 212

$s=<>;sub f{9-$i-$_[0]?$":pop}for$i(0..8){$h=1;$_=$s;s!(\.*)(\d?)!$D=($w=length$1)+$h-($2||1);join'',(map{($x=$_-int$D/2)<0?f--$h,'\\':$x?f++$h,'/':$D%2?f--$h,v:f$h,'/'}0..$w-1),$2?f$h=$2,'^':''!ge;print if/\S/}

$s=<>;
sub f{9-$i-$_[0]?$":pop}
for$i(0..8){
    $h=1;
    $_=$s;
    s!(\.*)(\d?)!
        $D=($w=length$1)+$h-($2||1);
        join'',(map{
            ($x=$_-int$D/2)<0
                ?f--$h,'\\'
                :$x
                    ?f++$h,'/'
                    :$D%2
                        ?f--$h,v
                        :f$h,'/'
        }0..$w-1),$2
            ?f$h=$2,'^'
            :''
    !ge;
    print if/\S/
}

संपादित करें: वास्तव में यह प्रोग्रामरडान के ..3..4...6...5....1उदाहरण के साथ काम करने के लिए एक बग-फिक्स है , लेकिन, इस प्रक्रिया में, कुछ बाइट्स बंद थे। और ऑनलाइन टेस्ट: https://ideone.com/P4XpMU

— user2846289
स्रोत
1

सी # - 321 319

using System.Linq;class P{static void Main(string[]p){int h=p[0].Max()-48,i=h,j,n=p[0].Length;char[]A=new char[n+2],B=A;for(;i-->0;){for(j=0;j++<n;){var r=(A[j+1]==47|A[j+1]==94);B[j]=(char)(p[0][j-1]==i+49?94:i+1<h?A[j]==0?(A[j-1]>90&A[j-1]<95)?r?118:92:r?47:0:0:0);}A=(char[])B.Clone();System.Console.WriteLine(B);}}}

असंबद्ध और टिप्पणी:

using System.Linq;

class P
{
    static void Main(string[] p)
    {
        int h = p[0].Max() - 48,    // Getting the height. Codes for 0 to 9 are 48 to 57, so subtract 48 and hope no one will input anything but dots and numbers.
            i = h,
            j,                      // Declaring some iterators here, saves a few chars in loops.
            n = p[0].Length;
        char[] A = new char[n+2],   // Creating an array of char with 2 extra members so as not to check for "index out of bounds" exceptions
               B = A;               // B is referencing the same array as A at this point. A is previous row, B is the next one.
        for (;i-->0;)               // Looping from top to the bottom of the mountain
        {
            for (j = 0; j++ < n;)   // Looping from left to right.
            {
                var r = (A[j + 1] == 47 | A[j + 1] == 94);  // This bool is used twice, so it saves a few characters to make it a variable

                // Here's the logic
                B[j] = (char)(p[0][j - 1] == i + 49 ? 94    // If at this position in the string we have a number, output "^"
                                           : i + 1 < h ?    // And if not, check if we're on the top of the mountain
                                             A[j] == 0 ?    // If we're not at the top, check if the symbol above is a space (0, actually)
                                            (A[j - 1] > 90 & A[j - 1] < 95) ?   // If there's nothing above, we check to see what's to the left ( ^ or \ )
                                             r ?            // And then what's to the right ( ^ or / )
                                             118            // If there are appropriate symbols in both locations, print "v"
                                           : 92             // If there's only a symbol to the left, print "\"
                                           : r              // Otherwise check if there's a symbol to the right, but not to the left
                                           ? 47             // And if there is, print "/"
                                           : 0 : 0 : 0);    // Print nothing if there aren't any symbols above, to the left and to the right,
                                                            // or there's a "^" right above, or we're at the top of the mountain
            }
            A=(char[])B.Clone();    // Clone arrays to iterate over the next line
            System.Console.WriteLine(B);
        }
    }
}

उदाहरण:

C:\>program .2..3..4...
        ^
     ^ / \
  ^ / v   \
 / v       \

मुझे लगता है कि यह प्रत्येक पंक्ति से पहले एक अतिरिक्त स्थान का आउटपुट देता है, हालांकि।

— रे पावर्ड
स्रोत
1

सीजाम, 128 117 112 106 104 बाइट्स

CJam इस चुनौती से थोड़ा छोटा है इसलिए यह जवाब प्रतिस्पर्धा नहीं करता है। हालांकि यह एक बहुत अच्छी चुनौती थी! छोटे से मुझे जे और एपीएल के बारे में पता है, मुझे लगता है कि उन में एक सबमिशन प्रभावशाली रूप से कम होगा।

WlW++"."Waer{_{~U(e>:U}%\W%}2*;W%]z{$W=}%_$W=S*\:L,2-,\f{\_)L=(~"^/ ^^/ \v ^ \\"S/2/@L>3<_$0=f-{=}/t}zN*

यहाँ एक परीक्षण मामला है, जो मुझे लगता है कि ढलान, चोटियों और गर्तों के सभी संभव संयोजन शामिल हैं:

...4...3...33..4..4....2.3.22.33.5..22...333.222.3..

कौन सी पैदावार

                                 ^                  
   ^           ^  ^             / \                 
  / \  ^   ^^ / \/ \     ^    ^/   \     ^^^     ^  
 /   \/ \ /  v      \  ^/ \^^/      \^  /   \^^^/ \ 
/        v           \/               \/           \

इसका परीक्षण यहां करें।

मैं बाद में कोड के लिए स्पष्टीकरण जोड़ूंगा।

— मार्टिन एंडर
स्रोत
1

अजगर, 297 234 218

-63 बाइट्स लाम्बदा
के r=s.replaceबजाय जो किंग -16 बाइट्स के लिए धन्यवाद

s=input()
r=s.replace
q=0
j=''.join
for i in range(9):
 if`9-i`in s or q:q=s=r(`9-i`,'^');s=r(' . ',' v ');s=r('. ','/ ');s=r(' .',' \\');print j([x,' '][x in'0123456789.']for x in s);s=j([x,' '][x in'/\^v']for x in s)

STDIN से इनपुट लेता है। अपंग, सरलीकृत:

s=input() # Take input
r=lambda y,z: s.replace(y,z) # Function for quick s.replace(a, b)
j=lambda x: ''.join(x)
q=0 # Acts like boolean
for i in range(9): # Count to 9
 if `9-i`in s or q: # When digit has been found or found previously (no newlines at start)
  q=s=r(`9-i`,'^') # Digit to ^, set q to non-zero value for always executing from now on
  s=r(' . ',' v ') # ' . ' to ' v '
  s=r('. ','/ ') # '. ' to '/ '
  s=r(' .',' k') # ' .' to 'k'. K is a placeholder, since \\ takes two chars and `[...]`[2::5] fails
  print j([x,' '][x in'0123456789.']for x in s) # Print without '0123456789.'
  s=j([x,' '][x in'/\^v']for x in s) # Wipe (delete '/^\v`)
— डंकन डाइट
स्रोत
— जो किंग
1
हाँ, मैंने s.replaceस्वयं विधि की कोशिश की , लेकिन यह काम नहीं करता है। आप मूल स्ट्रिंग पर केवल प्रतिस्थापन कर रहे हैं क्योंकि तार अपरिवर्तनीय हैं
— जो किंग
0

पॉवर्सशेल, 148 145 बाइट्स

यह एक अच्छी चुनौती है!

param($s)9..1|?{($p+=$s-match$_)}|%{"$_,^; \. , v ;\. ,/ ; \., \;\^|\\|/|v, "-split';'|%{$x=$s-replace'\.|\d',' '
$s=$s-replace($_-split',')}
$x}

कम गोल्फ परीक्षण स्क्रिप्ट:

$f = {

param($s)
9..1|?{($p+=$s-match$_)}|%{      # loop digits form 9 downto 1, execute to the end as soon as a suitable digit met
    $s=$s-replace$_,'^'          # replace current digit with '^'
    $s=$s-replace' \. ',' v '    # replace ' . '  with ' v '
    $s=$s-replace'\. ','/ '      # replace '. ' with '/ '
    $s=$s-replace' \.',' \'      # replace ' .' with ' \'
       $s-replace'\.|\d',' '     # replace all dots and digits with ' ' and push to output. Don't store this replacement
    $s=$s-replace'\^|\\|/|v',' ' # prepeare to the next step: replace ^ \ / and v to space
}

    # Example:
    #     $s="...4...3...3.."
    # 4 : $s="...^...3...3.." output: "   ^          "
    # 4 : $s="... ...3...3.."
    # 3 : $s="../ \..^...^.." output: "  / \  ^   ^  "
    # 3 : $s="..   .. ... .."
    # 2 : $s="./   \/ \./ \." output: " /   \/ \ / \ "
    # 2 : $s=".        .   ."
    # 1 : $s="/        v   \" output: "/        v   \"
    # 1 : $s="              "

}

@(
    ,("1",
      "^")

    ,("11",
      "^^")

    ,("1.2.",
    "  ^ ",
    "^/ \")

    ,(".2.3..",
      "   ^  ",
      " ^/ \ ",
      "/    \")

    ,(".2..3..",
      "    ^  ",
      " ^ / \ ",
      "/ v   \")

    ,("...4...3...3..",
      "   ^          ",
      "  / \  ^   ^  ",
      " /   \/ \ / \ ",
      "/        v   \")

    ,("...4...3...33..4..4....2.3.22.3..5...22...333.222.3..",
      "                                 ^                   ",
      "   ^           ^  ^             / \                  ",
      "  / \  ^   ^^ / \/ \     ^    ^/   \      ^^^     ^  ",
      " /   \/ \ /  v      \  ^/ \^^/      \^^  /   \^^^/ \ ",
      "/        v           \/                \/           \")

    ,(".2..3..6.....5...3......1..3..4....2.",
      "       ^                             ",
      "      / \    ^                       ",
      "     /   \  / \               ^      ",
      "    ^     \/   \ ^         ^ / \     ",
      " ^ /            v \       / v   \  ^ ",
      "/ v                \    ^/       \/ \")
) | % {
    $s,$expected = $_
    $result = &$f $s
    "$result"-eq"$expected"
    $s
    $result
}

आउटपुट:

True
1
^
True
11
^^
True
1.2.
  ^
^/ \
True
.2.3..
   ^
 ^/ \
/    \
True
.2..3..
    ^
 ^ / \
/ v   \
True
...4...3...3..
   ^
  / \  ^   ^
 /   \/ \ / \
/        v   \
True
...4...3...33..4..4....2.3.22.3..5...22...333.222.3..
                                 ^
   ^           ^  ^             / \
  / \  ^   ^^ / \/ \     ^    ^/   \      ^^^     ^
 /   \/ \ /  v      \  ^/ \^^/      \^^  /   \^^^/ \
/        v           \/                \/           \
True
.2..3..6.....5...3......1..3..4....2.
       ^
      / \    ^
     /   \  / \               ^
    ^     \/   \ ^         ^ / \
 ^ /            v \       / v   \  ^
/ v                \    ^/       \/ \
— Mazzy
स्रोत
0

पिप -l , 100 बाइट्स

Y#aZGMXaFi,#aIh:+a@i{(yi--h):4j:0Wh-j&++(yi-++jh-j)(yi+jh-j):2}RV Z(J*y)R`.(?=.*[^0])`0R,6;^" /\v^^"

(भाषा सवाल की तुलना में नई है, लेकिन शायद एपीएल जमा को वैसे भी हरा नहीं सकती है। हालाँकि मुझे उम्मीद है कि यह बहुत कम हो जाएगी।)

कमांड-लाइन तर्क के माध्यम से इनपुट लेता है। इसे ऑनलाइन आज़माएं!

— DLosc
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.