जादू: क्षमताओं के साथ सभा का मुकाबला

16

सम्बंधित

लक्ष्य:

वैकल्पिक मुकाबला क्षमताओं के साथ दो प्राणियों को देखते हुए, अद्वितीय लेकिन सुसंगत मान लौटाते हैं जो यह दर्शाता है कि किस जीव की मृत्यु हुई, यदि कोई हो।

इनपुट:

#Longest form:
[[P,T, "<abilities>"], [P,T, "<abilities>"]]
#Shortest form:
[[P,T], [P,T]]

प्रत्येक प्राणी के रूप में दिया जाएगा [P,T,"<abilities>"]। यह रूप में होगा [P,T], [P,T,""]या [P,T,0]यह कोई क्षमताओं, प्रपत्र पर अपनी पसंद है या नहीं। P एक पूर्णांक है> = 0, T एक पूर्णांक> = 1 है। <abilities>का एक सबसेट है "DFI", या यदि आप चाहें तो एक ही नंबर / बिटस्ट्रिंग के माध्यम से प्रतिनिधित्व किया जा सकता है। झंडों का ऑर्डर भी आपके ऊपर है।

लड़ाकू यांत्रिकी:

प्रत्येक प्राणी के पास उस क्रम में दो आँकड़े, शक्ति और कठिनता और वैकल्पिक क्षमताएं होती हैं। एक प्राणी की शक्ति> = 0 है। एक प्राणी की कठिनता> 1 = है।

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

उदाहरण: एलिस एक है 2/2, बॉब एक ​​है 3/4, दोनों बिना किसी योग्यता के। एलिस बॉब को 2 नुकसान देगी और बदले में 3 नुकसान उठाएगी। ऐलिस की बेरहमी 2 है इसलिए यह मर जाएगा, बॉब की बेरहमी 4 है इसलिए यह जीवित रहेगा।

केवल 3 वैकल्पिक क्षमताएं हैं हम इसके लिए विचार करेंगे (हालांकि खेल में अधिक हैं)। ये एक वर्ण के झंडे होंगे:

  • [D] eathtouch: क्षति की किसी भी राशि (X> 0) को घातक माना जाता है।
  • [एफ] irst स्ट्राइक: पहले अपने नुकसान से निपटेंगे, दूसरे प्राणी को मारने से पहले वापस हमला कर सकते हैं। यदि दोनों प्राणियों में फर्स्ट स्ट्राइक है, तो लड़ाई को सामान्य रूप से हल करें।
  • [I] ndestructible: क्षति की कोई मात्रा घातक नहीं मानी जाती है, जिसमें डेथटच भी शामिल है।

आउटपुट:

निम्नलिखित चार मामलों में से प्रत्येक के लिए कोई सुसंगत मूल्य। कृपया अपने उत्तर में चार मान बताएं। उदाहरण रिटर्न में मान:

  • न तो प्राणी की मृत्यु हुई (0)
  • 1 प्राणी की मृत्यु (1)
  • दूसरा प्राणी मर गया (2)
  • दोनों प्राणियों की मृत्यु (3)

नियम:

  • इनपुट को दो सही ढंग से स्वरूपित प्राणियों की गारंटी है।
  • यदि आप क्षमताओं के लिए वर्णों का उपयोग कर रहे हैं, तो आप मान सकते हैं कि वे कैसे ऑर्डर करना चाहते हैं, लेकिन प्रासंगिक होने पर उपयोग किए गए ऑर्डर को पोस्ट करें।
  • यदि आप क्षमताओं के लिए एक नंबर / बिटस्ट्रिंग का उपयोग कर रहे हैं, तो पोस्ट करें कि आप किस एन्कोडिंग का उपयोग कर रहे हैं। जैसे: 111है D/F/I, 7है D/F/I, आदि।
  • यदि किसी प्राणी के पास कोई क्षमता नहीं है, तो उसे [P,T, ""]संख्या के बराबर या भी लिया जा सकता है
  • मानक Loopholes निषिद्ध
  • यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।

उदाहरण:

Input: [[2,2], [1,1]]
Output: 2nd Dies

Input: [[0,2], [0,1]] #0/2 vs 0/1
Output: Neither Die

Input: [[2,1], [2,1]] #2/1 vs 2/1
Output: Both Die

Input: [[1,1, "D"], [2,2]] #1/1 Deathtoucher vs 2/2 
Output: Both Die

Input: [[2,2], [0,1, "D"]] #2/2 vs 0/1 Deathtoucher
Output: 2nd Dies

Input: [[2,2], [1,1, "DF"]] #2/2 vs 1/1 Deathtouch First-striker 
Output: 1st Dies

Input: [[0,2, "D"], [0,1, "DF"]] #0/2 Deathtoucher vs 0/1 Deathtouch First-striker
Output: Neither Die

Input: [[2,2], [2,2, "F"]] #2/2 vs 2/2 First-striker
Output: 1st Dies

Input: [[2,2, "I"], [1,1, "DF"]] #2/2 Indestructible vs 1/1 Deathtouch First-striker
Output: 2nd Dies

Input: [[9999,9999], [1,1, "I"]] #9999/9999 vs 1/1 Indestructible
Output: Neither Die

Input: [[2,2, "F"], [1,1, "F"]] #2/2 First-Striker vs 1/1 First-Striker
Output: 2nd Dies

#9/9 Deathtouch, Indestructible First-Striker vs 9/9 Deathtouch, Indestructible First-Striker
Input: [[9,9, "DFI"], [9,9, "DFI"]] 
Output: Neither Die
code-golf  decision-problem  game 
— Veskah
स्रोत
1
@ user71546 हाँ। इसमें कुछ और नियम शामिल हैं लेकिन MtG में, "कैन्ट्स" ट्रम्प "कैन।" इसलिए कार्यात्मक रूप से, अविनाशी डेथस्ट्राइक की उपेक्षा करता है। संपादित करें कि अधिक स्पष्ट होने के लिए
— Veskah
1
@ f @n ,tɪk, यह अभी भी नुकसान उठाता है, यह सिर्फ इससे नहीं मरता है। ध्यान रहे, सवाल नियम को भी गलत करता है। यह " [अविनाशी] स्थायित्व को घातक क्षति से नष्ट नहीं किया जाना चाहिए , और वे राज्य-आधारित कार्रवाई की उपेक्षा करते हैं जो घातक क्षति की जांच करता है "।
— पीटर टेलर
4
" यदि किसी प्राणी की कोई क्षमता नहीं है, तो उसे [P, T] के रूप में पार्स किया जाना चाहिए। [P, T," "] वैध नहीं है " एक बुरा नियम है। यह बिना किसी लाभ के मजबूत टाइपिंग वाली भाषाओं के साथ भेदभाव करता है।
— पीटर टेलर
2
@PeterTaylor मैं दांतेदार ऐरे रखना चाहता हूं लेकिन आप सही हैं कि यह इसे बेहतर नहीं बनाता है। इस प्रकार नियम को हटा दिया गया है
— Veskah
1
@Veskah क्या मैं "D", "F", "I" को संख्याओं के रूप में ले सकता हूं? D => 0, F => 1, I => 2
— लुइस फेलिप डी जीसस मुनोज

जवाबों:

6

पर्ल 5 , 248 बाइट्स

... रिक्त स्थान और newlines के बिना:

sub c{eval'
(P,T,A,p,t,a)=@_;
     A=~/F/&&a!~/F/&&a!~/I/ ? c( P,2e9,A=~s/F//r,p,t, a         )
    :a=~/F/&&A!~/F/&&A!~/I/ ? c( P,T, A,        p,2e9,a=~s/F//r )
    : do{
        P=1e9 ifA=~/D/&&P>0;
        p=1e9 ifa=~/D/&&p>0;
        T=3e9 ifA=~/I/;
        t=3e9 ifa=~/I/;
        T-=p;
        t-=P;
        T>0&&t>0  ? 0
            : T>0 ? 2
            : t>0 ? 1
            :       3
}'=~s,[pta],\$$&,gri }

इसे ऑनलाइन आज़माएं!

@Veskah (ओपी) से दस परीक्षणों के साथ मेरा अनगुल्ड संस्करण, परीक्षण पास:

sub co { #combat
    my($p1,$t1,$a1, $p2,$t2,$a2)=@_; #p=power, t=toughness, a=abilities
    $a1=~s/F// and $a2=~s/F// if "$a1$a2"=~/F.*F/; #both F, no F
    return co($p1,2e9,$a1=~s/F//r, $p2,$t2,$a2        ) if $a1=~/F/ && $a2!~/I/;
    return co($p1,$t1,$a1,         $p2,2e9,$a2=~s/F//r) if $a2=~/F/ && $a1!~/I/;
    $p1=1e9 if $a1=~/D/ and $p1>0;
    $p2=1e9 if $a2=~/D/ and $p2>0;
    $t1=3e9 if $a1=~/I/;
    $t2=3e9 if $a2=~/I/;
    $t1-=$p2;
    $t2-=$p1;
    $t1<=0 && $t2<=0 ? "Both Die"
   :$t1<=0           ? "1st Dies"
   :$t2<=0           ? "2nd Dies"
                     : "Neither Die"
}

my @test=map{[/Input: .*? (\d+),(\d+)(?:,\s*"([FDI]+)")?
                      .*? (\d+),(\d+)(?:,\s*"([FDI]+)")?
           .*? Output: \s* (1st.Dies|2nd.Dies|Both.Die|Neither.Die)? /xsi]}
         split/\n\n/,join"",<DATA>;
my $t=0;
for(@test){ $t++;
  my $r=co(@$_);#result
  $r=~s,0,Neither Die,; $r=~s,3,Both Die,;
  print $$_[-1]=~/^$r/
    ? "Ok $t\n"
    : "Not ok, combat $t --> $r, wrong! (".join(",",@$_).")\n"
}
__DATA__
Input: [[2,2], [1,1]]
Output: 2nd Dies

Input: [[0,2], [0,1]] #0/2 vs 0/1
Output: Neither Die

Input: [[2,1], [2,1]] #2/1 vs 2/1
Output: Both Die

Input: [[1,1, "D"], [2,2]] #1/1 Deathtoucher vs 2/2
Output: Both Die

Input: [[2,2], [0,1, "D"]] #2/2 vs 0/1 Deathtoucher
Output: 2nd Dies

Input: [[2,2], [1,1, "DF"]] #2/2 vs 1/1 First-strike, Deathtoucher
Output: 1st Dies

Input: [[2,2], [2,2, "F"]] #2/2 vs 2/2 First-striker
Output: 1st Dies

Input: [[2,2, "I"], [1,1, "DF"]] #2/2 Indestructible vs 1/1 First-strike, Deatht.
Output: 2nd Dies

Input: [[99999,99999], [1,1, "I"]] #99999/99999 vs 1/1 Indestructible
Output: Neither Die

Input: [[2,2, "F"], [1,1, "F"]] #2/2 First-Striker vs 1/1 First-Striker
Output: 2nd Dies
— केजेटिल एस।
स्रोत
4

जावास्क्रिप्ट, 137 125 120 111 बाइट्स

i=>(k=(a,b)=>!(b[2]%2)&&a[0]/(a[2]<=3)>=b[1],[c,d]=i,g=c[2]&2,h=k(c,d),j=k(d,c),d[2]&2-g&&(g?h&&2:j&&1)||j+2*h)

मैं क्षमताओं के लिए बिटमैप संख्याओं का उपयोग कर रहा हूं D = 4 F = 2 I = 1 do "DFI"होगा 7। मेरा उत्पादन न तो मर रहा है 0, न पहला दिन 1, दूसरा मर गया 2, दोनों मर गए 3।

के साथ टेस्ट:

f([[2, 2, 0], [1,1, 0]]); // 2
f([[0, 2, 0], [0,1, 0]]); // 0
f([[2, 1, 0], [2,1, 0]]); // 3
f([[1, 1, 4], [2,2, 0]]); // 3
f([[2, 2, 0], [0,1, 4]]); // 2
f([[2, 2, 0], [1,1, 6]]); // 1
f([[2, 2, 0], [2,2, 2]]); // 1
f([[2, 2, 1], [1,1, 6]]); // 2
f([[99999, 99999, 0], [1,1, 1]]); // 0
f([[2, 2, 2], [1,1, 2]]); // 2)

यह मेरा पहला काम करने वाला कोड था

const kills = (c1, c2) => { // Return true if c1 kills c2
    if (c2[2] % 2) {
        console.log("Indestructible");
        return false;
    }
    const c1p = c1[0] / (c1[2] <= 3); // Infinity if Deathtoucher && P > 0
    const c2t = c2[1];
    return c1p >= c2t;
}
const f = (input) => {
    console.log("Match:", input);
    const [c1, c2] = input;
    const f1 = (c1[2] & 2);
    const f2 = (c2[2] & 2);
    if (f2 !== f1) {
        if (f1) {
            if (kills(c1, c2)) {
                console.log("c1 killed c2 in first round");
                return 2;
            }
        } else {
            if (kills(c2, c1)) {
                console.log("c2 killed c1 in first round");
                return 1;
            }
        }
    }
    return kills(c2, c1) + 2 * kills(c1, c2);
};

जिसे मैंने इस मध्यवर्ती में घटाया:

const f = i => {
    const k = (a, b) => !(b[2] % 2) && a[0] / (a[2] <= 3) >= b[1];
    const [c, d] = i;
    const g = c[2] & 2;
    const h = k(c, d);
    const j = k(d, c);
    return d[2] & 2 - g &&
        (g  ? h && 2
            : j && 1
        ) || j + 2 * h
}
— जेम्स
स्रोत
PPCG में आपका स्वागत है! और बहुत अच्छा पहला समाधान :) मैं आगे गोल्फ के लिए कुछ क्षमता देख सकता हूं, लेकिन मैं अपने फोन पर, कुछ बियर के बाद तो ठीक से परीक्षण नहीं कर सकता।
— झबरा
यहां एक त्वरित 7 बाइट बचत है, हालांकि: tio.run/##bc/RbsIgFAbg@z0FuxgBd7RwNEu2SPcgjERKtak1ZVHjle/...
— शैगी
@Shaggy। अच्छा है! बेशक अल्पविराम ऑपरेटर - क्या मैं एक noob हूँ।
— जेम्स
1
हम सब एक बार नए थे :)
— झबरा
3

जावास्क्रिप्ट (ईएस 6), 83 76 बाइट्स

इनपुट को 6 अलग-अलग तर्कों के रूप में लेता है: 2 x (पावर, टफनेस, एबिलिटीज)। उपयोगिताएँ बिटमास्क के रूप में अपेक्षित हैं:

  • 1
  • 2
  • 4

0123

(p,t,a,P,T,A)=>(x=A<4&&p>=T|a&!!p)&(y=a<4&&P>=t|A&!!P)&&(a^A)&2?a+2>>1:x*2+y

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

(p, t, a, P, T, A) => // (p, t, a) = arguments for the first player (P1)
                      // (P, T, A) = arguments for the second player (P2)
  ( x =               // x is a flag which means 'P1 can kill P2',
                      // regardless of the 'First Strike' abilities
    A < 4 &&          // it is set to 1 if P2 is not Indestructible and:
    p >= T |          //   the power of P1 is greater than or equal to the toughness of P2
    a & !!p           //   or the power of P1 is not zero and P1 has the Death Touch
  ) &                 //
  ( y = a < 4 &&      // y is the counterpart of x and is computed the same way
    P >= t |          //
    A & !!P           //
  ) &&                // if both x and y are set
  (a ^ A) & 2 ?       // and exactly one player has the First Strike:
    a + 2 >> 1        //   return 2 if P1 has the First Strike, or 1 otherwise
  :                   // else:
    x * 2 + y         //   return the default outcome: x * 2 + y
— Arnauld
स्रोत
3

सी (जीसीसी) , 114 113 95 बाइट्स

छत और लॉगर्न के लिए बहुत सारे गोल्फ का धन्यवाद।

g(Z{return F&1|F&4&&!(f&4||P<t)||!(f&2)&T>p;}
f(Z{return g(Z+2*g(p,t,f,P,T,F);}

के साथ संकलित करें -DZ=P,T,F,p,t,f)।

इसे ऑनलाइन आज़माएं!

हम जांच करते हैं (स्वतंत्र रूप से, मुकाबला यांत्रिकी के समरूपता के कारण) क्या प्रत्येक प्राणी लड़ाई से बचता है, जो तब होता है जब या तो सच होता है:

  • जीव अविनाशी है;
  • प्राणी ने पहली हड़ताल की है और दूसरा नहीं करता है और इसकी शक्ति अन्य की तुलना में अधिक है या बराबर है (इसलिए हम दूसरे के मौत के स्पर्श की उपेक्षा कर सकते हैं);
  • अन्य प्राणी की मृत्यु स्पर्श नहीं है और इसकी शक्ति हमारी क्रूरता से कम है।

(पूर्व स्थितियाँ अधिक महत्वपूर्ण हैं)।

निविष्टियाँ पूर्णांक के रूप में शक्ति और कठोरता हैं, और बिटफील्ड के रूप में क्षमताएं (1 = अविनाशी, 2 = मृत्यु स्पर्श, 4 = पहली हड़ताल), आउटपुट भी एक बिटफील्ड (1 = पहला प्राणी जीवित रहता है, 2 = दूसरा जीव जीवित रहता है)।

— मैक्स येखलाकोव
स्रोत
1
एक मैक्रो -DZ=P,T,F,p,t,f) 96 बाइट्स
— लोगन
का उपयोग करते हुए P=… करने के बजाय return …और न्यू लाइन को हटाने आप 85 बाइट्स पर ले जाता है।
इसके अलावा, तार्किक ऑपरेटरों की जगह -3 बाइट्स && के ||साथ , बिटवाइस के साथ &,|
2

रेटिना 0.8.2 , 123 बाइट्स

\d+
$*
(.*1)(.*;)(.*1)
$3$2$1
F(.*)F
$1
1+D
1
1*(,1+)I
$1
(1+)(F?;1*,)(1+)
$3$2$1
(1*)1*,\1(1+)?
$#2
0(F)?;0(F)?
$#1;$#2
F

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं, हालांकि मैंने गति 9के 99999लिए प्रतिस्थापित किया है। इनपुट अक्षरों का उपयोग करता है, DFIहालांकि Dपूर्ववर्ती होना चाहिए I। आउटपुट 1जीवित रहने और 0मरने के लिए प्रारूप में है। स्पष्टीकरण:

\d+
$*

आँकड़ों को एकात्मक में बदलें।

(.*1)(.*;)(.*1)
$3$2$1

आँकड़ों को अस्थायी रूप से एक्सचेंज करें।

F(.*)F
$1

दो Fएस रद्द।

1+D
1

डेथ टच प्रतिद्वंद्वी की क्रूरता को 1 तक कम करता है।

1*(,1+)I
$1

अविनाशी प्रतिद्वंद्वी की शक्ति को कम करके 0 कर देता है।

(1+)(;1*,)(1+)
$3$2$1

Toughness को वापस स्विच करें, इसलिए अब आपके पास P2, T1, F1; P1, T2, F2 हैं

(1*)1*,\1(1+)?
$#2

यदि प्रतिद्वंद्वी की पावर की तुलना में टफनेस अधिक है तो यह जीवित रहता है।

0(F)?;0(F)?
$#1;$#2

अगर दोनों मर जाते, तो फर्स्ट स्ट्राइक वाला बच जाता।

F

अन्यथा फर्स्ट स्ट्राइक से कोई फर्क नहीं पड़ता।

— नील
स्रोत
1

सी ++, 177 131 127 121 बाइट्स

यहाँ C ++ में मेरा इतना छोटा समाधान नहीं है। प्रत्येक प्राणी के लिए क्षमताएँ 3 बिट्स हैं:

  1. D = 0x1 (0001)
  2. एफ = 0x2 (0010)
  3. I = 0x4 (0100)

और यह केवल 0 देता है : यदि कोई नहीं मरता है, 1 : यदि पहला प्राणी मर जाता है, 2 : यदि दूसरा प्राणी मर जाता है और 3 : यदि दोनों जीव मर जाते हैं।

[](int p,int t,int a,int r,int k,int b){return(a&2&&b^4)^(b&2&&a^4)?1+(a&2):((t<r||b&1&&r)&&a^4)+((k<p||a&1&&p)&&b^4)*2;}

इसे ऑनलाइन आज़माएं!

C ++, 85 81 बाइट्स (वैकल्पिक)

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

[&]{s=(a&2&&b^4)^(b&2&&a^4)?1+(a&2):((t<r||b&1&&r)&&a^4)+((k<p||a&1&&p)&&b^4)*2;}

इसे ऑनलाइन आज़माएं!

— DimChtz
स्रोत
यह कोड-गोल्फ है , इस तरह के हैक की उम्मीद की जाती है, यदि आवश्यकता नहीं है, तो प्रतिस्पर्धा करने के लिए ... जब तक कि आप उद्देश्य-निर्मित कोड-गोल्फिंग भाषाओं का उपयोग नहीं कर रहे हैं, जो खेल को थोड़ा बदल देता है।
— 3D1T0R
1

पर्ल 5, 245 बाइट्स

$F[0]*=$F[4]if$F[2]=~/D/;$F[3]*=$F[1]if$F[5]=~/D/;$F[3]=0 if$F[2]=~/I/;$F[0]=0 if$F[5]=~/I/;$F[4]-=$F[0]if$F[2]=~/F/;$F[1]-=$F[3]if$F[5]=~/F/;if($F[1]>0&&$F[4]>0){$F[4]-=$F[0]if$F[2]!~/F/;$F[1]-=$F[3]if$F[5]!~/F/}$_=(0+($F[1]<=0)).(0+($F[4]<=0))

साथ दौड़ो -lapE

Ungolfed:

# Takes input in one lines, of the form:
# PPP TTT "<abilities>" PPP TTT "<abilities>"

$F[0] *= $F[4] if $F[2] =~ /D/;
$F[3] *= $F[1] if $F[5] =~ /D/;

$F[3] = 0 if $F[2] =~ /I/;
$F[0] = 0 if $F[5] =~ /I/;

$F[4] -= $F[0] if $F[2] =~ /F/;
$F[1] -= $F[3] if $F[5] =~ /F/;

if ($F[1] > 0 && $F[4] > 0) {
    $F[4] -= $F[0] if $F[2] !~ /F/;
    $F[1] -= $F[3] if $F[5] !~ /F/;
}

$_ = (0+ ($F[1] <= 0)) . (0+ ($F[4] <= 0));

"डेथटच" का अनुवाद "आपकी शक्ति अब आपके शत्रु की कठोरता से गुणा किया जाता है", और "अविनाशी" का अनुवाद "आपके शत्रु की शक्ति अब शून्य है", उत्तरार्द्ध मिसाल के साथ। कोड दो राउंड चलाता है, एक जहां केवल प्रथम-स्ट्राइकर हमला करने के लिए मिलता है, और दूसरा जहां केवल गैर-प्रथम-स्ट्राइकर हमला कर सकते हैं। यदि पहले दौर में एक मौत होती है, तो दूसरा दौर ऐसा नहीं होता। चूँकि हम शुरुआत में ही मृत्युभोज और अविनाशी से निपट चुके हैं, इसलिए "मृत्यु" की जाँच करना उतना ही सरल है जितना कि क्रूरता शून्य से अधिक है या नहीं।

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