ग्रेट एपीआई ईस्टर एग हंट!

15

एपीआई ईस्टर अंडे का शिकार!

Http://easter_egg_hunt.andrewfaraday.com पर एक एपीआई है जो आपके लिए एक विशेष ईस्टर अंडे का शिकार प्रदान करेगा ...

आप उपरोक्त पते पर एपीआई डॉक्स देख सकते हैं, या इसे यहाँ से आज़मा सकते हैं।

एपीआई:

इस API के सभी कॉल GET अनुरोध हैं, जो JSON स्ट्रिंग लौटाएंगे।

ये उदाहरण केवल 5x5 उद्यान में हैं, केवल चित्रण के लिए। एपीआई वास्तव में एक 100x100 उद्यान (अनुक्रमित 1 से 100 तक) पर काम करेगा

/new_game

आंतरिक रूप से, एपीआई एक बगीचे का निर्माण करता है, और इसमें एक अंडा छिपाता है।

इस उदाहरण में अंडा 4, 4 पर है

+----------+
|          |
|          |
|          |
|          |
|   E      |
|          |
|          |
|          |
|          |
|          |
+----------+

कॉल

/new_game

रिटर्न

{game_id: 'abcde'}

/guess/:game_id/:x/:y

एपीआई बगीचे में दिखता है और बताता है कि आप कितने करीब हैं।

यदि आप 2 के पार और नीचे 8 का अनुमान लगाते हैं, तो बगीचे इस तरह दिखता है

+----------+
|          |
|          |
|          |
|          |
|   E      |
|          |
|          |
| g        |
|          |
|          |
+----------+

कॉल

/guess/abcde/2/8

रिटर्न

{x: 'higher', y: 'lower'}

इसका मतलब है: * आपका x बहुत कम है (अंडे की स्थिति अधिक है) * आपका y बहुत अधिक है (अंडे की स्थिति कम है)

सही कॉल:

/guess/abcde/4/4

रिटर्न

{x: 'right', y: 'right', turns: 10}

नियम

एक एपीआई के साथ ईस्टर अंडे को खोजने के लिए एक कार्यक्रम लिखें।

  • किसी भी भाषा का उपयोग करें।
  • संक्षिप्त, लेकिन पठनीय कोड लिखने का प्रयास करें।
  • आपका प्रोग्राम हर बार '/ new_game' कॉल करना चाहिए , और सभी 'अनुमान' कॉल में दिए गए game_id का उपयोग करें। बगीचे में कोई झांकता नहीं!
  • संभव सबसे कम कॉल के साथ गेम को लगातार खत्म करने की कोशिश करें।
  • यह कोड गोल्फ नहीं है।

प्रतियोगी उत्तर?

यहाँ जीतने की संभावना के साथ होने के लिए हमें क्या जानना चाहिए:

  • आप किस कोड का उपयोग कर रहे हैं (यदि आपके उत्तर में है, या जीथब लिंक है तो यह आपके द्वारा उत्तर में डालना पसंद करने से बड़ा है)।
  • अपना कोड 10 बार चलाएं, और game_id रिकॉर्ड करें और हर बार स्कोर करें।

-गेम_िड- : -स्कोर -

जैसे

abbbbbbb : 10

abbbbbdd : 5

(नोट: game_ids परिणाम को सत्यापित करने के लिए आवश्यक हैं)

इस प्रकार स्कोर की गणना की जाएगी:

  • उच्चतम और निम्नतम दो परिणामों को अनदेखा किया जाएगा।
  • शेष 6 स्कोर को एक साथ जोड़ा जाएगा।
  • यह आपका स्कोर है।
  • सबसे कम स्कोर जीतता है।

परिशिष्ट

टीएल, डॉआर: ऐप थोड़ा घटिया है।

एपीआई लगभग 90 मिनट के अंतरिक्ष में लिखा गया था, और एक रास्पबेरी पाई पर तैनात किया गया है। कृपया मेरे एपीआई सर्वर के साथ कोमल रहें। यदि आप इस खराब चीज़ को डीडीओएस करते हैं तो आप इसे सभी के लिए खराब कर सकते हैं।

इसके अलावा, इसे एक स्थिर IP पते को अनुकरण करने के लिए NOIP के साथ लागू किया जाता है, लेकिन कभी-कभी यह थोड़ी देर के लिए बाहर हो जाएगा। यही मुझे शून्य-बजट वेब होस्टिंग के लिए उपयोग करने के लिए मिलता है।

बस गिगल्स के लिए, यहां खेले जाने वाले खेलों का एक सरल सांख्यिकीय विश्लेषण है ... http://easter_egg_hunt.andrewfaraday.com/stats

code-challenge 
— AJFaraday
स्रोत
टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।
— डेनिस

जवाबों:

3

एपीएल + विन

केंद्र में शुरू करके काम करता है और अंतिम मान के लिए ऊपरी या निचली सीमा निर्धारित करके स्थान पर धर्मान्तरित करता है और प्रत्येक पुनरावृत्ति पर अंतिम अनुमान के लिए उपयुक्त सीमा में आधा अंतर जोड़ या घटाता है।

API                                                                               
id←¯20↑¯2↓GetUrl 'http://easter_egg_hunt.andrewfaraday.com/new_game'              
xh←yh←100 ⋄ xl←yl←0 ⋄ x←50 ⋄ y←50 ⋄ c←0                                           
:repeat                                                                           
    xy←GetUrl 'http://easter_egg_hunt.andrewfaraday.com/guess/',id,'/',(⍕x),'/',⍕y
    xy←(('higher'⍷xy)+(¯1×'lower'⍷xy)+2×'right'⍷xy)~0                             
    :if xy[1]=1 ⋄ xl←x ⋄ x←x+⌈(xh-x)÷2 ⋄ :endif                                   
    :if xy[1]=¯1 ⋄ xh←x ⋄ x←x-⌈(x-xl)÷2 ⋄ :endif                                  
    :if xy[2]=1 ⋄ yl←y ⋄ y←y+⌈(yh-y)÷2 ⋄ :endif                                   
    :if xy[2]=¯1 ⋄ yh←y ⋄ y←y-⌈(y-yl)÷2 ⋄ :endif                                  
    c←c+1                                                                         
:until 4=+/2↑xy                                                                   
'id:',id,' x:',(⍕x),' y:',(⍕y),' count:',⍕c

यह फ़ंक्शन API कॉल करने के लिए निम्नलिखित फ़ंक्शन का उपयोग करता है:

r←GetUrl url                                     
⎕wself←'HTTP' ⎕wi 'Create' 'MSXML2.ServerXMLHTTP'
⎕wi 'XOpen' 'GET' url 0                          
⎕wi 'XSend'                                      
r←⎕wi 'xresponseText'

10 कोशिशों के परिणाम थे:

id:rbgprkxrqzzhwdfsbszn x:36 y:52 count:7      
id:nmpcxdqsdzhgrbtlcpbp x:35 y:49 count:6      
id:qqnsbpwnlbptxxblywnz x:99 y:22 count:6      
id:nsytnvcgnsyrgzvjcysc x:45 y:28 count:6      
id:yfkpfhphjpqxtqnwpmhv x:95 y:40 count:7      
id:kxhszzrhxqlnvwvwjgnm x:49 y:6 count:6       
id:rwnwfgdpzcjpzzfmgcfn x:93 y:34 count:7      
id:tcvhtpqlfrwngybsyzqh x:95 y:94 count:6      
id:pmlmqnprwcjggjfhttmy x:20 y:41 count:6      
id:kpsmmhfhxxrrlvbbgzkv x:9 y:28 count:5
— ग्राहम
स्रोत
2

रूबी (+ JSON, HTTParty) - स्कोर: 40 (6 + 7 + 7 + 7 + 7 + 6)

यह एक मजेदार चुनौती थी। मैंने अंडे को खोजने के लिए द्विआधारी खोज का उपयोग किया और ये परिणाम मिले:

[{:x=>34, :y=>17, :game_id=>"mgpbmdqbnklcqrdjpyrr", :count=>7},
 {:x=>99, :y=>17, :game_id=>"mhrsqfzmrrlcqxtcfgnw", :count=>7},
 {:x=>23, :y=>86, :game_id=>"zgmsrjpqvdtmqmmglstn", :count=>6},
 {:x=>24, :y=>55, :game_id=>"vkpjffyyltplztwhdsft", :count=>7},
 {:x=>12, :y=>94, :game_id=>"pxrzjvqfjrjsptvtvnfw", :count=>4},
 {:x=>83, :y=>59, :game_id=>"bdxljxkcnqmsqgnvggql", :count=>7},
 {:x=>45, :y=>40, :game_id=>"mqrsbrhbldcqwgbnmymc", :count=>7},
 {:x=>13, :y=> 9, :game_id=>"bphxkdgfcyyrvwxnfvkx", :count=>6},
 {:x=> 8, :y=>80, :game_id=>"qzdstksdwnwrhxqrczpc", :count=>7},
 {:x=>56, :y=>92, :game_id=>"ypqkfvmvwrcvvmjccvxg", :count=>6}]

यहाँ कोड है :

require 'rspec/autorun'
require 'json'
require 'httparty'
require 'pp'

GuessResult = Struct.new :x, :y, :count

class FakeGame
  def initialize(x=random_num, y=random_num)
    @x = x
    @y = y
    @count = 0
  end

  @@results = [:right, :higher, :lower]

  def guess(x, y)
    @count += 1
    GuessResult.new(@@results[@x <=> x], @@results[@y <=> y], @count)
  end

  def id
    :fake
  end

  def random_num
    rand(100) + 1
  end
end

class RealGame
  def initialize
    response = HTTParty.get('http://easter_egg_hunt.andrewfaraday.com/new_game')
    j = JSON.parse(response.body)
    @id = j['game_id']
  end

  def guess(x, y)
    response = HTTParty.get("http://easter_egg_hunt.andrewfaraday.com/guess/#{id}/#{x}/#{y}")
    j = JSON.parse(response.body)
    x_result = j['x'].to_sym
    y_result = j['y'].to_sym
    count = (j['turns']||0).to_i
    GuessResult.new(x_result, y_result, count)
  end

  def id
    @id
  end
end


class BinarySearch
  def initialize(min, max)
    @min = min
    @max = max
    @guessed = false
    update_next_guess
  end

  attr_reader :next_guess, :guessed

  def go(result)
    return if @guessed
    case result
    when :right
      @guessed = true
    when :lower
      @max = @next_guess - 1
      update_next_guess
    when :higher
      @min = @next_guess + 1
      update_next_guess
    end
  end

  private

  def update_next_guess
    @next_guess = (@max + @min) / 2
  end

end

def play(game)
  x_search = BinarySearch.new(1, 100)
  y_search = BinarySearch.new(1, 100)

  until x_search.guessed && y_search.guessed
    puts ?.
    result = game.guess(x_search.next_guess, y_search.next_guess)
    x_search.go(result.x)
    y_search.go(result.y)
  end

  {
    x: x_search.next_guess,
    y: y_search.next_guess,
    game_id: game.id,
    count: result.count
  }
end


def game_controller(game_constructor, game_count)
  (1..game_count).map do |i|
    game = game_constructor.call
    puts "Starting game #{game.id}..."
    play(game)
  end
end


def main
  # pp game_controller(->{ FakeGame.new }, 10)
  pp game_controller(->{ RealGame.new }, 10)
end

main


# tests

describe :FakeGame do

  it "returns right results" do
    game = FakeGame.new 4, 4

    result = game.guess(2, 5)
    expect(result.x).to eql :higher
    expect(result.y).to eql :lower
    expect(result.count).to eql 1

    result = game.guess(5, 3)
    expect(result.x).to eql :lower
    expect(result.y).to eql :higher
    expect(result.count).to eql 2

    result = game.guess(4, 4)
    expect(result.x).to eql :right
    expect(result.y).to eql :right
    expect(result.count).to eql 3

  end

end

describe :binary_search do
  let(:search) { BinarySearch.new 1, 100 }

  it "makes optimal guesses" do
    # aiming for 34
    expect(search.next_guess).to eql 50
    expect(search.guessed).to be_falsey
    search.go(:lower)
    expect(search.next_guess).to eql 25
    search.go(:higher)
    expect(search.next_guess).to eql 37
    search.go(:lower)
    expect(search.next_guess).to eql 31
    search.go(:higher)
    expect(search.next_guess).to eql 34
    search.go(:right)
    expect(search.next_guess).to eql 34
    expect(search.guessed).to be_truthy
  end

end

describe :fake_game do

  it "correctly responds to guesses" do
    game = FakeGame.new(34, 77)
    result = play(game)
    expect(result.y).to eql :lower
    expect(result.count).to eql 1

    result = game.guess(5, 3)
    expect(result.x).to eql :lower
    expect(result.y).to eql :higher
    expect(result.count).to eql 2

    result = game.guess(4, 4)
    expect(result.x).to eql :right
    expect(result.y).to eql :right
    expect(result.count).to eql 3

  end

end

describe '#play' do

  it "guesses correctly" do
    game = FakeGame.new(34, 77)
    result = play(game)
    expect(result[:x]).to eql 34
    expect(result[:y]).to eql 77
    expect(result[:count]).to eql 7
    expect(result[:game_id]).to eql :fake
  end

end
— क्रिस्टियन लुपस्कू
स्रोत
लगता है मैंने यहाँ गड़बड़ कर दी है। easter_egg_hunt.andrewfaraday.com/stats बताता है कि ऐप के इतिहास में केवल 12 गेम पूरे हुए हैं। मुझे यकीन है कि कल कम से कम 6 पूरे हो चुके थे। हालांकि 160 सबसे लंबा है। मैं इसे देखूंगा।
— AJFaraday
यह मुद्दा RealGame # अनुमान में प्रतीत होता है, जहाँ आपने game_id के साथ गेम को हार्डकोड किया है "bswtdwfdjypdtfyqxbyz"। अधिक सटीक परिणाम सेट प्राप्त करने के लिए इसे # {@ id} से बदलें।
— AJFaraday
वास्तव में, मैंने सही किया कि एक पंक्ति और आपका परिणाम सेट बहुत अच्छा है। बल्कि लगातार 6 और 7 का है। अच्छा काम: D
— AJFaraday
@AJFaraday ऊप्स। मेरी गलती! ठीक करने के लिए धन्यवाद! और इस मजेदार चुनौती को बनाने के लिए धन्यवाद!
— क्रिस्टियन लुपस्कू
आपने मुझे एक मिनट के लिए चिंतित किया, वहाँ;)
— एजेफाराडे
2

पायथन 3 (+ अनुरोध), 39 अंक

http://easter_egg_hunt.andrewfaraday.com/guess/dbxqfgldhryxymljthkx/13/82
{"turns": 7, "url": "http://easter_egg_hunt.andrewfaraday.com/surprise", "x": "right", "y": "right"}
http://easter_egg_hunt.andrewfaraday.com/guess/kfmgrdqlyxfknbgycfwm/6/52
{"turns": 7, "url": "http://easter_egg_hunt.andrewfaraday.com/surprise", "x": "right", "y": "right"}
http://easter_egg_hunt.andrewfaraday.com/guess/gnykwddprlfwwkrybkmc/34/91
{"turns": 6, "url": "http://easter_egg_hunt.andrewfaraday.com/surprise", "x": "right", "y": "right"}
http://easter_egg_hunt.andrewfaraday.com/guess/xhwrqdgtdyrwrvdqqcpk/92/54
{"turns": 7, "url": "http://easter_egg_hunt.andrewfaraday.com/surprise", "x": "right", "y": "right"}
http://easter_egg_hunt.andrewfaraday.com/guess/hmbgrnxjfgqcxhbfkztm/44/48
{"turns": 7, "url": "http://easter_egg_hunt.andrewfaraday.com/surprise", "x": "right", "y": "right"}
http://easter_egg_hunt.andrewfaraday.com/guess/mhbchhbkppqqyxzqvrnb/62/38
{"turns": 7, "url": "http://easter_egg_hunt.andrewfaraday.com/surprise", "x": "right", "y": "right"}
http://easter_egg_hunt.andrewfaraday.com/guess/pbrkghynqybmkmctncmr/73/25
{"turns": 6, "url": "http://easter_egg_hunt.andrewfaraday.com/surprise", "x": "right", "y": "right"}
http://easter_egg_hunt.andrewfaraday.com/guess/sspxcsfblrnmhflgtggn/89/73
{"turns": 6, "url": "http://easter_egg_hunt.andrewfaraday.com/surprise", "x": "right", "y": "right"}
http://easter_egg_hunt.andrewfaraday.com/guess/rlvdstmpsthktzkqbynn/4/71
{"turns": 6, "url": "http://easter_egg_hunt.andrewfaraday.com/surprise", "x": "right", "y": "right"}
http://easter_egg_hunt.andrewfaraday.com/guess/wknwwcrdrmjsqxnqbvhm/50/67
{"turns": 6, "url": "http://easter_egg_hunt.andrewfaraday.com/surprise", "x": "right", "y": "right"}

स्कोर 39 (7 + 7 + 7 + 6 + 6 + 6 - 7-7-6-6)

स्रोत: 

import requests
import json
url='http://easter_egg_hunt.andrewfaraday.com/guess/{id}/{x}/{y}'
start='http://easter_egg_hunt.andrewfaraday.com/new_game'
gid = requests.get(start).json()['game_id']
x=y=50
step=25
lx=lr=''
def get_new(old,value):
        if value == 'higher':
                return old+step
        elif value == 'lower':
                return old-step
        else:#right
                return old
while True:
        res = requests.get(url.format(id=gid,x=x,y=y)).json()
        if res['x'] == 'right' and res['y'] == 'right':
                print(url.format(id=gid,x=x,y=y))
                print(json.dumps(res, sort_keys=True))
                break
        x=get_new(x,res['x'])
        y=get_new(y,res['y'])
        step=step // 2 or 1
— रिक रॉन्गेन
स्रोत
बस ध्यान दिया जाता है कि परिणाम में कोई गेमिड नहीं है, मैं इसे फिर से चलाऊंगा और गेम आईडी को थोड़ा जोड़
— दूंगा
आपने खुद को ओवर-स्कोर भी किया है। हम उच्चतम दो और सबसे कम दो परिणामों पर छूट दे रहे हैं। केवल 6 को राशि में छोड़ते हुए ... आप हमेशा स्कोर को शीर्षक में रख सकते हैं, भी।
— AJFaraday
ओह, मैं गलत था, मैंने केवल पहले और आखिरी को हटाने के लिए सोचा था। मैं इसे फिर संशोधित करूंगा :)
— रिक रॉन्गेन
2

पीएचपी

<?php

error_reporting(E_ALL);

$url = 'http://easter_egg_hunt.andrewfaraday.com';
extract(json_decode(file_get_contents("$url/new_game"), true));

$i = $j = 51;
$step = 50;
$right = false;

while(!$right) {
  extract(json_decode(file_get_contents(sprintf("$url/guess/$game_id/%d/%d", $i, $j)), true));
  $lower = -$higher = $step /= 2;
  $i += $$x;
  $j += $$y;
  $right = !($$x || $$y);
}

printf('{game_id: %s; x: %2d; y: %2d; turns: %d}', $game_id, $i, $j, $turns);

File_get_contents और json_decode का उपयोग करना ।

जहाँ तक मैं बता सकता हूँ , एक अक्ष पर औसतन ५. one चालों के साथ एक इष्टतम रणनीति की आवश्यकता होती है, और दो अक्षों पर औसत ६.४ average average६ चालें चलती हैं।

10 का नमूना

{game_id: pfmyldcsltlbtmcfjtqr; x: 76; y: 51; turns: 6}
{game_id: jnmshsfvstcmksdcdrnj; x: 40; y:  5; turns: 7}
{game_id: wsrptrymycxjfxwvdvlh; x: 55; y: 35; turns: 7}
{game_id: fxpxtqwnxstwcxbsqtwc; x: 73; y: 93; turns: 6}
{game_id: zppntvjxnjpnlmpfzcfj; x: 71; y: 76; turns: 6}
{game_id: fzvlxqgrxcvtbbydgrpj; x: 48; y: 51; turns: 6}
{game_id: hqytpzjxkfhqhhwwfryd; x: 23; y: 87; turns: 6}
{game_id: ldsbfgcqbqpxgdhtkxsm; x: 90; y: 81; turns: 5}
{game_id: shypwsmjljyqdvwcwnxv; x: 19; y: 57; turns: 7}
{game_id: bsfrhhrvmpqfvyhjxcwh; x: 82; y: 85; turns: 6}

स्कोर: 6 + 6 + 6 + 6 + 6 + 7 = 37

गोल्फ, 245 बाइट्स

<?$e="extract(json_decode(file_get_contents('http://easter_egg_hunt.andrewfaraday.com";eval("$e/new_game".$f="'),1));");
for($i=$j=$h=50;!$url;$l=-$h/=2)eval("$e/guess/$game_id/".-~($i+=$$x[0]).'/'.-~($j+=$$y[0]).$f);
echo$game_id,~$i,~$j,-$turns;

नमूना आउटपुट

$ php egg-hunt.php
hgzqmqyrznglsdwfwcft-9-86-7
— Primo
स्रोत
2

हास्केल, कुल स्कोर 66 40

(संपादित करें: स्कोरिंग में उच्चतम और निम्नतम परिणाम छोड़ने के बारे में याद किया गया)

मैं सिर्फ बाइनरी खोज का उपयोग कर रहा हूं। निश्चित नहीं है कि अगर धोखा देने के बिना औसतन 6.5 प्रति प्रयास से बेहतर पाने का कोई तरीका है (मुझे लगता है कि मैं सिर्फ 10 का सेट चालू रख सकता हूं जब तक कि मुझे बेहतर स्कोर नहीं मिलता है, लेकिन इसमें मज़ा कहाँ है?)।

आह, वैसे बहुत मजेदार चुनौती है। यह विचार सभी के लिए समावेशी होने के लिए काफी सरल है, और मैं आमतौर पर अपने दिन के काम में वेब APIs के साथ सौदा नहीं करता हूं और मैं सिर्फ कोशिश करने के लिए एक बहाने के लिए खुजली कर रहा था servant, इसलिए इसके लिए धन्यवाद :) शायद आप इतने महान नहीं हैं ' प्रतियोगिता के लिए उम्मीद कर रहा हूं, लेकिन मुझे लगता है कि इस तरह की चुनौतियों का इस्तेमाल शुरुआती और चीजों की तरह कोड नमूने एकत्र करने के लिए किया जा सकता है।

निष्पादन योग्य स्क्रिप्ट (एक खेल चलाता है और gameId और स्कोर की रिपोर्ट करता है):

#!/usr/bin/env stack
{- stack
   --resolver lts-11.2
   script
   --package servant
   --package servant-client
   --package http-client
   --package aeson
   --package text
-}

-- the above comments allow this to be run as a script if haskell-stack is installed.
-- Actual source starts here.
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module Main where

import Data.Aeson
import Servant.API
import Servant.Client
import qualified Network.HTTP.Client as HttpClient
import Data.Proxy
import Data.Text(Text)
import Text.Printf
import System.IO(stderr)

newtype GameID = GameID Text deriving (PrintfArg, ToHttpApiData)

instance FromJSON GameID where
  parseJSON = withObject "GameID" $ \o ->
    fmap GameID (o .: "game_id")

data Accuracy = Lower | Higher | Correct

readAccuracy :: Text -> Accuracy
readAccuracy t
  | t == "lower" = Lower
  | t == "higher" = Higher
  | t == "right" = Correct
  | otherwise = error $ printf "Unexpected accuracy text: \"%s\"" t

data GuessResult = GuessResult { xAccuracy :: Accuracy, yAccuracy :: Accuracy, turnCount :: Maybe Int }

instance FromJSON GuessResult where
  parseJSON = withObject "GuessResult" $ \o ->
    GuessResult
      <$> fmap readAccuracy (o .: "x")
      <*> fmap readAccuracy (o .: "y")
      <*> o .:? "turns"

type EggAPI =    "new_game" :> Get '[JSON] GameID
            :<|> "guess"
              :> Capture "game_id" GameID
              :> Capture "x" Int
              :> Capture "y" Int
              :> Get '[JSON] GuessResult

getNewGame :: ClientM GameID
makeGuess :: GameID -> Int -> Int -> ClientM GuessResult
getNewGame :<|> makeGuess = client (Proxy :: Proxy EggAPI)

data CoordinateRange = CoordinateRange { lowerBound :: Int, higherBound :: Int }

middleOfRange :: CoordinateRange -> Int
middleOfRange rng = lowerBound rng + (higherBound rng - lowerBound rng) `div` 2

adjustCoordinateRange :: Accuracy -> CoordinateRange -> CoordinateRange
adjustCoordinateRange Lower rng = CoordinateRange (lowerBound rng) (middleOfRange rng)
adjustCoordinateRange Higher rng = CoordinateRange (middleOfRange rng) (higherBound rng)
adjustCoordinateRange Correct rng = rng

searchForEggs :: ClientM (GameID, Int)
searchForEggs = do
  game <- getNewGame
  let initialRange = CoordinateRange 1 100
  score <- loop game initialRange initialRange
  return (game, score) where
    loop gId xRange yRange = do
      guessResult <- makeGuess gId (middleOfRange xRange) (middleOfRange yRange)
      let newXRange = adjustCoordinateRange (xAccuracy guessResult) xRange
          newYRange = adjustCoordinateRange (yAccuracy guessResult) yRange
      maybe (loop gId newXRange newYRange) return $ turnCount guessResult

main :: IO ()
main = do
  manager' <- HttpClient.newManager HttpClient.defaultManagerSettings
  let clientEnv = mkClientEnv manager' (BaseUrl Http "easter_egg_hunt.andrewfaraday.com" 80 "")
  result <- runClientM searchForEggs clientEnv
  case result of
    Left err -> hPrintf stderr  "Error: %s\n" (show err)
    Right (game, score) -> printf "GameID: %s | Score: %d\n" game score

परिणाम

GameID               |  Score
---------------------+-------
fdcbwwxkvhkfskqlpgnh |  7
cdgjnksfnrhgjjsdbnhd |  7
lbjjqgkvfzzprnrxcpsx |  6
rtbngkdlwdfmhdyggnjd |  6
rcphvxzzgblfnzxdqlyh |  6
gyfjbjmplkrfnqjptygl |  7
bkdnbqhsbhwwvgtcfhjb |  6
knjdxdmvttwgltjdpvtv |  7
zqpstnhjgsykkwxnxcbv |  7
rccpmsbfxqvsmzxckhcs |  7
— घन
स्रोत
2

जावास्क्रिप्ट, 35 अंक

पोस्ट करना ungolfed कोड है नहीं मेरे साथ अच्छी तरह से बैठते हैं! : डी

(async _=>{
    url=`https://crossorigin.me/http://easter_egg_hunt.andrewfaraday.com/`
    promise=await fetch(url+`new_game`)
    json=await promise.json()
    id=json.game_id
    max={x:100,y:100}
    min={x:0,y:0}
    (guess=async (x,y)=>{
        promise=await fetch(url+`guess/${id}/${x|=0}/${y|=0}`)
        json=await promise.json()
        turns=json.turns
        if(turns)
            console.log(`{game:"${id}",turns:${turns},x:${x},y:${y}}`)
        else{
            switch(json.x){
                case`higher`:
                    min.x=x
                    x+=max.x
                    x/=2
                    break
                case`lower`:
                    max.x=x
                    x+=min.x
                    x/=2
            }
            switch(json.y){
                case`higher`:
                    min.y=y
                    y+=max.y
                    y/=2
                    break
                case`lower`:
                    max.y=y
                    y+=min.y
                    y/=2
            }
            guess(x,y)
        }
    })(50,50)
})()

स्कोरिंग: 5 + 6 + 6 + 6 + 6 + 6 = 35

बहुत भाग्यशाली हो गया, पोस्ट करने से पहले मेरे आखिरी टेस्ट पर 3 का स्कोर हासिल किया!

{game:"bjzkjzxwmksmbsbxtdzp",turns:3,x:75,y:12}
{game:"bvmhssnmzhlnykgxdkww",turns:5,x:93,y:71}
{game:"mcydbttxhcxwqymksgbg",turns:5,x:71,y:37}
{game:"xdynxrkxgsyltsfrqzll",turns:6,x:54,y:88}
{game:"wjdkclsqksnvdnwbspxq",turns:6,x:90,y:13}
{game:"mgvlssfgjcgtylwqpvhq",turns:6,x:26,y:68}
{game:"rgjvbkrlzqvpdfphqxtq",turns:6,x:19,y:81}
{game:"hgrscvfzgrkzzjvkjjwb",turns:6,x:41,y:19}
{game:"lrfrblmmkggghntshnkj",turns:7,x:86,y:32}
{game:"ldsndvjsbvgvbhbtfckp",turns:7,x:24,y:7}

कोशिश करो

ऊपर दिए गए कोड के थोड़े से गोल्फ संस्करण का उपयोग करना !

कोड स्निपेट दिखाएं

— झबरा
स्रोत
यह वास्तव में कोड गोल्फ नहीं है, आप स्पष्टता के लिए थोड़ा विस्तार कर सकते हैं यदि आप
— क्यूबिक
@ सार्वजनिक, तुम सही हो, मुझे शायद करना चाहिए! : DI यह अविश्वसनीय रूप से मुश्किल है कि बाइट्स के दौर को क्रंच न करें, यहां तक ​​कि जब यह कोड-गोल्फ नहीं है !
— शैगी
1

जंग

जैसा कि होता है, रस्ट के पास वास्तव में एक अच्छा deserialization पुस्तकालय है, serdeजिसने इस कार्यक्रम के साथ बहुत मदद की। एल्गोरिथ्म अपने आप में एक सरल बाइनरी खोज है, सिवाय दो बार भागे - एक बार के लिए xऔर एक बार के लिए y।

URL मैक्रो में कोई प्रारूप स्ट्रिंग के लिए एक विशिष्ट मामला है, क्योंकि यह बहुत अधिक मुफ्त में किया जा सकता है, और जब स्वरूपित नहीं होता है तो स्ट्रिंग को स्थिर भंडारण में संग्रहीत किया जाएगा।

Cargo.toml

[package]
name = "easter-egg-hunt"
version = "0.1.0"
authors = ["Konrad Borowski"]

[dependencies]
reqwest = "0.8.5"
serde = "1.0.36"
serde_derive = "1.0.36"

main.rs

extern crate reqwest;
extern crate serde;
#[macro_use]
extern crate serde_derive;

use reqwest::Client;

#[derive(Deserialize)]
struct NewGame {
    game_id: String,
}

#[derive(Deserialize)]
struct Guess {
    x: GuessStatus,
    y: GuessStatus,
    turns: Option<u32>,
}

#[derive(Deserialize)]
#[serde(rename_all = "lowercase")]
enum GuessStatus {
    Lower,
    Right,
    Higher,
}

macro_rules! url {
    ($path:expr) => {
        concat!("http://easter_egg_hunt.andrewfaraday.com", $path)
    };
    ($path:expr $(, $part:expr)*) => {
        &format!(url!($path) $(, $part)*)
    };
}

struct BinarySearch {
    low: u8,
    high: u8,
}

impl BinarySearch {
    fn new() -> Self {
        BinarySearch { low: 1, high: 100 }
    }

    fn current_guess(&self) -> u8 {
        (self.low + self.high) / 2
    }

    fn update(&mut self, guess_status: GuessStatus) {
        let current_guess = self.current_guess();
        match guess_status {
            GuessStatus::Lower => self.high = current_guess - 1,
            GuessStatus::Higher => self.low = current_guess + 1,
            GuessStatus::Right => {
                self.high = current_guess;
                self.low = current_guess;
            }
        }
    }
}

fn run_game(client: &Client) -> reqwest::Result<()> {
    let NewGame { game_id } = client.get(url!("/new_game")).send()?.json()?;
    let mut x_search = BinarySearch::new();
    let mut y_search = BinarySearch::new();
    loop {
        let x_guess = x_search.current_guess();
        let y_guess = y_search.current_guess();
        let response = client
            .get(url!("/guess/{}/{}/{}", game_id, x_guess, y_guess))
            .send()?
            .json()?;
        match response {
            Guess { x, y, turns: None } => {
                x_search.update(x);
                y_search.update(y);
            }
            Guess {
                turns: Some(turns), ..
            } => {
                println!("id:{} x:{} y:{} count:{}", game_id, x_guess, y_guess, turns);
                return Ok(());
            }
        }
    }
}

fn main() {
    let client = Client::new();
    for _ in 0..10 {
        run_game(&client).unwrap();
    }
}

सारांश

id:tlxjnjtslnsnbdxyzlvn x:97 y:22 count:7
id:bbzpyhhflrdjzylwxtbr x:21 y:6 count:5
id:kcjdkfvddgxckmprxwtw x:81 y:99 count:6
id:tnzryxpkblqrqbqrqkby x:30 y:25 count:7
id:pbzkdrmjrvwmkgmlvwcb x:79 y:20 count:7
id:qxvcbcslkdmjxnffsxfb x:36 y:94 count:7
id:hqfgpdmktyfwqtbrvvly x:94 y:71 count:5
id:ytgsnssvlpnhzqzgvygw x:1 y:83 count:7
id:gjhglmkbhvswqwgrynft x:65 y:94 count:5
id:rzghpypysxtwkclgpbkx x:55 y:96 count:7

5 + 6 + 7 + 7 + 7 + 7 = 39

— कोनराड बोरोस्की
स्रोत
1

अजगर २

गोल्फ की वेसरीन - 276 बाइट्स

from requests import*
u='http://easter_egg_hunt.andrewfaraday.com'
i=get('%s/new_game'%u).json()['game_id']
x=y=50;s=25;o={}
while not'turns'in o:o=get('%s/guess/%s/%d/%d'%(u,i,x,y)).json();exec("%s+=s*'rh'.rfind(o['%s'][0]);"*2)%tuple('xxyy');s=s%2+s/2
print i,x,y,o['turns']

अधिक पठनीय संस्करण + टिप्पणियाँ

from requests import*
u='http://easter_egg_hunt.andrewfaraday.com'
i=get('%s/new_game'%u).json()['game_id'] # get game id
x=y=50    # initial central position
s=25      # step of binary search
o={}      # initialize o to further store returns
while not'turns'in o:    # cycle until 'turns' occurs in return
    o=get('%s/guess/%s/%d/%d'%(u,i,x,y)).json()
    exec("%s+=s*'rh'.rfind(o['%s'][0]);"*2)%tuple('xxyy');s=s%2+s/2
    # this exec is used to shorten two similar lines for x and y:
    #  x += s * (... o['x'] ...); 
    #  s*'rh'.rfind(o['%s'][0]) - look at first letter of return and use its position in string 'rh' to map multipliers for step: 
    #                             -1 for lower, +1 for higher and 0 for right 
    #                             rfind() will return -1 for not finding l
    s=s%2+s/2    # divide step in two, rounding up
print i,x,y,o['turns']

परिणाम

vjwqvbydwmbvbrhwrxqz 19 95 4
svkdvszghjzfbvqxsprt 5 12 4
dvbpnxjdgrydwffcndnt 81 67 6
qqwgsctqhdcrbywwrcxf 21 49 6
zrgqqtzjjrrsqbgvkbsm 37 12 6
trzjngljbwbwxycxpcbk 91 2 7
kysjwfzsrdjsybrchnzg 76 45 7
kcjtxqfmcgszrwkyhlkm 68 48 7
wykbjvthqmcyzscxnsxt 68 41 7
kldrfccjdphzqnqcmdgz 88 14 7

सारांश

कुछ हद तक अपेक्षित: D
6 + 6 + 6 + 7 + 7 + 7 = 39

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