Ahhhh! जानवर HHHHere हैं!

19

जैसा कि हमने IBM PC AT, YouTube (वीडियो देखें) , विकिपीडिया (लेख देखें) , और तिल स्ट्रीट से सीखा है :

पत्र Hहै वर्णमाला के सबसे बेरहम पत्र !

(यहां तक ​​कि जब वास्तव में कोड पृष्ठ 437 में दो तत्वों से बना है । वास्तव में, यह उस तरह भी अधिक निर्दयी है।)

एलियंस की तरह, उम्म ... एर ... एलियंस , जानवर लगातार उन सभी का पीछा करते हैं जो अपने अंडों के पास आने की हिम्मत करेंगे। उनके साथ कोई तर्क नहीं है। यदि आप नष्ट नहीं करना चाहते हैं, तो आपको उन्हें स्क्वैश करना होगा।

4H क्लब के साथ एक भयावह मुठभेड़

इस परिदृश्य के लिए हम मान लेंगे कि आप अपने पिछले जीवन के लिए नीचे हैं, और आप बिना किसी अंडे (जैसे कि विकिपीडिया स्क्रीनशॉट में) के साथ एक भूभाग में सादे जानवरों से मिले हैं। आपके पास एक संख्यात्मक कीपैड नहीं है और केवल सीधे ऊपर / नीचे / बाएं / दाएं जा सकते हैं ... लेकिन जानवरों के पास स्पष्ट रूप से एक है, और अपनी बारी पर तिरछे स्थानांतरित कर सकते हैं।

अपने विकल्पों के बीच एक जानवर की पसंद का विकल्प वह होगा जो खिलाड़ी से दूरी को कम करता है। यदि दूरी बराबर होती है तो टाई ब्रेकिंग को बाएँ + दाएँ से ऊपर + नीचे की तरफ करने के लिए किया जाता है, लेकिन यहाँ इसके बारे में स्पष्ट होने के लिए विसंगति मैट्रिक्स है ... टाई-ब्रेक करने के लिए सबसे कम संख्या:

1 3 4
2 H 5
6 8 7

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

आप एक जानवर को कुचल देते हैं यदि आप चल दीवारों की एक ट्रेन को स्थानांतरित करते हैं जहां यह एक बंद खाई में बैठा था। ये सादे जानवर 2 अंक एक सिर के लायक हैं।

इनपुट

  1. स्तंभों की एक जोड़ी, जो स्तंभों में नक्शे के आकार का संकेत देती है।

  2. पंक्ति की पंक्ति की गणना, स्तंभ आकार में से प्रत्येक ... जिसमें या तो एक ठोस दीवार ( #), एक चल दीवार ( ~), एक जानवर ( H), खिलाड़ी ( O) या सिर्फ एक स्थान है।

  3. इनपुट जो कि U, D, L, R होगा, खिलाड़ी द्वारा किए गए प्रयास का संकेत होगा ... या W को बस इंतजार करना होगा। ध्यान दें कि एक जंगम दीवार को धक्का देने का प्रयास जो अवरुद्ध है कानूनी इनपुट है, यह सिर्फ बिना किसी कार्रवाई के परिणाम देगा।

उत्पादन

  1. aHHHH! अगर जानवरों ने खिलाड़ी को मार डाला ... या कुछ नहीं तो खिलाड़ी बिना किसी जानवर के शेष के साथ जीता

  2. स्कोर

(नोट: डिबगिंग के उद्देश्यों और / या मनोरंजन के लिए, आप संभवतः प्रत्येक चरण में राज्य का उत्पादन करने में सक्षम होना चाहते हैं, लेकिन यहां पोस्ट करने के लिए बहुत लंबा है।)

स्पष्टीकरण

  • नक्शे को ठोस दीवारों से बंधे होने की गारंटी है।

  • जो बदले में चलता है उसका क्रम परिणाम के लिए मायने रखता है। इस प्रकार: खिलाड़ी हमेशा पहले जाता है, फिर जानवरों को उनकी प्रारंभिक मानचित्र स्थिति के आधार पर एक आदेश दिया जाता है यदि आप स्क्रीन के ऊपर से नीचे दाएं से बाएं ऊपर की तरफ स्वीप कर रहे थे। (एक पंक्ति 1 जानवर एक पंक्ति 2 जानवर से पहले चलती है, और एक ही पंक्ति पर दो जानवर यह सबसे कम स्तंभ संख्या वाला एक होगा जो दूसरे से पहले चलेगा)

  • विकर्ण चलती जानवर किसी भी खुले आसन्न विकर्ण स्थान में जा सकते हैं, भले ही इसके लिए दीवारों के बीच निचोड़ने की आवश्यकता हो।

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

  • एक मोड़ के दौरान जानवर की चाल का निर्णय खिलाड़ी के स्थान पर टर्न की शुरुआत पर आधारित होता है । "डिस्टेंस टू प्लेयर" का इसका वांछित अनुकूलन "के रूप में कौवा मक्खियों" की गणना है। कोई भी सन्निकटन जो अपने वर्ग के केंद्र से खिलाड़ी के वर्ग के केंद्र तक मापे गए परिणाम को ठीक देगा।

  • यदि कोई जानवर ऐसा नहीं कर सकता है जो एक मोड़ में उसकी पहली पसंदीदा चाल होगी, क्योंकि एक उच्च प्राथमिकता वाले जानवर ने उसका स्थान ले लिया, तो वह अपने अगले सबसे अच्छे विकल्प को जगह में रहने का विरोध करेगा (यदि एक चाल अभी भी संभव है)।

नमूना मामलों

सिंपल क्रश

इनपुट

5 3
#####
#O~H#
#####
R

उत्पादन

2

वरीयता मैट्रिक्स -> मौत

इनपुट

5 5
#####
#O  #
# ~ #
#  H#
#####
WWDW

उत्पादन

aHHHH!
0

वरीयता मैट्रिक्स -> जीत

इनपुट

5 5
#####
#O  #
# ~ #
#  H#
#####
WRD

उत्पादन

2

लावक की प्रतीक्षा में

इनपुट

5 5
#####
#O  #
# ~ #
#  H#
#####
WWW

उत्पादन

aHHHH!
0

विकिपीडिया परिदृश्य में सफल हार

इनपुट

40 23
########################################
#~      ~ ~~  ~  ~ ~~   ~ ~~    ~ ~ ~~ #
#~~ ~          ~~   ~   ~ ~~         ~ #
#~# ~~   ~~~~      ~  ~~~~  ~    ~~~  ~#
# ~        ~   ~ ~~ #~~       ~        #
#~~  ~~~   ~ ~ ~      ~ ~~ ~  ~  ~  ~  #
#     ~~  ~  ~ ~ ~~~       H    ~  #~  #
#  O~  ~  #  ~~~ ~      ~ ~~  ~  ~ ~~  #
#       ~ ~H~~   ~~ ~ #        ~~   ~  #
# ~~         ~ ~~~  ~~   ~~~~      ~  ~#
#~  ~    ~~~  ~   ~        ~   ~ ~~  ~~#
#     ~      # ~ ~~  ~~~   ~ ~ ~ #    ~#
#~ ~ ~~  ~  ~   H     ~~  ~~ ~ ~ ~~~   #
#       ~   ~   ~   ~  ~     ~~~ ~     #
# ~~  ~  ~ ~~   ~       ~ ~ ~     ~    #
#      ~~   ~   ~  ~         ~      ~~ #
#~ ~     #    ~~~~  ~    ~~~H   # ~    #
#  ~   ~ ~   ~        ~          ~~  ~ #
#  ~   ~     #~  ~   ~~  ~  ~         ~#
# ~~ ~ ~  ~~                ~   ~      #
#    ~~~        ~ ~~  ~  ~  ~   ~      #
# ~ ~     ~            ~~   ~   ~  ~   #
########################################
RRRUWWWRRRURWWWWRDRRWWRDWWWWD

उत्पादन

8

मेरे द्वारा प्रदत्त मानचित्र, चाल और आउटपुट @bobbel द्वारा, अपने आप को और @Allbeert द्वारा पुष्ट।

जीत का मानदंड

मुझे लगता है कि यह गोल्फ है, इसलिए मैं कोड गोल्फ नियमों के साथ जाऊंगा जब तक लोग शिकायत नहीं करते।

अतिरिक्त श्रेय

छवि के समान डबल-वाइड वर्णों के साथ खेलने योग्य यूनिकोड कार्यान्वयन!

code-golf  game  maze 
— डॉ। रीबमू
स्रोत
क्या विकर्ण आंदोलनों दीवारों की एंटीडायंगल लाइनों पर कूदते हैं? यह देखते हुए कि एक जानवर हर मोड़ पर एक चाल बनाता है, यह दो क्षैतिज चालों या दो ऊर्ध्वाधर चालों के बीच दूरी संबंध कैसे तोड़ता है? क्या यह उस स्थान की ओर बढ़ता है जहां खिलाड़ी मोड़ के प्रारंभ में था, या खिलाड़ी के आंदोलन के बाद? जब आप कहते हैं "जंगम दीवारों की ट्रेन", तो क्या इसका मतलब यह है कि खिलाड़ी किसी भी संख्या में चल रही दीवारों को एक पंक्ति में धकेल सकता है बशर्ते कि दूसरे छोर पर एक जगह या जानवर हो?
— पीटर टेलर
2
मैं सही ढंग से समझ रहा हूँ, तो दूसरे उदाहरण, गलत है क्योंकि pastebin.com/raw.php?i=CqPJPjTR ।
— दरवाज़े
1
@ डॉ.रेम्बु: आम तौर पर मुझे आपका काम बहुत पसंद है, लेकिन इसके लिए कई सवाल हैं। स्पष्टीकरण देने के लिए धन्यवाद! तो, अगला: इस द्वि-जानवर स्थिति के बारे में क्या: pastebin.com/raw.php?i=FENVAkCH मेरी धारणा सही है?
— bobbel
1
एक और सवाल: क्या होगा यदि आप दीवारों की एक ट्रेन को एक जानवर में स्थानांतरित कर दें जो 'पिन डाउन' नहीं है? pastebin.com/raw.php?i=isN4L6pJ
— क्लाउडीयू
3
@ बब्बल मैन, प्रश्न लिखना उन्हें हल करने से ज्यादा कठिन है! :-) मैं कहता हूं कि अभी भी नहीं रहने के लिए जानवरों की प्रवृत्ति को देखते हुए, वे अपना अगला सबसे अच्छा कदम उठाएंगे यदि उपलब्ध होने के बजाय अपनी चाल को आगे बढ़ाएं, यदि उच्च प्राथमिकता वाले जानवर ने अपना आदर्श स्थान लिया। स्पष्ट किया।
— डॉ। रेम्बू

जवाबों:

3

पर्ल 6: 741 अक्षर, 758 बाइट्स

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

उपयोग की तरह है perl6 beast.p6 beast-input:

use Term::ANSIColor;
class BeastGame {
    enum BeastParts <None Player Beast M-Wall S-Wall>;

    has @.board;
    has Int $.turn = 0;
    has Int $.score = 0;

    method indices (\matcher) {
        @.board.pairs.map: {
            .key*i X+ .value[].pairs.map: {
                .key if .value ~~ matcher
            }
        }
    }
    multi postcircumfix:<[ ]> (BeastGame \SELF, Complex \c) is rw { SELF.board[c.im][c.re] }

    has Complex $!player;
    method player { $!player = $.indices(Player)[0] }
    method Bool { so $.indices(Player) & $.indices(Beast) }

    method new (@lines) {
        my @board = @lines.map:
            {[ %(' ',<O H ~ #> Z=> None, Player, Beast, M-Wall, S-Wall){ .comb } ]}

        self.bless: :@board
    }
    method gist {
        state @symbol-map = map {colored .key, .value~' on_black'},
            ('  ',<◄► ├┤ ▒▒ ██> Z=> <default cyan red green yellow>);

        @.board.map({ @symbol-map[@$_].join }).join("\n")
    }

    method step ($d) {
        my $direction = %(:W(0), :L(-1+0i), :R(1+0i), :U(-1i), :D(1i)){$d};
        $direction // return self;
        self.move($.player,$direction);

        if ++$!turn %% 2 {
            for $.indices(Beast).eager -> $c {
                for (-1-1i,-1+0i,-1i,1-1i,1+0i,-1+1i,1+1i,1i,0i)\
                        .sort({abs $c + $^d - $!player})
                {
                    last if self.move($c, $_).defined;
                }
            }
        }

        self;
    }
    method move ($cur, $by) {
        return $cur if $by == 0;

        my $to = $cur + $by;
        my &cur-is  = { self[$cur] ~~ $^o }
        my &next-is = { self[$to]  ~~ $^o }
        return if cur-is S-Wall;
        (self[$to], self[$cur]) = (self[$cur], None)
            if next-is None
            # Move wall
            or cur-is Player | M-Wall and next-is M-Wall and self.move($to, $by)
            # Kill Player
            or cur-is Beast  and next-is Player
            # Squish Beast
            or cur-is M-Wall and next-is Beast  and self[$to+$by] ~~ M-Wall|S-Wall and $!score += 2
    }
}
my $width = get.words[1];
my $game  = BeastGame.new(lines[^$width]);
my @commands = '',lines.comb,{$*IN.get.comb}...*;

while $game {
    $game.step: @commands.shift;
    print "\e[2J";
    print "\e[H";
    say $game;
}

say "aHHHH!" unless $game.player;
say $game.score;

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

my ($u,$s,$m)=0,0;my@b=lines[^get.words[1]].map:{[%(' ',<O H ~ #>Z=>^5){.comb}]}
my@a='',lines.comb,{$*IN.get.comb}...*;sub g(\c)is rw {@b[c.im][c.re]}
my&n=->\o{@b.kv.map:{$^k*i X+$^v[].kv.map:{$^l if $^w==o}}}
my&p={$m=n(1)[0]}
my&M=->$c,$b{my$t=$c+$b;my&c={$^o==g $c}
my&x={$^o==g $t}
c(4)??0!!$b??(($c,$t)».&g=(0,g $c)
if x(0)||c(1|3)&&x(3)&&M($t,$b)||c(2)&&x(1)||c(3)&&x(2)&&2 <g($t+$b)&&($s+=2))!!1}
while n(1)&n(2) {for 1
{M p,%(:W(0),:L(-1),:R(1),:U(-1i),:D(1i)){@a.shift}//last;if $u++%2
{for n(2).eager ->$c{last if M $c,$_
for(-1-1i,-1+0i,-1i,1-1i,1+0i,-1+1i,1+1i,1i,0i).sort({abs $c+$_-$m})}}}
say "\e[2J\e[H",join "\n",map {[~]
(map {"\e[$^v;40m$^k\e[0m"},'  ',<39 ◄► 36 ├┤ 31 ▒▒ 32 ██ 33>)[@$_]},@b}
say "aHHHH!" if !p;say $s;

हैप्पी ईस्टर!

— Mouq
स्रोत
यह कोड गोल्फ नियम है, इसलिए इसे देखते हुए, आपका समाधान जीत जाता है ... भले ही मैं खुद पर्ल को बहुत पसंद नहीं करता हूं। ; सांत्वना और रंग के साथ अच्छा काम!
— डॉ। रेबमु
14

जावा, 1,843

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

इसे आज़माने के लिए, आपको एक क्लास बनाना होगा Cऔर कोड पेस्ट करना होगा। args[0](सख्ती से बोलना a[0]) इनपुट के लिए है। मानचित्र का प्रिंट तरीका शामिल नहीं है क्योंकि यह पहेली आउटपुट के लिए आवश्यक नहीं है।

class C{static char                    [][]C;static int A=
0,B=0,D=0,E=0,F=0,G                    = 0 ; public static
void main(String[]a                    ){String []b= a[0].
split("\n");int c =                    Byte. decode(b [0].
split(" ")[1]); G=a                    [ 0 ] . replaceAll(
"[^H]","").length()                    ; String d = b [ b.
length - 1 ] ;C=new                    char[c][];for(int e
=1;e<b.length-1;e++                    ) C [ e - 1 ]=b[e].
toCharArray ( ) ; f                    ();boolean X= 0> 1;
for ( char  g : d .                    toCharArray ( ) ) {
switch(g){case 'U':                    h(0,-1);break; case
'D':h(0, 1); break;                    case 'L':h( -1, 0);
break;case'R':h(1,0                    );}if(X)i();X=!X;f(
);}System.out.print                    (D);}static void f(
){for(int a= 0;a<C.                    length;a++)for( int
b=0;b<C[a].length;b                    ++)if(C[a][b]=='O')
{A=b;B= a;}}static void h(int x,int y){E =x;F =y;switch(C[
B +y][A +x]){case 'H':g();break;case ' ':j(A,B);break;case
'~':k();}}static void i(){if(G<1){return;}int[][]l=new int
[G][];int m=0;for(int r=0;r<C.length;r++){for(int c=0;c<C[
r].length; c++){if(C[r][c]=='H'){l[m++]=new int[]{c,r};}}}
for(int[]n:l){o(n[0],n[1]);}} static void o(int a, int b){
int[]c=d (a,b);E=c[0];F =c[1];if(E !=0||F !=0){ j(a,b);} }
static int[]d(int a,int b){int[][]d={{1,3,4},{2,0,5},{6,8,
7},};int[]e=new int[]{0,0};double f=999;for(int r=-1;r<2;r
++){for(int c=-1;c<2;c++){if(C[b+r][a+c]==' '||C[b+r][a+c]
=='O'){int g=a+c-A;                    int h=b+r-B; double
i=Math.sqrt(g*g+h*h                    );if(i<f){e=new int
[]{ c,r};f =i;}else                    if(i==f){if(d[r+1][
c+1]<d[e[1]+1][e[0]                    +1]){e=new int[]{c,
r};}}} }}return e;}                    static void k(){if(
p(E,F,false)){q(E,F                    );} }static void q(
int x,int y){switch                    (C[B+y][A+x]){ case
'~':q(x+E,y+F);case                    'H':case ' ':j(A+x-
E,B+y- F);}} static                    boolean p(int x,int
y,boolean h){switch                    (C[B+y][ A+x]){case
' ':return !h; case                    '~':return h?h:p(x+
E,y +F, false);case                    'H':return h?!h:p(x
+E , y+ F, true) ;}                    return h&&C[B+y][A+
x] == '#' ; }static                    void j(int a,int b)
{char c=C[b][a];if(                    C[b+F][a+E]=='O'){g
();}else if(C[b+F][                    a+E]=='H'){D+=2;G--
;c=C[b][a];C[b][a]=                    ' ';}else{C[b][a]=C
[b+F][a+E];}C[b+F][                    a+E]=c;}static void
g () { System .out.                    print("aHHHH!\n"+D)
;     System      .                    exit  ( 0  ) ;  } }

इसे चलाने के लिए, उदाहरण के लिए प्रयास करें:

root@host:/cygdrive/c/workspace/project/bin> java C "5 5
> #####
> #O  #
> # ~ #
> #  H#
> #####
> WWDW"
aHHHH!
0
root@host:/cygdrive/c/workspace/project/bin>

एक जानवर खिलाड़ी को खाने से पहले आखिरी बड़े परिदृश्य का आउटपुट:

████████████████████████████████████████████████████████████████████████████████
██▓▓            ▓▓  ▓▓▓▓    ▓▓    ▓▓  ▓▓▓▓      ▓▓  ▓▓▓▓        ▓▓  ▓▓  ▓▓▓▓  ██
██▓▓▓▓  ▓▓                    ▓▓▓▓      ▓▓      ▓▓  ▓▓▓▓                  ▓▓  ██
██▓▓██  ▓▓▓▓      ▓▓▓▓▓▓▓▓            ▓▓    ▓▓▓▓▓▓▓▓    ▓▓        ▓▓▓▓▓▓    ▓▓██
██  ▓▓                ▓▓      ▓▓  ▓▓▓▓  ██▓▓▓▓              ▓▓                ██
██▓▓▓▓    ▓▓▓▓▓▓      ▓▓  ▓▓  ▓▓            ▓▓  ▓▓▓▓  ▓▓    ▓▓    ▓▓    ▓▓    ██
██          ▓▓▓▓    ▓▓    ▓▓  ▓▓  ▓▓▓▓▓▓                        ▓▓    ██▓▓    ██
██          ▓▓▓▓    ██    ▓▓▓▓▓▓  ▓▓            ▓▓  ▓▓▓▓    ▓▓    ▓▓  ▓▓▓▓    ██
██              ▓▓  ▓▓  ▓▓▓▓      ▓▓▓▓  ▓▓  ██                ▓▓▓▓      ▓▓    ██
██  ▓▓▓▓                  ▓▓  ▓▓▓▓▓▓    ▓▓▓▓  ├┤  ▓▓▓▓▓▓▓▓            ▓▓    ▓▓██
██▓▓    ▓▓    ├┤◄►▓▓▓▓▓▓├┤  ▓▓      ▓▓                ▓▓      ▓▓  ▓▓▓▓    ▓▓▓▓██
██          ▓▓            ██  ▓▓  ▓▓▓▓    ▓▓▓▓▓▓      ▓▓  ▓▓  ▓▓  ██        ▓▓██
██▓▓  ▓▓  ▓▓▓▓    ▓▓    ▓▓                  ▓▓▓▓    ▓▓▓▓  ▓▓  ▓▓  ▓▓▓▓▓▓      ██
██              ▓▓      ▓▓      ▓▓      ▓▓    ▓▓├┤        ▓▓▓▓▓▓  ▓▓          ██
██  ▓▓▓▓    ▓▓    ▓▓  ▓▓▓▓      ▓▓              ▓▓  ▓▓  ▓▓          ▓▓        ██
██            ▓▓▓▓      ▓▓      ▓▓    ▓▓                  ▓▓            ▓▓▓▓  ██
██▓▓  ▓▓          ██        ▓▓▓▓▓▓▓▓    ▓▓        ▓▓▓▓▓▓        ██  ▓▓        ██
██    ▓▓      ▓▓  ▓▓      ▓▓                ▓▓                    ▓▓▓▓    ▓▓  ██
██    ▓▓      ▓▓          ██▓▓    ▓▓      ▓▓▓▓    ▓▓    ▓▓                  ▓▓██
██  ▓▓▓▓  ▓▓  ▓▓    ▓▓▓▓                                ▓▓      ▓▓            ██
██        ▓▓▓▓▓▓                ▓▓  ▓▓▓▓    ▓▓    ▓▓    ▓▓      ▓▓            ██
██  ▓▓  ▓▓          ▓▓                        ▓▓▓▓      ▓▓      ▓▓    ▓▓      ██
████████████████████████████████████████████████████████████████████████████████

बिना मूर्खतापूर्ण रेखा के रिक्त स्थान: http://pastebin.com/raw.php?i=QhpxKcCT

तो खिलाड़ियों का रास्ता चालों के बाद समाप्त हो रहा है RRDDDRRRWW, क्योंकि अंतिम Wएइटी पर, बाईं ओर का जानवर खिलाड़ी को खाने के लिए दाईं ओर जाएगा।

मूल बड़े नक्शे का एक और उदाहरण लेकिन अलग-अलग चालें:

http://pastebin.com/raw.php?i=nBWjC3PZ

इस एनीमेशन को देखें: http://youtu.be/0DIhEhjWd6s

और मूल नक्शे और अलग चाल (नए जानवर आंदोलन के नियमों के अनुसार) के साथ अंतिम उदाहरण:

http://pastebin.com/raw.php?i=NNmgzx7U

यूट्यूब पर देखें: http://youtu.be/jXPzL88TU2A

— bobbel
स्रोत
1
HHHa! :-) बहुत ही शांत। जब तक आप इसे प्राप्त कर लेते हैं, तब तक कुछ गेम खेलने की देखभाल करें और उस मानचित्र पर अधिक परीक्षण केस डेटा दें?
— डॉ। रेब्बू
मैंने मूल नक्शे और विभिन्न चालों के साथ एक नया परिदृश्य जोड़ा है। लेकिन आप वास्तव में चरणों का पालन नहीं कर सकते, क्योंकि मैं
— पास्टबिन के
इसलिए, मैंने एनीमेशन के रूप में परिणाम देखने के लिए एक वीडियो जोड़ा!
— बोबेल
अच्छा वीडियो ... हालांकि यह जानवरों को किसी भी मज़ेदार होने के लिए बहुत तेज़ी से ले जाता है! क्या हमें नियम को बदलना चाहिए ताकि वे हर मोड़ के बजाय हर दूसरे मोड़ पर जाएं?
— डॉ। रेब्बू
मुझे कोई आपत्ति नहीं है। मेरे लिए लगभग दस बाइट्स! लेकिन मैं पूरी तरह से सहमत हूं। यह अब जीतना कठिन है जैसे :)
— बॉब
5

सी - 1004 984 917

आह, सी। की सुंदरता अन्य उत्तर की भावना के बाद, मैंने मेरा भी प्रारूप बनाने की कोशिश की :)

मुझे लगता है कि अभी भी यहां और वहां कुछ सुधार हैं, लेकिन यह वास्तव में लिखने और गोल्फ के लिए मजेदार था। वर्ण गणना में सभी आवश्यक स्थान और नई लाइनें शामिल हैं।

#define M(y,x,c) {t[y][x]=32;t[p][q]=c;y=p;x=q;}
   #define E {printf("aHHHH!\n%d",Z);exit(0);}
    #define A sqrt(pow(X-Q,2)+pow(Y-P,2))*30
           #define L (char)(m[s]>>8)
            #define G (char)(m[s])
             #define B(b) if(T==b)
              #define J M(Y,X,79)
               #define T t[P][Q]

r,c,X,Y,H,i,j,k,Z,p,q,P,Q,u,v,s,w,m[99],b[8]={
-1,255,65280,65281,1,511,257,256},t[999][999],
x[99],y[99];main(){char N[99];m[85]=b[2];m[68]
=256;m[76]=255; m[82]=1; scanf("%d %d",&c,&r);
for(;P<r;P++)                    for(Q=0;Q<c&&
scanf("%c",&T                    );T-10&&T-13?
Q++:Q){B(79){                    Y=P;X=Q;}B(72
){y[H]=P ;x[H                    ++]=Q;}}scanf
("%s",N);for(                    ;i<strlen(N);
i++){s=N[i];P                    =p=Y+L;Q=q=X+
G;B(32)J B('~')                  {while(P+=L,Q
+=G,T=='~');B                    (72){u=P+L;v=
Q+G;if(t[u][v]                   ==35||t[u][v]
=='~'){Z+=2;T=                   '~';J}}B(32){
T='~';J}}else                    B(72)E if(r=!r)
for(j=0;j<H;j                    ++){P=y[j];Q=
x[j];if(T-72)continue;v=A;s=0;for(k=0;k<8;k++)
{P=y[j]+(char)(b[k]>>8);Q=x[j]+(char)(b[k]);u=
A;B(32)if((c=v-u+99)>s){s=c;q=Q;p=P;}B(79)E}if
(s)M(y[j],x[j],72)}}printf("%d",Z);}//////////

मैंने सभी नमूना मामलों और कुछ और खानों के साथ इसका परीक्षण किया, और यह ठीक से काम करता हुआ प्रतीत होता है। अगर किसी को ऐसी कोई स्थिति मिलती है जिसमें वह ठीक से जवाब नहीं देता है, तो कृपया मुझे बताएं।

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

Ungolfed संस्करण:

#define M(y,x,c) {t[y][x]=32;t[p][q]=c;y=p;x=q;}
#define E {printf("aHHHH!\n%d",Z);exit(0);}
#define A sqrt(pow(X-Q,2)+pow(Y-P,2))*30
#define L (char)(m[s]>>8)
#define G (char)(m[s])
#define B(b) if(T==b)
#define J M(Y,X,79)
#define T t[P][Q]

r, c, X, Y, H, i, j, k, Z, p, q, P, Q, u, v, s, w, m[99], b[8] = { -1, 255,
        65280, 65281, 1, 511, 257, 256 }, t[999][999], x[99], y[99];
main() {
    char N[99];
    m[85] = b[2];
    m[68] = 256;
    m[76] = 255;
    m[82] = 1;
    scanf("%d %d", &c, &r);
    for (; P < r; P++)
        for (Q = 0; Q < c && scanf("%c", &T);T-10&&T-13?Q++:Q) {
            B(79) {
                Y=P;
                X=Q;
            }
            B(72) {
                y[H]=P;
                x[H++]=Q;
            }
        }

    scanf("%s", N);
    for (; i < strlen(N); i++) {
        s = N[i];
        P = p = Y + L;
        Q = q = X + G;
        B(32)
            J
        B('~') {
            while (P += L, Q += G, T=='~');
            B(72) {
                u=P+L;
                v=Q+G;
                if(t[u][v]==35||t[u][v]=='~') {
                    Z+=2;
                    T='~';
                    J
                }
            }
            B(32) {
                T='~';
                J
            }
        } else B(72)E
        if (r = !r)
            for (j = 0; j < H; j++) {
                P = y[j];
                Q = x[j];
                if (T-72)
                continue;

                v = A;
                s = 0;

                for (k = 0; k < 8; k++) {
                    P = y[j] + (char) (b[k] >> 8);
                    Q = x[j] + (char) (b[k]);
                    u = A;
                    B(32)
                        if ((c = v - u + 99) > s) {
                            s = c;
                            q = Q;
                            p = P;
                        }

                    B(79)
                        E
                }
                if (s)
                    M(y[j], x[j], 72)
            }
    }
    printf("%d", Z);
}
— Allbeert
स्रोत
अच्छा !! हालांकि बड़े नक्शे पर @ bobbel के इनपुट RRRUWWWRRRURWWWWRDRRWWRDWWWWD पर, आपको 6 मिलते हैं जबकि वह 8 हो जाता है। उसने एक वीडियो बनाया , आप शायद प्रत्येक चरण को प्रिंट कर सकते हैं और किसी भी विसंगति को देख सकते हैं ...
— डॉ। रेम्बु
(यह देखते हुए कि मैंने जानवरों को हर-दूसरे को
— घुमाने के
ईमानदार होने के लिए: मुझे यकीन नहीं है, अगर मेरा समाधान 100% ठीक से काम करता है, तो भी। लेकिन यह मुझे ऐसा लगता है :)
— bobbel
@ Dr.Rebmu मुझे एहसास हुआ कि आपने मेरे द्वारा पोस्ट किए गए समय के आसपास ही प्रश्न संपादित किया है। तो मैंने बस एक त्वरित हैक किया जो प्रतीत होता है कि काम किया। मैं इसे इस सप्ताह के अंत में दोबारा देखूंगा और इसे अपडेट करूंगा। मैं एक "अच्छा" संस्करण भी पोस्ट करूंगा ताकि किसी भी त्रुटि को अन्य लोगों द्वारा स्पॉट करना आसान हो सके :)
— Allbeert
FWIW मैं आज इसे Rebol में हल कर रहा हूं और 8 के साथ @ bobbel का उत्तर भी प्राप्त कर रहा हूं।
— डॉ। रेबमू
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.