परिचय

Sisyphus को हाल ही में काम में कुछ परेशानी हो रही थी। ऐसा लगता है कि वह कभी भी कुछ भी नहीं करता है, और वह इस समस्या का समाधान खोजना पसंद करेगा।

उनके वर्तमान रोजगार के लिए एक पहाड़ी पर एक चट्टान को रोल करने की आवश्यकता है। वह आमतौर पर अपना काम अच्छी तरह से करता है, लेकिन हर बार जब वह पहाड़ी की चोटी के पास होता है तो वह फिर से लुढ़क जाता है।

वह वास्तव में अपनी नौकरी से निराश हो रहा है और पहाड़ी पर लुढ़कते हुए कंप्यूटर का अनुकरण करते हुए वैज्ञानिक रूप से समस्या को हल करना चाहता है।

ऐसा होता है कि Sisyphus प्रोग्रामिंग में विशेष रूप से अच्छा नहीं है, इसलिए शायद आप उसकी मदद कर सकते हैं?

चुनौती

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

#o        
##
###
######
########

जहां #पहाड़ी के एक हिस्से का oप्रतिनिधित्व करता है और चट्टान का प्रतिनिधित्व करता है।

अब आपको एक प्रोग्राम लागू करना होगा जो रॉक 1 लेयर को नीचे ले जाए। उदाहरण के लिए, ऊपर का आउटपुट होना चाहिए:

#        
##o
###
######
########

यदि वहाँ एक क्षैतिज रूप से भी क्षेत्र है, तो पहाड़ी क्षैतिज रूप से लुढ़कती है, इसलिए ...

o
########

... यह सिर्फ पत्थर के रोल को बग़ल में बना देगा।

 o
########

यदि एक ऊर्ध्वाधर क्षेत्र है, तो चट्टान एक कदम नीचे गिरती है, इसलिए ...

#o
#
#
#####

... उपज होगी ...

#
#o
#
#####

आपको छवि की चौड़ाई और ऊंचाई क्रमशः छवि के ऊपर एक पंक्ति में भी प्राप्त होगी। तो, पूरा, हमारे नमूना इनपुट इस तरह दिखेगा:

10 5
#o        
##        
###       
######    
#########

(ध्यान दें कि यहां व्हाट्सएप स्पेस है। टेक्स्ट का चयन करें और देखें कि मेरा क्या मतलब है।)

कुछ विवरण

जब प्रोग्राम चलाने के दौरान रॉक पहले से ही अंतिम पंक्ति में है, तो आप प्रोग्राम को समाप्त करने का विकल्प चुन सकते हैं या अपरिवर्तित इनपुट का उत्पादन कर सकते हैं
पहाड़ी केवल नीचे की ओर जाती है
आपके प्रोग्राम को आउटपुट को बिल्कुल उसी तरह प्रारूपित करना चाहिए जैसे इनपुट (आयामों सहित), इसलिए यदि आप प्रोग्राम के आउटपुट को स्वयं पाइप करते हैं, तो यह अगले चरण की गणना करता है।
आप मान सकते हैं कि हमेशा नीचे की ओर एक रास्ता है, इसलिए इनपुट जहां पथ "अवरुद्ध" है अपरिभाषित व्यवहार का कारण बन सकता है
आप मान सकते हैं कि अंतिम पंक्ति में हमेशा एक स्थान होता है। चट्टान को वहां "आराम" करना चाहिए, इसलिए कार्यक्रम को कुछ बार कॉल करने के बाद, हमेशा इसे अपने आप में आउटपुट करना, आपको अंतिम पंक्ति में रॉक के साथ समाप्त होना चाहिए, जहां पहले स्थान था।
आप किसी भी रूप में इनपुट स्वीकार कर सकते हैं, जैसे (स्टडिन, फ़ाइल, ...)। आपको WHOLE प्रोग्राम (इसलिए सभी प्री-इनिशियलाइज्ड वैरिएबल काउंट को कोड के रूप में पोस्ट करना होगा)।
लाइनों के साथ समाप्त कर रहे हैं \n।
आप यहां कुछ उदाहरण इनपुट प्राप्त कर सकते हैं (सुनिश्चित करें कि आप रिक्त स्थान को सही ढंग से कॉपी कर रहे हैं!)
यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ काम करने वाला सबमिशन ।
विजेता को 26 जुलाई 2014 को चुना जाएगा। आप उसके बाद समाधान पोस्ट कर सकते हैं, लेकिन आप जीत नहीं सकते

यदि आपके कोई प्रश्न हैं, तो मुझे टिप्पणियों में बताएं।

हैप्पी गोल्फिंग!

code-golf

— क्रिस्टोफ़ बोहमलडर
स्रोत

क्या आपके अंतिम उदाहरण में व्हॉट्सएप का एक अनुगामी स्तंभ होगा? (क्योंकि अन्य के पास नहीं है)

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

@ m.buettner अंतिम उदाहरण में केवल 9 #s हैं, इसलिए अंत में एक स्थान है क्योंकि चौड़ाई 10. है। इस मामले में (कुछ पुनरावृत्तियों के बाद) चट्टान जहां व्हॉट्सऐप है (वहां सबसे नीचे होगा) -दांया कोना)।

— क्रिस्टोफ बोहमवल्डर

हां, मुझे एहसास है कि, मैं सोच रहा था कि क्या हम यह मान सकते हैं कि हमेशा ऐसा ही होता है, क्योंकि यह आपके अन्य उदाहरणों के लिए नहीं है। (यह कहा जा रहा है, आपके अन्य उदाहरणों में किसी भी तरह के व्हाट्सएप का स्थान नहीं है।)

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

6

इसे "रॉक एंड रोल" कहने के लिए एक शानदार मौका याद आया

— qwr

1

@HackerCow तुम सही हो। एक चरित्र को हटाकर फिक्स्ड: डी

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

35

रेगेक्स (.NET, पर्ल, पीसीआरई, जावास्क्रिप्ट, ... फ्लेवर), 25 बाइट्स

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

तो यहाँ एक शुद्ध रेगेक्स प्रतिस्थापन समाधान है।

पैटर्न (अनुगामी स्थान पर ध्यान दें):

o(( *)\n#*)(?=\2) |o

प्रतिस्थापन (प्रमुख स्थान पर ध्यान दें):

$1o

बाइट की गिनती दो के योग के लिए है।

आप इसे http://regexhero.net/tester/ पर देख सकते हैं । चिपकाने के दौरान यूनिक्स-स्टाइल लाइन एंडिंग्स और "पास्टर्ड फॉर्मेटिंग को संरक्षित करें" चुनना सुनिश्चित करें। यदि यह अभी भी काम नहीं करता है, तो आपने अभी भी विंडोज-स्टाइल लाइन एंडिंग्स चिपकाया है। उस मामले में सबसे आसान फिक्स को बदलना है\n\r\n यह है कि यह काम करता है देखने के लिए पैटर्न के साथ करना है।

यहाँ एक 48 बाइट ECMAScript 6 फ़ंक्शन का उपयोग किया गया है

f=(s)=>s.replace(/o(( *)\n#*)(?=\2) |o /,' $1o')

अंत में, मुझे एक वास्तविक कार्यक्रम भी मिला है। यह पर्ल के 31 बाइट्स हैं ( झंडे के लिए दो बाइट्स pऔर 0सुझाव के लिए वेंटरो के लिए धन्यवाद!)।

s/o(( *)\n#*)(?=\2) |o / $1o/

यदि आप इसका परीक्षण करना चाहते हैं, तो इसे किसी फ़ाइल में सेव भी न करें, बस करें

perl -p0e 's/o(( *)\n#*)(?=\2) |o / $1o/' < hill.txt

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

दुर्भाग्य से मेरे लिए काम नहीं करता है (ऑनलाइन परीक्षक में)। यह हमेशा चट्टान को दाईं ओर ले जाता है। 40 बाइट्स एक शानदार शुरुआत है, हालांकि, इसे हराना मुश्किल होगा!

— क्रिस्टोफ़ बोम्हवालडर

@HackerCow तुम सही हो, मैंने देखा कि वहाँ एक समस्या है। फिक्सिंग ...

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

@HackerCow नहीं मुझे नहीं लगता कि यह वास्तव में काम करता है, लेकिन "संरूपण को संरक्षित करना" समाप्त होने वाली रेखा को ओवरराइट करता है, इसलिए यदि आप विंडोज-शैली की लाइन को समाप्त करते हैं तो यह काम नहीं करता है ( \nसाथ बदलने की कोशिश करें \r\n)

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

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

— ब्रूनोज

4

मैं इसे कैसे हराऊंगा? महान समाधान

— qwr

3

अजगर - 190

स्लाइसिंग और कंसेंट्रेशन हॉरर, साथ ही बहुत सारे वैरिएबल। मुझे यकीन है कि यह अधिक गोल्फ हो सकता है, लेकिन मैं अभी किसी भी चतुर अजगर कार्यों के बारे में नहीं सोच सकता। इनपुट स्ट्रिंग में संग्रहीत है s।

r=" "
o="o"
i=s.index(o)
b=i+int(s.split(r)[1])
q=s[:i]+r
x=s[b+3:]
try:
 a=s[b+1:b+3]
 if a[0]==r:s=q+s[i+1:b+1]+o+r+x
 elif a[1]==r:s=q+s[i+1:b+2]+o+x
 else:s=q+o+s[i+2:]
except:1
print(s)

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

— qwr
स्रोत

3

मेरी आंखों में चोट लगी। +1

— क्रिस्टोफ़ बोहमवल्डर

2

रूबी, 65/55 वर्ण

मुझे लगता है कि मैं एक समाधान है कि समस्या पर एक regex फेंक नहीं है कितनी देर तक देखना होगा।

r=gets p
r[r[(r[k=1+~/o/+x=r.to_i,2]=~/ /||-x)+k]&&=?o]=" "
$><<r

जैसी कि उम्मीद थी, यह m.buettner's regex solution जितना छोटा नहीं है - लेकिन यह अधिक लंबा भी नहीं है।

दुभाषिया झंडे का उपयोग करते समय, इसे 55 वर्णों (कोड के लिए 53, झंडे के लिए 2) के लिए छोटा किया जा सकता है:

sub$_[($_[k=1+~/o/+x=$_.to_i,2]=~/ /||-x)+k]&&=?o," "

कोड इस तरह से चलाएं:

ruby -p0e 'sub$_[($_[k=1+~/o/+x=$_.to_i,2]=~/ /||-x)+k]&&=?o," "' < input

— Ventero
स्रोत

2

HTML जावास्क्रिप्ट - 251 वर्ण

( 251 आप एकल उद्धरण है कि इनपुट पढ़ता है और उत्पादन। रिटर्न के अंदर कोड गिनती करता है, तो 359 अगर आप इनपुट बॉक्स, इनपुट स्ट्रिंग, बटन, आदि गिनती 192 अगर आप सिर्फ काम करता है कि गिनती।)

गोल्फ कोड:

<pre id="i">10 5
#o        
##        
##        
######    
######### </pre><button onclick='i=document.getElementById("i");h=i.innerHTML;if(p=h.
match(/([\s\S]*?)([# ]+)(o *\n)(#+)([\s\S]*)/)){if(p[4].length>p[2].length+1)p[3]=p[3].
replace("o "," o");else{p[3]=p[3].replace("o"," ");p[5]="o"+p[5].substr(1);}p[0]="";
h=p.join("");}i.innerHTML=h;'>Go</button>

http://goo.gl/R8nOIK
बार-बार "गो" पर क्लिक करें
"गो" पर बार-बार क्लिक करें।

तरीका

मैं 5 भागों में पहाड़ी को तोड़ने के लिए String.match () का उपयोग करता हूं, फिर मैं एक या दो भागों को बदलता हूं। मैं जावास्क्रिप्ट सीख रहा हूं, इसलिए किसी भी सुझाव की सराहना की जाएगी।

पठनीय संहिता

<pre id="io">10 5
#o        
##        
##        
######    
######### </pre>

<button onclick='

    // get image
    io = document.getElementById("io");
    image = io.innerHTML;

    // break image into five parts
    // 1(10 5\n#         \n##        \n) 2(### ) 3(o     \n) 4(######) 5(    \n######### )
    if (parts = image.match(/([\s\S]*?)([# ]+)(o *\n)(#+)([\s\S]*)/)) {

        // move rock to the right
        if (parts[4].length > parts[2].length + 1)
            parts[3] = parts[3].replace("o ", " o");

        // or move rock down
        else {
            parts[3] = parts[3].replace("o", " ");
            parts[5] = "o" + parts[5].substr(1);
        }

        // return new image
        parts[0] = "";
        image = parts.join("");

        // MAP io:i image:h parts:p
    }
    io.innerHTML = image;
'>Go</button>

— JeffSB
स्रोत

1

अजगर 2 - 289 252 बाइट्स

p=raw_input
w,h=map(int,p().split())
m=[p()for a in[0]*h]
j=''.join
f=lambda s:s.replace('o ',' o')
for i,r in enumerate(m):
 x=r.find('o')
 if x+1:y=i;break
if m[y+1][x]=='#':m=map(f,m);x+=1
print w,h
print'\n'.join(map(j,zip(*map(f,map(j,zip(*m))))))

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

पहले, मैं चट्टान को ढूँढता हूँ। यदि चरित्र इसके तुरंत नीचे है'#' , तो हर उदाहरण को प्रतिस्थापित 'o 'करें ' o'। चूंकि अंत में एक अतिरिक्त स्थान होने की गारंटी है, यह हमेशा चट्टान को दाईं ओर ले जाएगा।

भले ही मैंने बस ऐसा किया हो या नहीं, मैं पूरे ग्रिड को स्थानांतरित करता हूं zip(*m)। फिर, मैं के 'o 'साथ एक और प्रतिस्थापन करते हैं ' o'। यदि चट्टान के दाईं ओर एक स्थान है, तो इसका मतलब है कि असली ग्रिड में इसके नीचे एक स्थान है, इसलिए यह स्थानांतरित हो जाता है। फिर मैं वापस प्रिंट करता हूं।

— undergroundmonorail
स्रोत

क्या यह ओपी के तीसरे उदाहरण को गड़बड़ नहीं करेगा, जहां चट्टान के नीचे और नीचे खाली जगह है, और इसे तिरछे तरीके से स्थानांतरित करें?

— दरवाज़े

@ ऐसा नहीं होना चाहिए। यदि नीचे दी गई जगह है #, तो मैं केवल दाईं ओर जाता हूं, और जब मैं लंबित स्थानांतरित करने के लिए जांच करता हूं, तो मैं वह जांच करता हूं।

— भूमिगत

1

पायथन (201)

import sys
print(input())
g=list(sys.stdin.read())
o='o'
x=g.index(o)
n=x+g.index('\n')+1
try:
 if g[n]==' ':g[n]=o
 elif g[n+1]==' ':g[n+1]=o
 else:g[x+1]=o
 g[x]=' '
except:1
print(*g,sep='',end='')

— इयान डी। स्कॉट
स्रोत

1

awk, 152

awk 'NR==1{w=$2}{if(NR<=w&&$0~/o/){r=index($0,"o");g=$0;getline;if(index($0,"# ")<=r){sub("o"," ",g);sub(" ","o")}else{sub("o "," o",g)}print g}print}'

अधिक पठनीय

    awk '
  NR==1{  //If we're at the first line, set the width from the second column in the header.
    width=$2
  }
  {
    if(NR<=width && $0~/o/){   //If not at the bottom, look for the line with the rock.
      rockIndex=index($0,"o"); //Set the position of the rock.
      orig=$0;                 //Remember the current line so we can compare it to the next.
      getline;                 //Get the next line.

      if(index($0,"# ")<= rockIndex){  //Move down: if the rock is on a cliff or on a slope,
        sub("o"," ",orig);             //update the orig so that the rock is removed
        sub(" ", "o")                  //and update the current (first available position).
      }                                         
      else {                           //Move right: if the rock is on flat ground,
        sub("o "," o", orig)           //update the orig so the the rock is advanced.
      }
      print orig                       //Print the line we skipped (but stored      
    }                                  //and updated based on the line we're now on).
    print                              //Print the line we're now on.
  }
'

— जूलियन पीटर्स
स्रोत

0

php 485 484 चार्ट

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

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

यहाँ मेरा कोड है: इनपुट पहले चर में है।

<?
$a.='10 5
#o         
##       
###       
######    
#########';$b=array();$c=explode("\n",$a);$d=explode(" ",$c[0]);$e=$d[0];$f=$d[1];unset($c[0]);$g=0;foreach($c as $h){$b[$g]=str_split($h);++$g;}for($i=0;$i<$f;++$i){for($j=0;$j<$e;++$j){if($b[$i][$j]=='o'){$k=$j;$l=$i;$b[$i][$j]=' ';}}}if($b[$l+1][$k]!='#'){$b[$l+1][$k]='o';}else if($b[$l+1][$k+1]!='#'){$b[$l+1][$k+1]='o';}else{$b[$l][$k+1]='o';}echo"$e $f\n";for($i=0;$i<$f;++$i){for($j=0;$j<$e;++$j){echo $b[$i][$j];}echo "\n";}

आप इसे देख सकते हैं यहाँ codepad पर कार्रवाई में

संपादित करें: परिवर्तित कोडपैड और कोड जैसा कि ओ के बजाय 0 आउटपुट कर रहा था, जिससे समस्या तब हुई जब मैंने आउटपुट को प्रोग्राम में वापस फीड करने की कोशिश की। अब फिक्स्ड और एक चार को बचाया!

— पॉल ड्रूएट
स्रोत

0

ग्रूवी - 263 261 256 वर्ण

Golfed। फ़ाइल को स्ट्रिंग में पढ़ें, और फ़ंक्शन pका अनुकरण करने के लिए फ़ंक्शन का उपयोग करें String.putAtIndex(index,value):

o="o"
b=" "
s=new File(args[0]).text
z={s.size()-it}
s=s[0..z(2)]
w=s.find(/\n.*?\n/).size()-1
p={i,v->s=s[0..i-1]+v+((i<z(0)-2)?s[i+1..z(1)]:"")}
try{
t=s.indexOf o
i=w+t
j=i+1
x=t+1
(s[i]==b)?x=i:(s[j]==b)?x=j:0
p x,o
p t,b
}catch(Exception e){}
print s

अनगढ़ (कुछ हद तक):

o = "o"
b = " "
s = new File(args[0]).text
z = {s.size()-it}
s = s[0..z(2)]
w = s.find(/\n.*?\n/).size()-1

putAtIndex = { i,val -> 
    s = s[0..i-1] + val + ((i<z(0)-2)?s[i+1..z(1)]:"") 
}

try {
    t=s.indexOf o
    i=w+t
    j=i+1
    x=t+1
    // default x as horizontal move
    // check for (a) directly below (b) below and over one
    (s[i]==b) ? x=i : ( (s[j]==b) ? x=j : 0)
    putAtIndex x,o
    putAtIndex t,b
} catch (Exception e) {}
print s

— माइकल ईस्टर
स्रोत

अच्छा लगा। मुझे भाषा नहीं आती है, लेकिन मुझे लगभग यकीन है कि आप (कम से कम) दो बाइट्स से छुटकारा पा सकते हैं यदि आप try{इसके बजाय try {और catch(Exceptionइसके बजाय लिखते हैं catch (Exception।

— क्रिस्टोफ़ बोम्हवालडर

वास्तव में! नोट के लिए धन्यवाद ....

— माइकल ईस्टर

0

आर, 234

require(stringr)
g=scan(,"")
g=do.call(rbind,strsplit(str_pad(g,m<-max(nchar(g)),"r"),""))
if(g[(x<-which(g=="o"))+1]==" "){g[x+1]="o";g[x]=""}else{if(!is.na(g[x+1])){g[x+(n<-nrow(g))]="o";g[x]=""}}
for(i in 1:n) cat(g[i,],"\n",sep="")

स्ट्रिंग हेरफेर आर का सबसे मजबूत बिंदु नहीं है।

अधिक आसानी से:

require(stringr) # load package `stringr`, available from CRAN. required for `str_pad`
g=scan("")       # read input from console
g=do.call(       # applies the first argument (a function) to the second argument (a list of args to be passed) 
  rbind,         # "bind" arguments so that each one becomes the row of a matrix
  strsplit(      # split the first argument by the second
    str_pad(g,max(nchar(g)),"r"," "), # fill each row with whitespace
    "")
)
if(g[(x<-which(g=="o"))+1]==" ") { # if the next element down from the "o" is " "...
  g[x+1]="o";g[x]=""               # make it an "o" and replace the current element with ""
} else {
  if(!is.na(g[x+1])) {             # if the next element down is not empty (i.e. out of range)
    g[x+nrow(g)]="o"; g[x]=""      # move "o" right
  }
}
for(i in 1:n) cat(g[i,],"\n",sep="") # print to console

— shadowtalker
स्रोत

0

सी (182)

char b[1024],*x,*n;main(z){read(0,b,1024);n=index(b,10)+1;x=index(n,'o');z=index(n,10)-n;n=x+z+1;if(n[1]){if(*n==32)*n='o';else if(n[1]==32)n[1]='o';else x[1]='o';*x=32;}printf(b);}

या, यदि आप वास्तव में कोड पढ़ना चाहते हैं:

char b[1024],*x,*n; //1024 byte buffer hard coded
main(z){
    read(0,b,1024);
    n=index(b,10)+1; //start of line 2
    x=index(n,'o');
    z=index(n,10)-n; //10='\n'
    n=x+z+1; //reusing n
    if(n[1]){ //if not 0
        if(*n==32) //32=' '
            *n='o';
        else if(n[1]==32)
            n[1]='o';
        else
            x[1]='o';
        *x=32;
    }
    printf(b);
}

— इयान डी। स्कॉट
स्रोत

0

क्लोजर - 366 वर्ण

रेगेक्स के बिना। "D" नाम की आवश्यक इनपुट फ़ाइल। golfed:

(def s(slurp "d"))(def w(-(.length(re-find #"\n.*?\n" s))2))(def t(.indexOf s "o"))(def i(+ t w 1))(defn g[i,j,x,c](cond (= x i) \ (= x j) \o :else c))(defn j[i,j] (loop[x 0](when(< x (.length s))(print(g i j x (.charAt s x)))(recur(inc x)))))(try(cond(= \ (.charAt s i))(j t i)(= \ (.charAt s (inc i)))(j t (inc i)):else (j t (inc t)))(catch Exception e (print s)))

Ungolfed:

(def s (slurp "d"))
(def w (- (.length (re-find #"\n.*?\n" s)) 2))
(def t (.indexOf s "o"))
(def i (+ t w 1))
(defn g [i,j,x,c] (cond (= x i) \ (= x j) \o :else c))

(defn j [i,j] (loop [x 0]
     (when (< x (.length s))
     (print (g i j x (.charAt s x))) (recur (inc x)))))

(try (cond (= \ (.charAt s i)) (j t i)
           (= \ (.charAt s (inc i))) (j t (inc i))
           :else (j t (inc t)))(catch Exception e (print s)))

नमूना रन (संक्षिप्तता के लिए सिर्फ एक मामला):

bash-3.2$ cat d
6 7
#     
#     
#     
## o  
####  
####  
##### 

bash-3.2$ java -jar clojure-1.6.0.jar hill.clj 
6 7
#     
#     
#     
##    
####o 
####  
#####

मैं नौसिखिया हूँ। सुझावों का स्वागत करते हैं।

— माइकल ईस्टर
स्रोत

0

MATLAB, 160

function r(f)
F=cell2mat(table2array(readtable(f)));
m=@(d)mod(d-1,size(F,1));C=find(F=='o');P=find(F==' ');N=min(P(P>C&m(P)>=m(C)));F([C,N])=F([N,C]);
disp(F);

दर्दनाक हिस्सा फ़ाइल-इनपुट है। वास्तविक गणना केवल 114 बाइट्स होगी:

function F=r(F)
m=@(d)mod(d-1,size(F,1));C=find(F=='o');P=find(F==' ');N=min(P(P>C&m(P)>=m(C)));F([C,N])=F([N,C]);

— knedlsepp
स्रोत

पहाड़ी से लुढ़कते हुए चट्टान की गणना करें

परिचय

चुनौती

कुछ विवरण

रेगेक्स (.NET, पर्ल, पीसीआरई, जावास्क्रिप्ट, ... फ्लेवर), 25 बाइट्स

अजगर - 190

रूबी, 65/55 वर्ण

HTML जावास्क्रिप्ट - 251 वर्ण

अजगर 2 - 289 252 बाइट्स

पायथन (201)

awk, 152

अधिक पठनीय

php 485 484 चार्ट

ग्रूवी - 263 261 256 वर्ण

आर, 234

सी (182)

क्लोजर - 366 वर्ण

MATLAB, 160