टहलने के लिए कुत्ते को ले जाना

14

मेरा कुत्ता मुझ पर भौंक रहा है, लेकिन मैं उसे टहलने के लिए ले जा रहा हूँ। मेरे पास विचार है! मैं कोड गोल्फ में लोगों को मेरे लिए यह करने के लिए मिल जाएगा!

आपकी चुनौती एक कुत्ते के चलने की नकल करना है। यहाँ कुत्ते चलने के नियम हैं:

  • मानव ( H) 0,0एक (कार्टेशियन) समन्वय विमान पर शुरू होगा , और बेतरतीब ढंग से हर सेकंड, बाएं, दाएं, या नीचे एक स्थान ऊपर जाएगा।
  • कुत्ता ( D) एक ही स्थान पर शुरू होगा, और प्रत्येक सेकंड (यादृच्छिक रूप से, निश्चित रूप से) शून्य, एक, दो, या तीन स्थान ऊपर, बाएं, दाएं, या नीचे जाएगा। कुत्ता कम अनुमानित है और कभी-कभी तेजी से चलेगा या पूरी तरह से बंद हो जाएगा।
  • कुत्ते को मानव (यूक्लिडियन दूरी) में दूर इकाइयों की एक निश्चित मात्रा से अधिक कभी नहीं मिलेगा, जो पट्टा ( L) की लंबाई है । उदाहरण के लिए, यदि Lहै 6, तो एक वैध स्थिति होगी H(0,0) D(4,4)(चूंकि दूरी लगभग 5.65 इकाई है), लेकिन नहीं H(0,0) D(5,4)(लगभग 6.4 इकाई)।
    • यदि, कुत्ता चलता है, तो वह पट्टा दूरी की आवश्यकता का उल्लंघन करेगा, उसे अपनी निर्धारित दिशा में सबसे दूर जाना चाहिए जो दूरी की आवश्यकता का उल्लंघन नहीं करता है। उदाहरण के लिए, यदि स्थिति है H(0,0) D(3,4)और कुत्ते को बेतरतीब ढंग से 3 रिक्त स्थान को दाईं ओर ले जाने का निर्णय लिया गया है, तो यह जाएगा D(4,4), क्योंकि यह सबसे दूर जाने के बाद 6 से अधिक इकाइयों को प्राप्त किए बिना जा सकता है। (ध्यान दें कि इसके परिणामस्वरूप 0 स्थान हो सकता है, अर्थात कोई भी आंदोलन नहीं होगा!)
  • विविध नियम: मानव सबसे पहले चलता है। मानव को अपनी चाल पर पट्टा लंबाई से अधिक नहीं होना चाहिए। यदि ऐसा होता है, तो उसे दूसरी दिशा चुननी चाहिए। "यादृच्छिक" का अर्थ है "एक समान वितरण के साथ और बिना किसी पैटर्न के।"

इस प्रारूप में इनपुट दिया जाएगा (एसटीडीआईएन, फ़ंक्शन पैरामीटर, फ़ाइल, आदि):

"<amount of seconds the walk will last> <leash length>"

उदाहरण के लिए:

300 6 // a 5 minute walk with a 6 yard leash

आपको इस प्रारूप में आउटपुट देना होगा (STDOUT, फ़ंक्शन रिटर्न वैल्यू, फ़ाइल, आदि):

H(0,0) D(0,0)
H(0,1) D(2,0)
H(1,1) D(2,1)
H(1,0) D(2,-1)
...

(लाइन आउटपुट की मात्रा होगी seconds + 1, क्योंकि H(0,0) D(0,0)लाइन की गिनती नहीं है।)

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाएगा!

code-golf  random 
— Doorknob
स्रोत
4
स्पष्ट रूप से आपके द्वारा बताई गई बातें, लेकिन संभवतः उन्हें स्पष्ट रूप से बताने के लिए अच्छा है: 1. दूरी का मतलब यूक्लिडियन दूरी, 2. समन्वय विमान कार्टेशियन है, ध्रुवीय नहीं (या बोइंग 777); ऐसी चीजें जो स्पष्ट नहीं हैं: 3. अगर उनकी चाल लम्बी लंबाई से अधिक होगी तो मानव क्या करेगा? 4. प्रत्येक मोड़ पर, सबसे पहले कौन चलता है, कुत्ता या इंसान?
— जोनाथन वान मैटर
यदि चयनित दिशा वैध कदम की अनुमति नहीं देती है: तो क्या कोई कदम नहीं उठाया जाना चाहिए या किसी अन्य दिशा को चुना जाना चाहिए?
— तिमुल्ला
इनपुट कैसे प्राप्त किया जाना चाहिए? STDIN? एक फ़ंक्शन पैरामीटर भी ठीक है?
— तिमुल्ला
1
मेरा कुत्ता केवल मुझ पर भौंकता है अगर मैं उसे टहलने के लिए ले जाऊं।
— TheDoctor
@ स्पष्टता के लिए संपादित समय; धन्यवाद।
— दरवाज़े

जवाबों:

2

GolfScript, 140 वर्ण

~.*:L;)[0.].@{['H('1$','*') D('4$','*')'n]@@{[@~]}+[{)}{(}{\(\}{\)\}]:^%{{~2$~@-.*@@-.*+L>!},}:F~.,{rand}:R~=\[.;{.[~}^4R=+{]}+4R*]F-1=\}*;;

उदाहरण रन ( ऑनलाइन प्रयास करें ):

> 10 3
H(0,0) D(0,0)
H(0,1) D(0,0)
H(0,0) D(0,2)
H(0,1) D(-1,2)
H(1,1) D(-1,2)
H(1,2) D(-1,4)
H(1,3) D(-1,5)
H(0,3) D(-1,5)
H(-1,3) D(1,5)
H(-1,4) D(1,5)
H(0,4) D(-1,5)
— हावर्ड
स्रोत
6

CoffeeScript - 324 + फ़ंक्शन कॉल

डेमो (पट्टा 10 का उपयोग करके):

H(0,0) D(0,0)
H(0,-1) D(0,3)
H(-1,-1) D(0,3)
H(-1,-2) D(-1,3)
H(-1,-3) D(-4,3)
H(-1,-2) D(-4,4)
H(-1,-3) D(-5,4)
H(-1,-2) D(-2,4)
H(-1,-3) D(-2,5)
H(-1,-4) D(-2,5)
H(-1,-3) D(-3,5)
H(0,-3) D(-4,5)
H(-1,-3) D(-4,6)
H(-1,-4) D(-2,6)
H(-2,-4) D(-2,6)
H(-3,-4) D(-5,6)
H(-4,-4) D(-5,6)
H(-4,-3) D(-5,8)
H(-5,-3) D(-2,8)
H(-5,-2) D(-2,8)
H(-5,-3) D(-2,5)

कोड:

w=(i)->
    [s,l]=i.split ' ';m=Math;h=[0,0];d=[0,0];r=->(4*m.random())|0
    a=->m.abs(h[0]-d[0])**2+m.abs(h[1]-d[1])**2<=l**2
    b=(x)->if x%2 then 1else-1
    for i in[0..s]
        console.log "H(#{h}) D(#{d})"
        loop
            H=h.slice();x=r();h[(x/2)|0]+=b x;break if a();h=H
        D=r();x=r();(d[(x/2)|0]+=b x;d[(x/2)|0]-=b x if!a())while D-->0

लंबा कोड:

human = [ 0, 0 ]
doge = [ 0, 0 ]
randomDirection = -> [ 'u', 'd', 'l', 'r' ][(4*Math.random())|0]
allowed = -> Math.abs(human[0] - doge[0]) ** 2 + Math.abs(human[1] - doge[1]) ** 2 <= leash**2
leash = 0
walk = (input) ->
    [ seconds, leash ] = input.split ' '
    for i in [0..seconds]
        console.log "H(#{human}) D(#{doge}) #{Math.sqrt Math.abs(human[0] - doge[0]) ** 2 + Math.abs(human[1] - doge[1]) ** 2}"
        valid = no
        loop
            oldHuman = human.slice()
            switch randomDirection()
                when 'u'
                    human[0]--
                when 'd'
                    human[0]++
                when 'l'
                    human[1]--
                when 'r'
                    human[1]++

            if allowed()
                break
            else
                human = oldHuman

        dogeDistance = (Math.random() * 4)|0
        switch randomDirection()
            when 'u'
                while dogeDistance-- > 0
                    doge[0]--
                    doge[0]++ if !allowed() 
            when 'd'
                while dogeDistance-- > 0
                    doge[0]++
                    doge[0]-- if !allowed() 
            when 'l'
                while dogeDistance-- > 0
                    doge[1]--
                    doge[1]++ if !allowed() 
            when 'r'
                while dogeDistance-- > 0
                    doge[1]++
                    doge[1]-- if !allowed() 
walk "10 2"
— TimWolla
स्रोत
4

रूबी, १ 189 ९ १y

मैं संभवतः इसे थोड़ा कम कर सकता हूं। मैं प्यार नहीं करते j।

h=d=0;e,l=$*
def j;[1,-1,?i,'-i'].sample.to_c end
0.upto(e.to_i){puts'H(%d,%d) D(%d,%d)'%(h.rect+d.rect)
1 while((g=h+j)-d).abs>l.to_i
h,s=g,j
3.times{d+=s if(d+s-h).abs<=l.to_i}}

Ungolfed:

h=d=0 # use complex numbers since it has distance built in
time,leash=$*

def randomDirection
  [1,-1,'i','-i'].sample.to_c 
end

0.upto(time.to_i) { # (1 + time) times
  puts"H(%d,%d) D(%d,%d)"%(h.rect+d.rect) # that's [h.real, h.imag, d.real, d.imag]

  # find a newH that doesn't violate the leash
  newH = h + randomDirection
  while((g-d).abs > leash.to_i) 
    newH = h + randomDirection
  end

  h = newH

  newD = randomDirection
  3.times{
    # keep adding newD until you hit the leash
    d += newD if(d + newD - h).abs <= leash.to_i
  }
}
— चार्ल्स नहीं
स्रोत
2

गणितज्ञ 285

golfed

r=RandomChoice;k=False;
s:=r[{{0,1},{-1,0},{1,0},{0,-1}}]
w:=r[{0,1,2,3,4}]
f[{-1,___}]:="";
f[{n_,l_,{h_,d_}}]:=
(Print["H(",h,")\t","D(",d,")"];
m[i_,u_,v_]:=EuclideanDistance[u+i,v]<l;
z=k;While[z==k,t=s;z=m[t,h,d]];
y=h+t;t=w*s;z=k;While[z==k,t=t-Sign@t;z=m[t,d,y]];
dp=d+t;f[{n-1,l,{y, dp}}])

उदाहरण

f[{17,7,{{0,0},{0,0}}}]

H ({0,0}) D ({0,0})
H ({1,0}) D ({0,0})
H ({2,0}) D ({0,2})
H (0 ) {2, -1}) डी ({0, -1})
एच ({1, -1}) डी ({- 3, -1})
एच ({1,0}) डी ({- 3,1) })
एच ({११ ९}) डी ({०,१}})
एच ({१,२}}) डी ({० ९ २})
एच ({११ ९}) डी ({० ९ २})]
H ({1,0}) D ({- 2,2})
H ({2,0}) D ({1,2})
H ({2, -1}) D ({- 2,2}} )
H ({2,0}) D ({- 2,3})
H ({2,1}) D ({- 2,0})
H ({1,1}) D ({- 2,3} })
H ({2,1}) D ({- 2,6})
H ({1,1}) D ({- 3,6})
H ({0,1}) D ({- 4,) 6})

UnGolfed

नीचे दिए गए पाठ में कुछ टिप्पणियां हैं। मैंने एक प्रिंटआउट भी शामिल किया है, जो कुछ गणनाओं का पालन करना संभव बनाता है।

step:=RandomChoice[{{0,1},{-1,0},{1,0},{0,-1}}]
dogWander:=RandomChoice[{0,1,2,3,4}]

f[{-1,___}]:="";

f[{n_,l_,{humanPos_,dogPos_}}]:=
Module[{tempStep,moveOK,hp,hp1,dp,p,test},

(* human imagines step, checks with leash, chooses another step if would choke the dog *)
moveOK[intendedStep_,pos1_,pos2_]:=EuclideanDistance[pos1+intendedStep,pos2]<l;
test=False;While[test==False,tempStep=step;test=moveOK[tempStep,humanPos,dogPos]];
hp=humanPos+tempStep;
Print["humanPos before: ", humanPos,"\t","human step: ",tempStep,"\thumanPos after: ",hp,"\tdistance from dog: ",N@EuclideanDistance[hp,dogPos]];

(*move closer to human if needed *)
tempStep=dogWander*step;
test=False;While[test==False,tempStep=tempStep-Sign[tempStep];test=moveOK[tempStep,dogPos,hp]];
dp=dogPos+tempStep;
Print["dog's intended step: ",tempStep,"\tdogPos before: ",dogPos,"\t","dog actual step: ",tempStep, "\t","dogPos after: ",dp,"\tdistance: ",N@EuclideanDistance[hp,dp],"\n"];
f[{n-1,l,{hp, dp}}]]

उदाहरण

f[{17,5,{{0,0},{0,0}}}]

[प्रिंटआउट का एक भाग यह बताने के लिए दिखाया गया है कि कोड कैसे काम करता है। ]

प्रिंट आउट

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