जादू की सभा: दोस्तों या दुश्मनों?

67

कार्ड गेम मैजिक: गैदरिंग में पांच अलग-अलग रंग होते हैं, जो कार्ड के ढीले जुड़ाव का प्रतिनिधित्व करते हैं, सफेद ( W), नीला ( U), काला ( B), लाल ( R) और हरा ( G)। ये अक्सर एक पंचकोण में व्यवस्थित होते हैं:

  W
G   U
 R B

MtG के साथ-साथ कई कार्ड यांत्रिकी में, इस पेंटागन में आसन्न रंगों को आमतौर पर सहयोगी माना जाता है, और गैर-आसन्न (विपरीत के प्रकार) रंगों को दुश्मन माना जाता है।

इस चुनौती में, आपको दो रंग दिए जाएंगे और उन्हें अपने रिश्ते को निर्धारित करना चाहिए।

चुनौती

आपको सेट से दो अलग-अलग वर्ण दिए गए हैं BGRUW। आप इन्हें दो-वर्ण स्ट्रिंग के रूप में ले सकते हैं, पात्रों के बीच एक सीमांकक के साथ एक स्ट्रिंग, दो अलग-अलग वर्ण मान, दो सिंगलटन स्ट्रिंग्स, दो पूर्णांक उनके कोड बिंदुओं का प्रतिनिधित्व करते हैं, या एक सूची या सेट प्रकार जिसमें दो वर्ण / स्ट्रिंग्स / पूर्णांक होते हैं।

आपका आउटपुट आपकी पसंद के दो अलग-अलग और सुसंगत मूल्यों में से एक होना चाहिए, जो यह दर्शाता है कि दो रंग सहयोगी हैं और एक जो इंगित करता है कि वे दुश्मन हैं। उन दो मूल्यों में से एक बिल्कुल भी आउटपुट नहीं हो सकता है।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

परीक्षण के मामलों

केवल 20 संभावित इनपुट हैं, इसलिए मैं उन सभी को सूचीबद्ध करूंगा।

दोस्त:

WU   UB   BR   RG   GW   UW   BU   RB   GR   WG

दुश्मनों:

WB   UR   BG   RW   GU   BW   RU   GB   WR   UG
code-golf  game  decision-problem  card-games 
— मार्टिन एंडर
स्रोत
33
अगले: कोर नियमों को लागू करें: पी
— कैप्टन मैन
12
अगर आप इसे 30k कैरेक्टर पोस्ट में फिट कर सकते हैं तो @CaptainMan आप को
— उधेड़ देगा
@Walfrat 30k? संभव होना चाहिए
— नहीं कि चार्ल्स
2
सबसे अप्रत्याशित गठजोड़ से @IvanKolmychek सबसे अप्रत्याशित परिणाम आता है।
— अलुरीक
1
मजेदार तथ्य: जादू: सभा पूरी तरह से चल रही है :)
— मैथ्यू रो

जवाबों:

82

जावास्क्रिप्ट (ईएस 6),  26 23 17 15  14 बाइट्स

करी सिंटैक्स में दो ASCII कोड के रूप में इनपुट लेता है (a)(b)। 4दोस्तों के लिए या 0दुश्मनों के लिए रिटर्न ।

a=>b=>a*b/.6&4

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

कैसे?

NB: केवल 0.6 द्वारा विभाजन के पूर्णांक भाग को नीचे दिखाया गया है।

Combo | a  | b  | a*b  | / 0.6 | AND 4
------+----+----+------+-------+------
  WU  | 87 | 85 | 7395 | 12325 |   4
  UB  | 85 | 66 | 5610 |  9350 |   4
  BR  | 66 | 82 | 5412 |  9020 |   4
  RG  | 82 | 71 | 5822 |  9703 |   4
  GW  | 71 | 87 | 6177 | 10295 |   4
  UW  | 85 | 87 | 7395 | 12325 |   4
  BU  | 66 | 85 | 5610 |  9350 |   4
  RB  | 82 | 66 | 5412 |  9020 |   4
  GR  | 71 | 82 | 5822 |  9703 |   4
  WG  | 87 | 71 | 6177 | 10295 |   4
------+----+----+------+-------+------
  WB  | 87 | 66 | 5742 |  9570 |   0
  UR  | 85 | 82 | 6970 | 11616 |   0
  BG  | 66 | 71 | 4686 |  7810 |   0
  RW  | 82 | 87 | 7134 | 11890 |   0
  GU  | 71 | 85 | 6035 | 10058 |   0
  BW  | 66 | 87 | 5742 |  9570 |   0
  RU  | 82 | 85 | 6970 | 11616 |   0
  GB  | 71 | 66 | 4686 |  7810 |   0
  WR  | 87 | 82 | 7134 | 11890 |   0
  UG  | 85 | 71 | 6035 | 10058 |   0

पिछला दृष्टिकोण, 15 बाइट्स

करी सिंटैक्स में दो ASCII कोड के रूप में इनपुट लेता है (a)(b)। 0दोस्तों के लिए या 1दुश्मनों के लिए रिटर्न ।

a=>b=>a*b%103%2

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

कैसे?

Combo | a  | b  | a*b  | MOD 103 | MOD 2
------+----+----+------+---------+------
  WU  | 87 | 85 | 7395 |    82   |   0
  UB  | 85 | 66 | 5610 |    48   |   0
  BR  | 66 | 82 | 5412 |    56   |   0
  RG  | 82 | 71 | 5822 |    54   |   0
  GW  | 71 | 87 | 6177 |   100   |   0
  UW  | 85 | 87 | 7395 |    82   |   0
  BU  | 66 | 85 | 5610 |    48   |   0
  RB  | 82 | 66 | 5412 |    56   |   0
  GR  | 71 | 82 | 5822 |    54   |   0
  WG  | 87 | 71 | 6177 |   100   |   0
------+----+----+------+---------+------
  WB  | 87 | 66 | 5742 |    77   |   1
  UR  | 85 | 82 | 6970 |    69   |   1
  BG  | 66 | 71 | 4686 |    51   |   1
  RW  | 82 | 87 | 7134 |    27   |   1
  GU  | 71 | 85 | 6035 |    61   |   1
  BW  | 66 | 87 | 5742 |    77   |   1
  RU  | 82 | 85 | 6970 |    69   |   1
  GB  | 71 | 66 | 4686 |    51   |   1
  WR  | 87 | 82 | 7134 |    27   |   1
  UG  | 85 | 71 | 6035 |    61   |   1

प्रारंभिक दृष्टिकोण, 23 बाइट्स

2-वर्ण स्ट्रिंग के रूप में इनपुट लेता है। trueदोस्तों के लिए या falseदुश्मनों के लिए रिटर्न ।

s=>parseInt(s,35)%9%7<3

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

— Arnauld
स्रोत
10
आह, अंत में कुछ मजेदार। :)
— मार्टिन एंडर
4
शानदार खोज!
— ग्रेग मार्टिन
वहाँ कुछ चतुर गणित मैं यहाँ के बारे में पता नहीं है या आप बस एक काम है कि जब तक आप अलग modulos बल मजबूर किया?
— फोरऑफोर
@FourOhFour यह मजबूर था। मुझे लगता है कि यह सबसे छोटा डबल मॉडुलो समाधान है। लेकिन इस जवाब का एक पोर्ट (जो एक तुलना का उपयोग कर रहा है) वास्तव में एक बाइट छोटा होगा।
— अरनुलद
1
@OddDev मैंने वास्तव में सभी बिट्स का परीक्षण किया, न कि केवल कम से कम एक महत्वपूर्ण। उदाहरण के लिए, a*b%290&8बस काम करेगा ( 0दोस्तों के लिए या 8दुश्मनों के लिए)।
— अरनुलद
37

जेली , 6 बाइट्स

ạg105Ị

दो कोड बिंदुओं को तर्क के रूप में लेता है। दोस्तों के लिए 1 उपज , 0 दुश्मनों के लिए।

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

पृष्ठभूमि

बता दें कि n और m दो इनपुट कैरेक्टर के कोड पॉइंट हैं। लेने से | n - m | , हम सभी पात्रों के संयोजन के साथ ही खुद को चिंतित करने की जरूरत है। निम्न तालिका वर्णों के सभी 2-संयोजनों को संबंधित पूर्ण अंतर दिखाती है।

WU  2
UB 19
BR 16
RG 11
GW 16

WB 21
UR  3
BG  5
RW  5
GU 14

सभी शत्रु संयोजन 3 , 5 या 7 से विभाज्य हैं , लेकिन मित्र में से कोई भी इसका संयोजन नहीं करता है, इसलिए मित्र बिल्कुल वही हैं जो 3 × 5 × 7 = 105 के साथ सह-प्रधान हैं ।

यह काम किस प्रकार करता है

ạg105Ị  Main link. Left argument: n (code point). Right argument: m (code point)

ạ       Yield the absolute difference of n and m.
 g105   Compute the GCD of the result and 105.
     Ị  Insignificant; return 1 if the GCD is 1, 0 if not.
— डेनिस
स्रोत
अच्छी तरह से देखा! पूर्ण मूल्य क्यों आवश्यक है? (मैं इसे ऑनलाइन करने की कोशिश की और यह सही जवाब नहीं दिया; लेकिन गणितीय रूप से यह बात नहीं होनी चाहिए।)
— ग्रेग मार्टिन
@GregMartin यह आवश्यक नहीं है; हस्ताक्षरित अंतर बस के रूप में अच्छी तरह से काम करेगा। घटाव _जेली है। क्या आपने कुछ और उपयोग किया?
— डेनिस
आह, मैं देख रहा हूं, मैंने गलत तरीके से ạसिर्फ पूर्ण मूल्य के रूप में पढ़ा , पूर्ण अंतर नहीं।
— ग्रेग मार्टिन
21

बेफ़ुंज -98, 13 12 बाइट्स

~~-9%5%3%!.@

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

0दोस्तों के लिए और 1दुश्मनों के लिए प्रिंट

यह अक्षरों के ASCII मूल्यों के बीच अंतर का उपयोग करता है।

यदि हम लेते हैं (((ASCII difference % 9) % 5) % 3), तो दुश्मनों के लिए मान 0. होगा। फिर, हम मूल्य नहीं लेते हैं और इसे प्रिंट करते हैं।

गोल्फ के लिए @ मॉर्टिन को धन्यवाद

— MildlyMilquetoast
स्रोत
9 बाइट्स के लिए जेली का उपयोग करें: IA%9%5%3¬संपादित करें यह ऑनलाइन कोशिश करो!
— जोनाथन एलन
@JonathanAllan मैं आपको पहले ही देख चुका हूँ! अच्छा लगा।
— मिल्डलीमिल्कॉस्ट
मैंने वास्तव में आपके तरीके को मॉर्फ किया (वास्तविक का उपयोग करते हुए, निरपेक्ष, अंतर के बजाय) आधुनिक 9 मॉड 6, और इस तथ्य का उपयोग किया कि जेली अनुक्रमित सूची में 7 तक नीचे लाने के लिए मॉड्यूलर रूप से अनुक्रमित करता है । मैंने आपको पहचाना और यहां से जोड़ा।
— जोनाथन एलन
@JonathanAllan मैं आधुनिक 9 मॉड 6 विधि के साथ भी आया था, लेकिन Befunge में वास्तविक अंतर या पूर्ण मूल्य नहीं है, इसलिए यह संभव नहीं था
— MildlyMilquetoast
18

जेली , 8 7 बाइट्स

मिगाहे फिगर्स के शानदार बेगुंजे उत्तर से पिग्गीबैक !

Iị390B¤

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

कैसे?

जैसा कि मिस्टाहा फिगर्स ने उल्लेख किया है कि एएससीआईआई मानों के बीच पूर्ण अंतर को देखते हुए निर्णय लिया जा सकता है, मॉड 9 मॉड 5 मॉड 3 - 0 एस तो दोस्त हैं और 1 एस और 2 एस दुश्मन हैं।

अगर हम इसके बजाय (सादा) अंतर mod 9 लेते हैं तो हम पाते हैं कि मित्र 1s, 2s, 7s और 8s हैं जबकि दुश्मन 3s, 4s, 5s और 6s हैं।

कोड अंतर के साथ ले जाता है Iलंबाई 9 सूची में अनुक्रमित और फिर [1,1,0,0,0,0,1,1,0], है, जो बाइनरी में 390 है 390B। इंडेक्सिंग दोनों मॉड्यूलर है (इसलिए प्रभावी रूप से इंडेक्सिंग मोड 9 को मुफ्त में करता है) और 1-आधारित (इसलिए 1 बहुत बाईं ओर)।

— जोनाथन एलन
स्रोत
16

सी ++ टेम्पलेट मेटाप्रोग्रामिंग, 85 बाइट्स

template<int A,int B,int=(A-B)%9%5%3>struct f;template<int A,int B>struct f<A,B,0>{};

कम गोल्फ वाला:

template<int A, int B,int Unused=(((A-B)%9)%5)%3>
struct foe;
template<int A, int B>
struct foe<A,B,0>{};

जैसा कि यह एक मेटाप्रोग्रामिंग भाषा है, एक निर्माण संकलन या नहीं एक संभव आउटपुट है।

f<'W','B'>संकलन का एक उदाहरण अगर और केवल अगर 'W'और 'B'शत्रु हैं।

बेफुन्गे के उत्तर पर आधारित गणित ।

जीवंत उदाहरण ।

जैसा कि C ++ टेम्प्लेट मेटाप्रोग्रामिंग सबसे बुरी गोल्फ भाषाओं में से एक है, जो कोई भी इससे भी बदतर है उसे शर्म महसूस करना चाहिए। ;)

— Yakk
स्रोत
ऐसा लगता है कि templates के अंदर कुल दो निरर्थक व्हाट्सएप हैं ।
— यति
तय @TuukkaX, डी 'ओह
— Yakk
14

रूबी, 22 19 बाइट्स

->x,y{390[(x-y)%9]}

इनपुट: 2 अक्षरों का ASCII कोड। आउटपुट: सहयोगियों के लिए 1, दुश्मनों के लिए 0।

यह काम किस प्रकार करता है:

2 नंबरों के मोडुलो 9 के बीच अंतर प्राप्त करें, बिटमास्क (390 द्विआधारी 110000110) का उपयोग करें और []ऑपरेटर का उपयोग करके एक बिट प्राप्त करें ।

— जीबी
स्रोत
2
आह अच्छा है, मैं भूल रहा हूँ कि पूर्णांकों को अनुक्रमित किया जा सकता है। +1
— मार्टिन एंडर
16 बाइट्स: ->x,y{x*y%103%2}ध्यान दें कि 0और 1उलट हैं।
— एरिक डुमिनील
1
और x*y%51>9हर किसी की तरह 15 बाइट्स । मुझे लगता है कि अपवित्रों के लिए अनुचित होगा कि वे इसे अब मौलिक रूप से बदल दें।
— जीबी
10

सीजेएम , 8 बाइट्स

{*51%9>}

एक अनाम ब्लॉक जो स्टैक के शीर्ष पर दो वर्ण कोड की अपेक्षा करता है और उन्हें 0(दोस्तों) या 1(दुश्मनों) के साथ बदल देता है ।

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

व्याख्या

ठीक है, हमने अब बहुत सारे मजेदार अंकगणित समाधान देखे हैं, इसलिए मुझे लगता है कि अगर मैं अपना स्वयं का पेश करता हूं तो यह ठीक है। अब तक मैंने जो सबसे नजदीक देखा, वह है स्टीडबॉक्स का सी सॉल्यूशन । यह एक गोल्फस्क्रिप्ट ब्रूट फॉरेसर की मदद से पाया गया था जो मैंने कुछ समय पहले अराजकतापूर्ण गोल्फ के लिए लिखा था।

यहां विभिन्न इनपुट्स के लिए यह किया गया है (आदेश की अनदेखी, क्योंकि प्रारंभिक गुणा सराहनीय है)

xy   x    y    x*y   %51  >9

WU   87   85   7395    0   0
UB   85   66   5610    0   0
BR   66   82   5412    6   0
RG   82   71   5822    8   0
GW   71   87   6177    6   0
WB   87   66   5742   30   1
UR   85   82   6970   34   1
BG   66   71   4686   45   1
RW   82   87   7134   45   1
GU   71   85   6035   17   1

हम देख सकते हैं कि कैसे इनपुट्स के उत्पाद को मोडुलो 51 लेने से इनपुट बड़े और छोटे परिणामों में अलग हो जाते हैं, और हम दोनों मामलों में अंतर करने के लिए किसी भी मान का उपयोग कर सकते हैं।

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

रोड़ा , 30 22 21 बाइट्स

बाइट्स ने _इनपुट के रूप में स्ट्रीम पर मान लेने के लिए @fergusq का धन्यवाद बचाया

{[_ in"WUBRGWGRBUW"]}

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

फ़ंक्शन को push "WU" | fनाम निर्दिष्ट करने के बाद फ़ंक्शन चलाया जाता है

व्याख्या

{                      /* Declares an anonymous function */
 [                 ]   /* Push */
  _ in                 /* the boolean value of the value on the stream is in */
      "WUBRGWGRBUW"    /* this string */
}
— क्रिकटी लिथोस
स्रोत
o_O बिजली की गति
— पावेल
मापदंडों को लेने के बजाय धारा से इनपुट मानों को पढ़कर 5 बाइट्स को बचाना संभव है: {[(_.._)in"WUBRGWGRBUW"]}लेकिन फिर फ़ंक्शन को इस तरह बुलाया जाना चाहिए [a, b] | f।
— फर्ग्यूसक
9

सी, 33 32 29 24 22 बाइट्स

#define f(k,l)k*l%51<9

1 अगर दोस्त, 0 अगर वापसी करता है।

— Steadybox
स्रोत
8

विम, 22 21 बाइट्स

CWUBRGWGRBUW<esc>:g/<c-r>"/d<cr>

इनपुट: एक एकल पंक्ति जिसमें दो वर्ण होते हैं।

आउटपुट: खाली बफर अगर दोस्तों, बफर युक्त WUBRGWGRBUWअगर दुश्मन।

व्याख्या

C                                 # [C]hange line (deletes line into " register and enters insert mode)
 WUBRGWGRBUW<esc>                 # insert this text and exit insert mode
                 :g/      /d<cr>  # delete all lines containing...
                    <c-r>"        # ... the previously deleted input
— एम-Chrzan
स्रोत
2
आप Cइसके बजाय कर सकते हैंcw
— क्रिस्ति लिथोस
8

जाप , 6 बाइट्स

@ मर्टिन एंडर के समाधान से प्रेरित ।

इनपुट के रूप में दो चार कोड की एक सरणी लेता है।

×%51<9

इसे ऑनलाइन आज़माएं! | परीक्षण सूट

रिटर्न trueदोस्तों के लिए, falseदुश्मनों के लिए।

14-बाइट समाधान:

इनपुट के रूप में दो चार कोड लेता है

nV a /3%3 f ¦1

इसे ऑनलाइन आज़माएं! | परीक्षण सूट

स्पष्टीकरण:

nV a /3%3 f ¦1
nV a             // Absolute value of: First input (implicit) - Second input
      /3%3 f     // Divide by 3, mod 3, then floor the result
             ¦1  // Return true if the result does not equals 1, otherwise return false

12-बाइट समाधान:

"WUBRGW"ê èU

इसे ऑनलाइन आज़माएं! | परीक्षण सूट

स्पष्टीकरण:

"WUBRGW"ê èU
"WUBRGW"ê     // "WUBRGW" mirrored = "WUBRGWGRBUW"
          èU  // Returns the number of times U (input) is found

1दोस्तों के लिए और 0दुश्मनों के लिए वापसी ।

9-बाइट समाधान :

@ अरनुलद के समाधान से प्रेरित ।

*V%24%B%2

परीक्षण सूट

रिटर्न 1दोस्तों के लिए, 0दुश्मनों के लिए।

11-बाइट समाधान:

@ मिताह फिगर्स के समाधान से प्रेरित ।

nV %9%5%3¦0

परीक्षण सूट

— ओलिवर
स्रोत
8

ब्रेन-फ्लैक , 155, 147 , 135 बाइट्स

(([(({}[{}]))<>])){({}())<>}(((([])[][][])[]())()()())<>{}<>{({}<><(({}))>)({}[{}]<(())>){((<{}{}>))}{}{{}({}<({}())>)(<()>)}{}<>}<>{}

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

यह -aध्वज के लिए कोड बाइट का 134 बाइट्स है जो ASCII इनपुट को सक्षम करता है।

यह इनपुट के बीच पूर्ण अंतर को खोजने के द्वारा काम करता है, और अगर वे 2, 11, 16, या 19 के बराबर की जाँच करते हैं। यदि ऐसा होता है, तो इनपुट एक मित्र है, और यह 1 प्रिंट करता है। यदि यह नहीं है, तो यह कुछ भी प्रिंट नहीं करता है। चूंकि ब्रेन-फ्लैक में कुछ भी एक खाली स्टैक से मेल नहीं खाता है, जो कि मिथ्या है, कोई भी आउटपुट मिथ्या मूल्य नहीं है। ( मेटा )

एक बात जो मुझे विशेष रूप से इस उत्तर के बारे में पसंद है, वह यह है कि "पूर्ण अंतर" स्निपेट (यानी (([(({}[{}]))<>])){({}())<>}{}{}<>{}) स्टैक साफ नहीं है, लेकिन इसका उपयोग अभी भी इस उत्तर में किया जा सकता है क्योंकि हम परवाह नहीं करते हैं कि हम एन्कोडिंग से पहले किस स्टैक पर समाप्त होते हैं। संभव अंतर।

बाद में संपादित करने पर, मैंने स्टैक पर बचे हुए गालियों का दुरुपयोग करके इससे भी अधिक लाभ उठाया जो उस पर पूर्ण अंतर के साथ समाप्त नहीं होता है। पहले संशोधन पर, मैंने इसे थोड़ा और अधिक रखने के लिए दोनों को बंद कर दिया। ऐसा नहीं करने से दो प्रमुख गोल्फ मिलते हैं:

  1. जाहिर है, यह उन्हें पॉप करने के लिए कोड निकालता है: {}{}लेकिन अधिक महत्वपूर्ण बात:

  2. यह हमें 2, 11, 16, 19अनुक्रम को सेक करने की अनुमति देता है

    (((((()()))[][][](){})[][]())[])

    सेवा 

    (((([])[][][])[]())()()())

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

चूंकि ब्रेन-फ्लैक को समझना बहुत मुश्किल है, यहाँ एक पठनीय / टिप्पणी संस्करण है:

#Push the absolute difference of the two input characters. It is unknown which stack the result will end on
(([(({}[{}]))<>])){({}())<>}

#Push 2, 11, 16, 19, while abusing the values left on the stack from our "Absolute value" calculation
(((([])[][][])[]())()()())

#Pop a zero from the other stack and toggle back
<>{}<>

#While True
{

    #Move top over and duplicate the other top
    ({}<><(({}))>)

    #Equals?
    ({}[{}]<(())>){((<{}{}>))}{}

    #If so:
    {

        #Increment the number under the stack
        {}({}<({}())>)
        #Push a zero
        (<()>)

    }

    #Pop the zero
    {}

    #Go back to the other stack
    <>

#Endwhile
}

#Toggle back
<>

#Pop a zero
{}
— DJMcMayhem
स्रोत
वहाँ एक धक्का है, पॉप आप निकाल सकते हैं, और आप 0 में धक्का दे सकते हैं अगर अधिक कुशलता से 129 तक नीचे जाने के लिए: टीआईओ
— रिले
@ रिले कूल, टिप के लिए धन्यवाद! मुझे एक टिप्पणी किया गया संस्करण पसंद है, इसलिए मैं प्रतीक्षा करने जा रहा हूं जब तक कि मैं अद्यतन करने से पहले उस संस्करण को समझ नहीं सकता।
— डीजेमेकमैम
यह केवल दो छोटे बदलाव थे। यहाँ महत्वपूर्ण हिस्सा है। मेरी टिप्पणियाँ सभी कैप्स में हैं, क्षमा करें यदि ऐसा लगता है कि मैं चिल्ला रहा हूँ।
— रिले
7

जेली , 14 बाइट्स

“WUBRG”wЀIAÆP

रिटर्न 1दुश्मनों के लिए और 0दोस्तों के लिए।

टेस्ट सूट ऑनलाइन यह कोशिश करो!

कैसे?

“WUBRG”wЀIAÆP - Main link                                   e.g. WG
“WUBRG”        - ['W','U','B','R','G']
       wЀ     - first index of sublist mapped over the input     [1,5]
          I    - incremental differences                           -4
           A   - absolute value                                     4
            ÆP - is prime?                                          0
— जोनाथन एलन
स्रोत
7

05AB1E , 7 बाइट्स

$Æ105¿Ö

यह मेरे जेली उत्तर का एक बंदरगाह है । इनपुट के रूप में कोड बिंदुओं की एक सूची लेता है। दोस्तों के लिए प्रिंट 1 , दुश्मनों के लिए 0 ।

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

यह काम किस प्रकार करता है

$        Push 1 and [n, m] (the input).
 Æ       Reduce [n, m] by subtraction, pushing n - m.
  105¿   Take the GCD of n - m and 105.
      Ö  Test if 1 is divisible by the GCD (true iff the GCD is ±1).
— डेनिस
स्रोत
6

CJam , 16 12 11 10 बाइट्स

मिस्टाह फिगर्स एल्गोरिथ्म का उपयोग करके 4 बाइट्स गॉकेटेड

लिन को धन्यवाद दिया 1 बाइट बचाया

l:m9%5%3%!

1दुश्मन रंगों के लिए आउटपुट , 0सहयोगी रंगों के लिए।

इसे ऑनलाइन आज़माएं! (या सभी परीक्षण मामलों को सत्यापित करें )

व्याख्या

l           e# Push a line of input as a string
 :m         e# Reduce the string by subtraction (using the ASCII values)
   9%5%3%   e# Mod by 9, then by 5, then by 3. By doing this, enemy
            e#  pairs go to 0, and allies go to 1, 2, -1, or -2.
         !  e# Boolean negation
— बिजनेस कैट
स्रोत
बहुत चालाक बनने की कोशिश मत करो! l:m9%5%3%!एक बाइट कम है।
— लिन
@ लिन ओह वाह, यह है। यह थोड़े उबाऊ है। धन्यवाद
— बिजनेस बिल्ली
5

रेटिना , 18 बाइट्स

O`.
BR|BU|GR|GW|UW

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

सीधे आगे: इनपुट को छाँटें और इसके खिलाफ किसी भी तरह की सहयोगी जोड़ी से मेल खाने की कोशिश करें। दुर्भाग्य से, मुझे नहीं लगता कि रेटिना की स्ट्रिंग-आधारित प्रकृति प्रतिस्पर्धी होने के लिए किसी भी अधिक दिलचस्प दृष्टिकोण की अनुमति देती है।

अगले रेटिना संस्करण के लिए एक चुपके के रूप में, मैं एक विकल्प जोड़ने की योजना बना रहा हूं, जो regex और लक्ष्य स्ट्रिंग (ताकि वर्तमान स्ट्रिंग को regex के रूप में उपयोग किया जाएगा और आप इसे जांचने के लिए एक स्ट्रिंग देते हैं), जिस स्थिति में यह छोटा होता है समाधान काम करेगा (या उन लाइनों के साथ कुछ):

?`WUBRGWGRBUW
— मार्टिन एंडर
स्रोत
4

जेली , 6 बाइट्स

ạ:3%3Ḃ

पूर्णता के लिए। दो कोड बिंदुओं को तर्क के रूप में लेता है। दोस्तों के लिए पैदावार 0 , दुश्मनों के लिए 1 ।

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

पृष्ठभूमि

बता दें कि n और m दो इनपुट कैरेक्टर के कोड पॉइंट हैं। लेने से | n - m | , हम सभी पात्रों के संयोजन के साथ ही खुद को चिंतित करने की जरूरत है। निम्न तालिका वर्णों के सभी 2-संयोजनों को संबंधित पूर्ण अंतर दिखाती है।

WU UB BR RG GW  WB UR BG RW GU
 2 19 16 11 16  21  3  5  5 14

यदि हम इन पूर्णांकों को 3 से विभाजित करते हैं , तो हमें निम्नलिखित उद्धरण मिलते हैं।

WU UB BR RG GW  WB UR BG RW GU
 0  6  5  3  5   7  1  1  1  4

1 , 4 , और 7 के परिणाम modulo 3 लेकर 1 से मैप किया जा सकता है ।

WU UB BR RG GW  WB UR BG RW GU
 0  0  2  0  2   1  1  1  1  1

अब हमें सिर्फ समता को देखना होगा।

यह काम किस प्रकार करता है

ạ:3%3Ḃ  Main link. Left argument: n (code point). Right argument: m (code point)

ạ       Absolute difference; yield |n - m|.
 :3     Integer division by 3, yielding |n - m| / 3.
   %3   Modulo 3, yielding |n - m| / 3 % 3.
     Ḃ  Parity bit; yield |n - m| / 3 % 3 & 1.
— डेनिस
स्रोत
4

क्यूबिक्स, 11 बाइट्स

अर्नुल्ड के समाधान का एक क्यूबिक्स कार्यान्वयन।

U%O@A*'g%2W

प्रयोग

दो वर्णों को इनपुट करें, और यह 0दोस्तों के लिए और 1दुश्मनों के लिए आउटपुट करता है। इसे यहाँ आज़माएँ।

व्याख्या

इस तरह कोड का विस्तार किया जा सकता है।

    U %
    O @
A * ' g % 2 W .
. . . . . . . .
    . .
    . .

इस क्रम में पात्रों को निष्पादित किया जाता है (नियंत्रण प्रवाह को छोड़कर):

A*'g%2%O@
A         # Read all input as character codes
 *        # Multiply the last two character codes
    %     # Modulo the result by
  'g      #     103
      %   # And modulo that by
     2    #     2
       O  # Output the result ...
        @ # ... and terminate
— ल्यूक
स्रोत
2

AWK, 23 बाइट्स

{$0="WUBRGWGRBUW"~$1}1

उदाहरण उपयोग: awk '{$ 0 = "WUBRGWGRBUW" ~ $ 1} 1' <<< UB

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

— रॉबर्ट बेन्सन
स्रोत
2

रूबी, 28 बाइट्स

दोस्त के लिए सच आउटपुट, दुश्मन के लिए गलत:

p'WUBRGWGRBUW'.include?$**''

Ungolfed संस्करण बहुत अलग नहीं है:

p 'WUBRGWGRBUW'.include?(ARGV.join(''))
— Sculper
स्रोत
2

GolfScript , 7 बाइट्स

~*51%9>

इनपुट के रूप में दो कोड पॉइंट लेता है।

इसे ऑनलाइन आज़माएं! (टेस्ट सूट जो सुविधा के लिए इनपुट प्रारूप को परिवर्तित करता है।)

का एक GolfScript बंदरगाह मेरी CJam जवाब (जो तकनीकी रूप से, मेरे GolfScript जानवर forcer का परिणाम के CJam बंदरगाह है ... uhhh ...)।

हालाँकि, क्योंकि गोल्फस्क्रिप्ट नकारात्मक इनपुट के साथ मॉडुलो सही हो जाता है, उसी बाइट की गिनती में एक मजेदार वैकल्पिक समाधान है जो 4इसके बजाय फोंस के लिए उपयोग करता है 1:

~-)9%4&

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

xy   x    y    x-y    +1  %9  &4

WU   87   85     2     3   3   0
UB   85   66    19    20   2   0
BR   66   82   -16   -15   3   0
RG   82   71    11    12   3   0
GW   71   87   -16   -15   3   0
WB   87   66    21    22   4   4
UR   85   82     3     4   4   4
BG   66   71    -5    -4   5   4
RW   82   87    -5    -4   5   4
GU   71   85   -14   -13   5   4
— मार्टिन एंडर
स्रोत
2

जावा 7, 38 बाइट्स

int b(int a,int b){return(a-b)%9%5%3;}

@ मिस्टाह फिगर्स बीफुंज -98 उत्तर से पोर्ट जावा 7 में अब तक पोस्ट किए गए उत्तरों में सबसे छोटा है।
दूसरों के लिए के रूप में:

39 बाइट: पोर्ट @Arnauld के जावास्क्रिप्ट (ES6) से ।

int a(int a,int b){return a*b%24%11%2;}

39 बाइट्स: पोर्ट @MartinEnder के CJam उत्तर से

Object e(int a,int b){return a*b%51>9;}

47 बाइट्स: @Steadybox C उत्तर से पोर्ट

Object d(int a,int b){return(a=a*b%18)>7|a==3;}

52 बाइट्स: @ लियोन पायथन 2 उत्तर से पोर्ट

Object c(String s){return"WUBRGWGRBUW".contains(s);}

नोट: छोड़े गए उत्तर जो primes / palindromes और एक जैसे का उपयोग करते हैं, क्योंकि वे जावा में कम निकट हैं। ;)
TODO: मेरे अपने उत्तर के साथ आ रहा है .. हालाँकि मुझे संदेह है कि यह इनमें से अधिकांश से छोटा है।

सभी यहाँ कोशिश करें।

संपादित करें: ठीक है, कुछ अपने आप से आया है जो बहुत बुरा नहीं है:

50 बाइट्स:

Object c(int a,int b){return(a=a*b%18)>3&a<7|a<1;}

स्पष्टीकरण:

ab  a   b   a*b     %18

WU  87  85  7395    15
UB  85  66  5610    12
BR  66  82  5412    12
RG  82  71  5822    8
GW  71  87  6177    3
UW  85  87  7395    15
BU  66  85  5610    12
RB  82  66  5412    12
GR  71  82  5822    8
WG  87  71  6177    3

WB  87  66  5742    0
UR  85  82  6970    4
BG  66  71  4686    6
RW  82  87  7134    6
GU  71  85  6035    5
BW  66  87  5742    0
RU  82  85  6970    4
GB  71  66  4686    6
WR  87  82  7134    6
UG  85  71  6035    5

सभी दुश्मन या तो 4-6 (समावेशी) या 0.
EDIT2 की सीमा में हैं : हम्म .. मैंने अभी देखा कि यह @Steadybox के उत्तर के समान है .. :(

— केविन क्रूज़सेन
स्रोत
2

PHP, 31 बाइट्स

echo!strstr(WBGURWRUGBW,$argn);

साथ चलाएं echo AB | php -nR '<code>, जहां Aऔर Bदो रंग हैं।

strtrइनपुट मिलने पर स्थिति से स्ट्रिंग लौटाता है;
साथ WBGURWRUGBWके रूप में भूसे के ढेर यह एक truthy स्ट्रिंग अगर रंग शत्रु हैं देता है; खाली स्ट्रिंग यदि नहीं।

!सत्य स्ट्रिंग को बदल देता है false, जिसके परिणामस्वरूप रिक्त आउटपुट होता है
और रिक्त स्ट्रिंग को trueआउटपुट में परिणाम होता है 1।

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