क्या मैं नीचे बसा सकता हूं?

23

में द सेटेलर्स ऑफ कटान ईंट, प्रवेश करें, अयस्क, गेहूं, और भेड़: बोर्ड खेल, वहाँ पाँच संसाधन प्रकार हैं। एक बस्ती के निर्माण में एक ईंट, एक लॉग, एक गेहूं और एक भेड़ का खर्च आता है। हालांकि, आप एक अलग प्रकार के संसाधन प्राप्त करने के लिए चार समान संसाधनों में भी व्यापार कर सकते हैं। उदाहरण के लिए, यदि आपके हाथ में चार अयस्क थे, तो आप उन सभी को एक भेड़ का व्यापार कर सकते थे।

आपका काम यह निर्धारित करना है कि मैं अपने हाथ को देखते हुए एक समझौता कर सकता हूं या नहीं।

आपका कार्य

इनपुट पत्र के एक दृश्य होगा B, L, O, W, और S, किसी भी उचित प्रारूप में ले लिया। ये पत्र ऊपर दिए गए पाँच संसाधन प्रकारों के अनुरूप हैं। आपको आउटपुट चाहिए कि मेरे पास निपटान बनाने के लिए आवश्यक संसाधन हैं या नहीं, एक तरह के चार ट्रेडिंग की संभावना को ध्यान में रखते हुए।

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

टिप्पणियाँ

  • आपको यह आउटपुट करने की आवश्यकता नहीं है कि मुझे क्या ट्रेड करने की आवश्यकता है या मैं कितनी बस्तियों का निर्माण कर सकता हूं। एक साधारण "हाँ" या "नहीं" करेंगे।
  • आप यह नहीं मान सकते हैं कि इनपुट किसी विशेष क्रम में है। विशेष रूप से, आप यह नहीं मान सकते हैं कि एक ही प्रकार के संसाधन एक साथ समूहीकृत हैं, इसलिए OBLSOएक वैध इनपुट है।
  • यह निर्णय-समस्या है , इसलिए आप किसी भी मूल्य का उपयोग कर सकते हैं जिसका आप "हां" और "नहीं" चाहते हैं, जब तक कि दो चुने हुए मूल्य अलग और सुसंगत नहीं होते हैं।
  • केवल नियम जो हम यहाँ से संबंधित हैं, वे ऊपर सूचीबद्ध हैं। अन्य खिलाड़ियों के साथ या बंदरगाह पर व्यापार करने जैसे कैटन नियमों के अधिक जटिल सेटलर्स यहां प्रासंगिक नहीं हैं।
  • इनपुट वर्ण ( B, L, O, W, S) अन्य मूल्यों के साथ, जब तक कि वहाँ पांच अलग आदानों हैं प्रतिस्थापित किया जा सकता है अगर यह अपनी पसंद के विशेष भाषा के लिए आसान है। यदि आप अन्य इनपुट मानों का उपयोग करते हैं, तो कृपया उन्हें अपने उत्तर में निर्दिष्ट करें।

उदाहरण

BLWS -> Yes
OOOOWLB -> Yes (trade four O for a S)
OOW -> No
BBBO -> No
(empty input) -> No
BBBBLW -> No
BBBBBLW -> Yes (trade four B for a S)
OOOOOOOOOOOOOOOO -> Yes (sixteen O; trade for B, L, W, S)
BLBLBLBLBL -> Yes (trade L for W and B for S)
BLSWBLSWBLSW -> Yes (extra, unused resources are ignored)
code-golf  decision-problem  board-game 
— सिल्वियो मायोलो
स्रोत
13
"एक बस्ती के निर्माण में एक ईंट, एक लॉग, एक गेहूं और एक भेड़ का खर्च होता है"। हां, एक बस्ती के निर्माण की रस्म करने के लिए, आपको एक भेड़ की जरूरत है। आश्चर्य है कि कोई शाकाहारी क्यों नहीं हैं?
— ओकेक्स
5
@ ऑक्स, भेड़ बिल्डरों को खिलाने के लिए गेहूं से रोटी के साथ दूध देती है जो बिल्डरों को खिलाती है (वे भुगतान के रूप में भेड़ को अंत में अपने साथ ले जाते हैं)। बस्ती के निर्माण में किसी भी जानवर को चोट नहीं पहुंची थी
— आगंजू
क्या प्रोग्राम को इनपुट सॉर्ट करने की आवश्यकता है, यह ठीक है?
— 14
@NieDzejkob नहीं, आदेश देने की आवश्यकता विशेष रूप से अस्वीकृत है। पांच संसाधनों के किसी भी क्रम को संभालने के लिए आपका कार्यक्रम तैयार होना चाहिए।
— सिल्वियो मायोलो
@SilvioMayolo क्षमा करें, मुझे नहीं पता कि मैं कैसे चूक गया
— NieDzejkob

जवाबों:

16

पायथन 2 , 54 बाइट्स

lambda s:sum((s+"BLSW"*3).count(n)/4for n in"BLSWO")>3

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

हमारे प्रत्येक संसाधन के लिए, हम उस संसाधन के n होने के द्वारा दिए गए "फ्रीडम" की संख्या की गणना करते हैं । एक स्वतंत्रता ईंट-लॉग-गेहूं-भेड़ स्लॉट में से एक को भरने के लिए एक अवसर का प्रतिनिधित्व करती है जिसे हमें व्यवस्थित करने के लिए भरने की जरूरत है, इस तथ्य के लिए लेखांकन कि हम अपने संसाधनों को बदल सकते हैं।

सभी BLSW के लिए, संसाधन में से एक होने से हमें एक ऐसी स्वतंत्रता मिलती है, और 4 में से प्रत्येक अतिरिक्त अतिरिक्त हमें एक और देता है। स्वतंत्रता-गणना नियम इस प्रकार है:

* Having 1 brick/log/wheat/sheep gives 1 freedom.
* Having 5 bricks/logs/wheat/sheep gives 2 freedoms.
* Having 9 bricks/logs/wheat/sheep gives 3 freedoms.
* …

तो n ईंटें / लॉग / गेहूं / भेड़ दे n (n + 3) / 4ed स्वतंत्रता।

अयस्कों के लिए, केवल अतिरिक्त चार सेम्स की गिनती होती है। स्वतंत्रता-गणना नियम इस प्रकार है:

* Having 4 ores gives 1 freedom.
* Having 8 ores gives 2 freedoms.
* Having 12 ores gives 3 freedoms.
* …

तो n ores ⌊n / 4⌋ फ्रीडम देते हैं।

प्रमेय: हम तभी निपट सकते हैं जब हमारे पास “4 ऐसे" स्वतंत्रता "हों।

इसलिए हम अपनी स्वतंत्रता की गणना करते हैं और जांचते हैं कि उनमें से ed 4 हैं या नहीं। ⌋N / 4 counting लेकिन अन्य संसाधनों + (n + 3) / 4⌋ के रूप में गिनती अयस्कों को संभालने के लिए, हम कृत्रिम रूप से अन्य संसाधनों के लिए 3 से गिनती बढ़ाते हैं और फिर उन सभी के लिए /n / 4⌋ की गिनती करते हैं। हम (s+"BLSW"*3).countइसकी जगह मैपिंग करके करते हैं s.count।

प्रमाण :

  • मान लीजिए हम निपट सकते हैं। फिर [बी, एल, एस, डब्ल्यू] में से प्रत्येक के लिए, हमने या तो (ए) उस संसाधन का 1 उपयोग किया जो हमारे पास पहले से था, या (बी) इसे बनाने के लिए कुछ अन्य संसाधन (अयस्कों सहित) में से 4 का बलिदान किया। किसी भी मामले में, हम उपरोक्त नियमों द्वारा कम से कम 1 स्वतंत्रता की गणना करते हैं। इसलिए हमारे पास ≥ 4 स्वतंत्रताएं हैं।

  • मान लीजिए कि हमें 4 स्वतंत्रता, कश्मीर जिनमें से "ज्यादतियों" की वजह से हैं (अयस्कों से हर स्वतंत्रता एक अतिरिक्त, और अन्य संसाधनों से हर स्वतंत्रता है अतीत और 4-कश्मीर पहले एक भी है), जिनमें से कम से कम एक में मालिक की गवाह हैं ईंट / लॉग / गेहूं / भेड़ ("प्रथम स्वतंत्रता" देने वाला)। फिर हम ईंट / लॉग / गेहूं / भेड़ के साथ 4 slots k स्लॉट भरते हैं, जिसने हमें हमारी पहली स्वतंत्रता दी, और हमारी अतिरिक्तताओं को परिवर्तित करके शेष k स्लॉट्स को भरें। सभी 4 स्लॉट भरे हुए हैं और हम निपट सकते हैं। हम स्पष्ट रूप से अभी भी ऐसा कर सकते हैं यदि हमारे पास 4 से अधिक स्वतंत्रताएं हैं।

यह सबूत बेकार है, लेकिन मुझे नींद आ रही है। मुझे यकीन है कि एक बेहतर व्याख्या है।

— लिन
स्रोत
2
ऐसा कहते sहै OOOOBLW, तुम हो रही अंत sum(n/4for n in map(("OOOOBLWBBBLLLSSSWWW").count,"BLSWO"))>3... इसलिए से प्रत्येक के लिए BLOWSआप गिनती कितनी बार इसके बारे में है कि स्टार्टर स्ट्रिंग में प्रकट होता है "BLWS"*3, तो यह कुल मिलाकर।
— 9
2
ठीक! (स्ट्रिंग "OOOOBLWBLSWBLSWBLSW"वास्तव में है, लेकिन मायने वही हैं, निश्चित रूप से।)
— लिन
पायथन मैप 'बैकवर्ड' होने के कारण हमेशा मुझे भ्रमित करता है!
— प्योरफेरेट
in"BLSWO"अजगर के बीच का स्थान अनावश्यक है, है ना? कम से कम TIO में काम करने लगता है ..
— केविन क्रूज़सेन
8

पायथन 2 ,  52  51 बाइट्स

-1 बाइट धन्यवाद ल्यूक (की जगह >=0के साथ <0, inverting False/ Trueपरिणाम)

lambda h:sum(~-(h+"O").count(c)/4for c in"BOWLS")<0

एक अनाम फ़ंक्शन बी , ओ , डब्ल्यू , एल , और एस (ओपी के रूप में) के पात्रों की एक स्ट्रिंग ले रहा है और Falseयदि आप समझौता कर सकते हैं या Trueनहीं तो वापस लौट सकते हैं।

इसे ऑनलाइन आज़माएं! (yes/noओपी केलिए उत्पादन coerces)।

कैसे?

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

lambda h:sum(~-(h+"O").count(c)/4for c in"BOWLS")<0
lambda h:                                           - a function that takes h (a string)
                                 for c in"BOWLS"    - for each letter, c, in "BOWLS":
                h+"O"                               -   append "O" to h
               (     ).count(c)                     -   count c instances
              -                                     -   negate
             ~                                      -   bitwise not (this is -x-1)
                               /4                   -   integer divide by 4
                                                    -    (NB: -1 and 0 are not affected)
         sum(                                   )   - sum the five values
                                                 <0 - less than zero? (inverted result)
— जोनाथन एलन
स्रोत
कैसे और किसके Falseलिए उपयोग कर रहे हैं ? तो फिर तुम बदल सकता है के लिए , 1 बाइट की बचत। 'yes'True'no'>=<
— ल्यूक
मैं सवाल करने के लिए संसाधन आदेश देने की आपकी पसंद को पसंद करता हूं!
— नील
7

अजगर , 14 बाइट्स

gsm/t/+Q4d4U5Z

यहाँ कोशिश करो! या सभी परीक्षण मामलों को सत्यापित करें।

पायथ ,  31 27 17  16 बाइट्स

<3s/R4/L+Q*3U4U5

परीक्षण मामलों की जाँच करें।

ये कैसे काम करते हैं?

स्पष्टीकरण # 1

gsm/t/+Q4d4U5Z   - Full program.

  m        U5    - Map over the range [0, 5) with a variable d.
      +Q4        - The input, with a 4 appended (this corresponds to O)
     /   d       - Count the occurrences of the current value in ^.
    t            - Decrement.
   /      4      - Integer division by 4.
 s               - Sum
g            Z   - Is non-negative (is the sum ≥ 0)?  
                 - Output implicitly.

व्याख्या # २

<3s/R4/L+Q*3U4U5   - Full program.

          *3U4     - The range [0, 4) repeated 3 times.
        +Q         - The input with ^ appended.
      /L      U5   - Count the occurrences of each element in [0, 5) in ^.
   /R4             - Integer division of each by 4.
  s                - Sum.
<3                 - Is higher than 3?
                   - Output implicitly.

ये मेरे प्रोग्राम द्वारा उपयोग किए जाने वाले कोड हैं:

B -> 0
L -> 1
S -> 2
W -> 3
O -> 4
— मिस्टर एक्सकोडर
स्रोत
+%ld4/ld4->s.Dld4
— आउटगॉल्फ
ओह, ठीक है।
— आउटगॉल्फ
मुझे विश्वास है कि //Q4 4हो सकता है, /Q16लेकिन मुझे यकीन नहीं है ...
— एर्ग आउटफ्लोफर
@EriktheOutgolfer यह अमान्य था ... BBBOउदाहरण के लिए विफल
— श्री Xcoder
@EriktheOutgolfer नहीं, यह होने वाली घटनाओं को गिनता है 4और विभाजित करता है 4।
— श्री Xcoder
6

जेली ,  13  12 बाइट्स

;5ċЀ5’:4S>-

आपके द्वारा दिए गए संसाधनों का प्रतिनिधित्व करने वाली संख्या की एक सूची को स्वीकार करने और वापस लौटने 1या 0नहीं रहने पर एक विवादास्पद लिंक ।

संसाधन 1, 2, 3, 4, 5जहां Ore का5 प्रतिनिधित्व करते हैं ।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट (ओपी आईओ का उपयोग करके) देखें।

कैसे?

यह विचार है कि पहले संसाधनों को टाइप करके गिना जाए, फिर बी , एल , डब्ल्यू और एस की सभी संख्याओं को एक-एक करके घटाया जाए - अगर हम इन चार में से किसी के लिए भी नहीं गिने जाते हैं, तो उनके पास अब -1 की प्रविष्टियां होंगी - हमें अधिग्रहण करना होगा उन्हें हमारे बचे हुए संसाधनों से (यह वास्तव में एक अतिरिक्त O ( 5) जोड़कर और सभी पांच गणनाओं को 1 से घटाकर प्राप्त किया जाता है )। इसके बाद हम इन सभी मूल्यों को चार से विभाजित करते हैं, यह देखने के लिए कि -1 और 0 काउंट को प्रभावित न करते हुए हम संसाधन इकाइयों द्वारा अपनी शेष गणना में से प्रत्येक के लिए कितनी इकाइयों के साथ व्यापार कर सकते हैं (ध्यान दें कि -1 पूर्णांक चार से विभाजित है।-1 , 0 नहीं )। अंत में हम मान जोड़ते हैं और जांचते हैं कि परिणाम शून्य से अधिक या इसके बराबर है (यहां -1 से अधिक का उपयोग किया जा सकता है क्योंकि हमारे पास हमेशा पूर्णांक होते हैं)।

;5ċЀ5’:4S>- - Link: list of numbers (BLWSO:12345) e.g. [3,2,2,2,2,2,5,5,5,5] (WLLLLLOOOO)
;5           - concatenate a five                       [3,2,2,2,2,2,5,5,5,5,5]
     5       - literal 5
   Ѐ        - map across implicit range(5) = [1,2,3,4,5]:
  ċ          -   count                                  [ 0, 5, 1, 0, 5]
      ’      - decrement (vectorises)                   [-1, 4, 0,-1, 4]
       :4    - integer divide by four                   [-1, 1, 0,-1, 1]
         S   - sum                                      0
           - - literal -1                              -1
          >  - greater than?                            1
— जोनाथन एलन
स्रोत
5

जावा 8, 101 बाइट्स

से लैम्ब्डा int[]के लिए boolean। को सौंपे Function<int[], Boolean>।

a->{int h,f[]=new int[5],i=0;for(int x:a)f[x]++;for(h=f[4]/4;i<4;)h+=--f[i]>>-1|f[i++]/4;return~h<0;}

यह ऑनलाइन की कोशिश करो

इनपुट और आउटपुट

इनपुट 0 से 4 तक पूर्णांकों की एक सरणी है, समावेशी है। 4 अयस्क का प्रतिनिधित्व करता है, और अन्य मैपिंग सारहीन हैं। मेरे परीक्षण के मामले प्रश्न में उन लोगों के प्रत्यक्ष अनुवाद हैं, जिनमें 0 ईंट के रूप में, 1 लॉग के रूप में, 2 गेहूं के रूप में और 3 भेड़ के रूप में हैं।

आउटपुट है कि क्या एक समझौता बनाया जा सकता है।

Ungolfed

a -> {
    int
        h,
        f[] = new int[5],
        i = 0
    ;
    for (int x : a)
        f[x]++;
    for (h = f[4] / 4; i < 4; )
        h += --f[i] >> 31 | f[i++] / 4;
    return ~h < 0;
}

व्याख्या

hव्यापार के लिए उपलब्ध संसाधन चौगुनी की संख्या है। हम प्रत्येक संसाधन प्रकार (अयस्क को छोड़कर) पर पुनरावृत्ति hकरते हैं, हमारे पास अतिरिक्त संसाधनों के प्रत्येक चौगुनी के लिए वेतन वृद्धि होती है, और जहां कोई संसाधन मौजूद नहीं होते हैं, वहां कमी होती है। फिर हमारा नतीजा यह है कि क्या hनॉन-नेटिव है।

रेखा

h += --f[i] >> 31 | f[i++] / 4;

इस बात की hपरवाह किए बिना कि क्या कोई संसाधन (कमी) नहीं है या कम से कम एक संसाधन (अधिशेष) है या नहीं। f[i]अधिशेष मामले में आवश्यक संसाधन के लिए खाते में कमी की जाती है, जो कमी के मामले में -1 का उत्पादन करता है। हस्ताक्षरित राइट शिफ्ट एक्सप्रेशन को घटाकर 0 (सरप्लस केस) या -1 (शॉर्टेज केस) में बदल देती है, जिससे कि एक बिटवाइज़ या f[i++] / 4सरप्लस क्वाड्रुपल्स की संख्या (सरप्लस केस में) की कमी के मामले में कोई प्रभाव नहीं पड़ता है, लेकिन परिणाम में नंबर अधिशेष मामले में ही।

स्वीकृतियाँ

  • -9 बाइट्स नेवय, बिट्स के मास्टर के लिए धन्यवाद
— जेकब
स्रोत
-3 बाइट्स ...for(h=f[4]/4;i<4;h+=f[i++]/4)n+=--f[i]>>-1;return~h<n;:।
— नेवई
103 बाइट्स:a->{int h,f[]=new int[5],i=0;for(int x:a)f[x]++;for(h=f[4]/4;i<4;h+=f[i++]/4)h+=--f[i]>>-1;return~h<0;}
— नेवई
2
101 बाइट्स:a->{int h,f[]=new int[5],i=0;for(int x:a)f[x]++;for(h=f[4]/4;i<4;)h+=--f[i]>>-1|f[i++]/4;return~h<0;}
— नेवे
अब यह कुछ रसदार बिट हैकिंग है!
— जैकब
4

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

^
BBBLLLWWWSSS
O`.
((.)\2{3}.*){4}

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: एक निपटान का निर्माण करने के लिए ४ संसाधनों की आवश्यकता होती है जो या तो आपके पहले बी, एल, डब्ल्यू, या एस, या किसी अन्य प्रकार के ४ संसाधन हैं। यह उन चार प्रकार के संसाधनों में से तीन को जोड़ने के बराबर है, और फिर यह देखने के लिए कि क्या आपके पास चार के चार सेट हैं।

— नील
स्रोत
2

पायथन 3 , 79 78 बाइट्स

संपादित करें: -1 बाइट @ मिस्टरकोड के लिए धन्यवाद

lambda x:3<sum((a>0)+~-a*(a>1)//4for a in map(x.count,"BLSW"))+x.count("O")//4

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

— हलवार्ड वुल्फ
स्रोत
यदि आप अजगर 2 पर जाने के लिए तैयार हैं, तो आप इसे 77 बाइट्स
— श्री एक्सकोडर
— श्री एक्सकोडर
@श्री। Xcoder आप पायथन 2 समाधान क्यों नहीं बनाते हैं?
— जैकब
@ जाकोब क्योंकि यह हालवर्ड के समान है।
— मिस्टर एक्सकोडर
@ Mr.Xcoder इसे Python 3
— Halvard Wil
2

MATL , 19 बाइट्स

Oh!5:=s4&\w4:)ghs3>

इनपुट एक संख्यात्मक पंक्ति वेक्टर है जहां अक्षरों को निम्नानुसार संख्याओं के रूप में दर्शाया जाता है:

B: 1
L: 2
W: 3
S: 4
O: 5

उत्पादन 1सत्य के लिए है, 0मिथ्या के लिए है।

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

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

  1. प्रत्येक संसाधन के महासागरों की गणना करें।
  2. उन्हें 4 से विभाजित करें।
  3. गणना करें कि पहले चार संसाधनों (अक्षर BLWS) के कितने अवशेष नॉनज़रो हैं। यह एक संख्या सी देता है ।
  4. कोटेदार योग करें। इससे नंबर s मिलता है ।
  5. आउटपुट c + s । 4 है या नहीं।

टिप्पणी कोड

Oh     % Append 0 to implicit input. This is just in case inpout is empty
!      % Convert into column vector
5:     % Push row vector [1 2 3 4 5]
=      % Compare for equality, element-wise with broadcast
s      % Sum of each column. Gives number of times that each entry of
       % [1 2 3 4 5] appears in the input
4&\    % Mod-div 4, element-wise. Pushes vector of remainders and then vector
       % of quotients of division by 4
w      % Swap. Brings remainders to top
4:)    % Get the first four entries
g      % Convert to logical. This transforms non-zero values into 1
h      % Concatenate with vector of quotients
s      % Sum
3>     % Does the result exceed 3? Implicitly display
— लुइस मेंडो
स्रोत
2

> <> , 61 बाइट्स

510ap\~1(n;
1+$ap> i:0(?v8%:ag
0:ga:v?=5:+1<$-}$,4-%4:-}-${:)

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

निम्नलिखित संसाधन मानचित्रण का उपयोग करता है:

O -> 0
B -> 1
L -> 2
W -> 3
S -> 4

यह वास्तव में मायने नहीं रखता है कि मैपिंग का उपयोग क्या है, जब तक वे सीमा में हैं 0-4, और 0ओ के लिए उपयोग किया जाता है। इस तथ्य का उपयोग करता है कि संयोजन BLWSकी तलाश उसी तरह की है जैसे OBLWSपहले से ही होने के दौरान संयोजन की तलाश Oमें है। हाथ।

— सोक
स्रोत
1

05AB1E , 19 बाइट्स

0 -> अयस्क
1 -> ईंट
2 -> लॉग
3 -> गेहूं
4 -> भेड़

झूठे होने पर 0 देता है, और 1 अन्यथा।

{γvyDĀi¼¨}g4÷}¾)O3›

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

स्पष्टीकरण:

{γvyDĀi¼¨}g4÷}¾)O3› Implicit input, e.g. 0030201
{                   Sort -> 0000123
 γ                  Split into chunks of consecutive elements: [0000, 1, 2, 3]
  vy                For each chunk...
    DĀ                 ...is different than 0?
      i¼¨}                ...if true: increment the counter by 1, and 
                              remove 1 element from the chunk
          g4÷         ...divide the number of elements by 4
             }      End For
              ¾     Push the counter
               )    Wrap the entire stack in a list
                O   Sum of that list
                 3> True if > 3
                    Implicit output

गैर-सक्षम समाधान: 17 बाइट्स

05AB1E में एक बग था जब मैंने पहली बार उस समाधान को प्रस्तुत किया था, जहां कुछ ऑपरेटरों ने खाली इनपुट को बुरी तरह से संभाला था। यह इस समाधान के परिणामस्वरूप 1एक खाली इनपुट पर उत्तर देता है । यह अब ठीक हो गया है, इसलिए यह समाधान ठीक काम करता है।

यहां अंतर यह है कि हम प्रत्येक संसाधन में से एक को हटाने से पहले एक अयस्क जोड़ते हैं, अंधाधुंध, उस तरह से हटाए गए संसाधनों की संख्या की गणना करते हैं। हम फिर बी, एल, डब्ल्यू और एस की सही संख्या प्राप्त करने के लिए काउंटर को 1 से घटाते हैं।

0«{γε¨g4÷¼}O¾<+3›

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

— scottinet
स्रोत
0

जावास्क्रिप्ट (स्पाइडरमोनी) , 116 बाइट्स

s=>Array.from("BLOWS").reduce((m,c)=>Math.floor(((s+"BLSW".repeat(3)).match(new RegExp(c,'g'))||"").length/4)+m,0)>3

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

सुपर क्लंकी बुरा जवाब। मुझे यकीन है कि इसे और अधिक साफ किया जा सकता है। इस धागे में लिन के उत्तर से प्रेरित विधि।

— Pureferret
स्रोत
0

कोटलिन , 131 129 बाइट्स

प्रस्तुत करने

fun r(i:String):Any=i.split("").groupingBy{it}.eachCount().map{when(it.key){
""->0
"O"->it.value/4
else->(it.value+3)/4}}.sum()>3

परीक्षा

fun r(i:String):Any=i.split("").groupingBy{it}.eachCount().map{when(it.key){
""->0
"O"->it.value/4
else->(it.value+3)/4}}.sum()>3

data class TestData(val input:String, val output:Boolean) {
    fun run() {
        val out = r(input)
        if (out != output) {
            throw AssertionError("Failed test: ${this} -> $out")
        }
    }
}
fun main(args: Array<String>) {
    listOf(

            TestData("BLWS", true),
            TestData("OOOOWLB", true),
            TestData("OOW", false),
            TestData("BBBO", false),
            TestData("", false),
            TestData("BBBBLW", false),
            TestData("BBBBBLW", true),
            TestData("OOOOOOOOOOOOOOOO", true),
            TestData("BLBLBLBLBL", true),
            TestData("BLSWBLSWBLSW", true)
    ).forEach(TestData::run)
    println("Test passed")
}

TryItOnline पर काम नहीं कर सकता, लेकिन try.kotlinlang.org पर काम करता है

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