दर्शनीय पासा चेहरे

Question

एक पारंपरिक पश्चिमी मृत्यु एक घन है, जिस पर पूर्णांक 1 से 6 अंकित हैं। जोड़े जो 7 जोड़ते हैं, उन्हें विपरीत चेहरों पर रखा जाता है।

जैसा कि यह घन है, हम किसी भी समय केवल 1 और 3 चेहरे (समावेशी) ^{1 के} बीच देख सकते हैं । एक ही समय में विपरीत चेहरे कभी नहीं देखे जा सकते हैं।

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जो एक मरने पर पक्षों का प्रतिनिधित्व करने वाले पूर्णांकों की एक सूची देता है, यह निर्धारित करता है कि क्या एक ही समय में इन चेहरों को देखना संभव है।

¹ _{ठीक है, हो सकता है कि आप 4 या 5 चेहरों को आँखों की एक जोड़ी के साथ देख सकते हैं, लेकिन इस चुनौती के उद्देश्य से हम एक बिंदु से मरना देख रहे हैं।}

---

नियम:

• आपकी प्रविष्टि इनपुट सूची मान सकती है:
  • गैर-रिक्त है।
  • केवल वे ही मूल्य हैं जो संतुष्ट करते हैं 1 ≤ n ≤ 6।
  • कोई डुप्लिकेट तत्व नहीं है।
• आप यह नहीं मान सकते हैं कि इनपुट क्रमबद्ध है।
• आपका सबमिशन एक सत्य / मिथ्या मूल्य का उत्पादन करना चाहिए : सच्चाई यह है कि चेहरे एक ही समय में देखे जा सकते हैं, मिथ्या अन्यथा।
• यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है!
• मानक कमियां डिफ़ॉल्ट रूप से मना की जाती हैं।

---

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

Truthy:

[6]                 (One face)
[6, 2]              (Share a side)
[1, 3]              (Share a side)
[2, 1, 3]           (Share a vertex)
[3, 2, 6]           (Share a vertex)

Falsy:

[1, 6]              (1 and 6 are opposite)
[5, 4, 2]           (2 and 5 are opposite)
[3, 1, 4]           (3 and 4 are opposite)
[5, 4, 6, 2]        (Cannot see 4 faces)
[1, 2, 3, 4, 5, 6]  (Cannot see 6 faces)

Comments

संबंधित ।

— 20

ऐसा लगता है कि पिछले दो झूठे मामले बहुत ही कम हैं क्योंकि 3 से अधिक किसी भी सूची में विरोधी मूल्य होंगे, नहीं?

— वीकर ई।

@ WeckarE हाँ, जाहिर है - यदि आपके पास उन उत्तरों पर एक नज़र है जो वे सभी इसका फायदा उठाते हैं। यह लिखने के लिए सिर्फ एक आसान स्पष्टीकरण था।

— 15

@FlipTack वास्तव में आपको लंबाई की जांच करने की आवश्यकता नहीं है, 3 तत्वों से अधिक लंबी प्रत्येक सूची में विपरीत पक्षों की कम से कम एक जोड़ी है।

— E१rik को आउटगोल्फर एरिक

आप अभी भी एक ही बिंदु से 5 चेहरों को देख सकते हैं यदि आप एक ब्लैक होल जैसी किसी भारी चीज के साथ प्रकाश तरंगों को

— झुकाते हैं

Answer 1

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

lambda a:any(7-i in a for i in a)<1

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

Comments

पायथन में -1 बाइट 3.

— 22

Answer 2

जावास्क्रिप्ट (ईएस 6),  38 34 30 29  28 बाइट्स

इनपुट को अलग-अलग मापदंडों की संख्या के रूप में लेता है। लौटाता है 0या 1।

(a,b,c,d)=>!(d|(a^b^c)%7)^!c

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

let f =

(a,b,c,d)=>!(d|(a^b^c)%7)^!c

console.log('[Truthy]')
console.log(f(6      ))
console.log(f(6, 2   ))
console.log(f(1, 3   ))
console.log(f(2, 1, 3))
console.log(f(3, 2, 6))

console.log('[Falsy]')
console.log(f(1, 6            ))
console.log(f(5, 4, 2         ))
console.log(f(3, 1, 4         ))
console.log(f(5, 4, 6, 2      ))
console.log(f(1, 2, 3, 4, 5, 6))

कैसे?

नीचे प्रदान की मानकों की संख्या के अनुसार मुख्य अभिव्यक्ति के संस्करणों को सरल बनाया जाता है, अपरिभाषित चर या तो करने के लिए मजबूर किया जा रहा 0 या गलत :

# of param. | simplified expression        | comment
------------+------------------------------+---------------------------------------------
     1      | !(a % 7) ^ 1                 | always true
     2      | !((a ^ b) % 7) ^ 1           | false for (1,6), (2,5) and (3,4)
     3      | !((a ^ b ^ c) % 7)           | see the table below
     4+     | !(d | (a ^ b ^ c) % 7)       | always false

NB : (ए, बी, सी) का क्रम कोई फर्क नहीं पड़ता क्योंकि वे हमेशा एक साथ XOR'd हैं।

पेचीदा मामला तीसरा है। यहाँ एक तालिका है जो सभी संभावित संयोजनों को दिखा रही है:

a | b | c | a^b^c | %7 | =0? | faces that sum to 7
--+---+---+-------+----+-----+--------------------
1 | 2 | 3 |   0   |  0 | Yes | none
1 | 2 | 4 |   7   |  0 | Yes | none
1 | 2 | 5 |   6   |  6 | No  | 2 + 5
1 | 2 | 6 |   5   |  5 | No  | 1 + 6
1 | 3 | 4 |   6   |  6 | No  | 3 + 4
1 | 3 | 5 |   7   |  0 | Yes | none
1 | 3 | 6 |   4   |  4 | No  | 1 + 6
1 | 4 | 5 |   0   |  0 | Yes | none
1 | 4 | 6 |   3   |  3 | No  | 1 + 6
1 | 5 | 6 |   2   |  2 | No  | 1 + 6
2 | 3 | 4 |   5   |  5 | No  | 3 + 4
2 | 3 | 5 |   4   |  4 | No  | 2 + 5
2 | 3 | 6 |   7   |  0 | Yes | none
2 | 4 | 5 |   3   |  3 | No  | 2 + 5
2 | 4 | 6 |   0   |  0 | Yes | none
2 | 5 | 6 |   1   |  1 | No  | 2 + 5
3 | 4 | 5 |   2   |  2 | No  | 3 + 4
3 | 4 | 6 |   1   |  1 | No  | 3 + 4
3 | 5 | 6 |   0   |  0 | Yes | none
4 | 5 | 6 |   7   |  0 | Yes | none

---

ऑल्ट। संस्करण # 1, 32 बाइट्स

एक सरणी के रूप में इनपुट लेता है। एक बूलियन देता है।

a=>a.every(x=>a.every(y=>x+y-7))

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

let f =

a=>a.every(x=>a.every(y=>x+y-7))

console.log('[Truthy]')
console.log(f([6]      ))
console.log(f([6, 2]   ))
console.log(f([1, 3]   ))
console.log(f([2, 1, 3]))
console.log(f([3, 2, 6]))

console.log('[Falsy]')
console.log(f([1, 6]            ))
console.log(f([5, 4, 2]         ))
console.log(f([3, 1, 4]         ))
console.log(f([5, 4, 6, 2]      ))
console.log(f([1, 2, 3, 4, 5, 6]))

---

ऑल्ट। संस्करण # 2, क्रोम / फ़ायरफ़ॉक्स, 34 बाइट्स

यह Chrome और फ़ायरफ़ॉक्स के प्रकार के तरीकों का दुरुपयोग करता है। यह एज के साथ काम नहीं करता है।

एक सरणी के रूप में इनपुट लेता है। लौटाता है 0या 1।

a=>a.sort((a,b)=>k&=a+b!=7,k=1)&&k

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

let f =

a=>a.sort((a,b)=>k&=a+b!=7,k=1)&&k

console.log('[Truthy]')
console.log(f([6]      ))
console.log(f([6, 2]   ))
console.log(f([1, 3]   ))
console.log(f([2, 1, 3]))
console.log(f([3, 2, 6]))

console.log('[Falsy]')
console.log(f([1, 6]            ))
console.log(f([5, 4, 2]         ))
console.log(f([3, 1, 4]         ))
console.log(f([5, 4, 6, 2]      ))
console.log(f([1, 2, 3, 4, 5, 6]))

Answer 3

हास्केल , 24 बाइट्स

-3 बाइट्स H.PWiz को धन्यवाद।

f l=all(/=7)$(+)<$>l<*>l

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

व्याख्या

f l=all(/=7)$(+)<$>l<*>l

f l=                      -- make a function f that takes a single argument l
             (+)<$>l<*>l  -- take the sum of each pair in the cartesian product...
    all(/=7)$             -- ...and check if they're all inequal to 7

Answer 4

एपीएल (डायलॉग) , 7 बाइट्स

~7∊∘.+⍨

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

∘.+⍨ - इसके अलावा तालिका (हर तत्व के साथ हर तत्व)

7∊ - 7 मौजूद है?

~ - नकारात्मक

---

एपीएल (डायलॉग) , 7 बाइट्स

⍬≡⊢∩7-⊢

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

7-⊢ - प्रत्येक तत्व को 7 से घटाएं

⊢∩ - मूल सरणी के साथ काटना

⍬≡ - खाली?

Answer 5

आर , 27 बाइट्स

बग को ठीक करने के लिए ग्रेगर का धन्यवाद

function(d)!any((7-d)%in%d)

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

पोर्ट ऑफ चास ब्राउन का जवाब । सदिश परिचालनों के होने से यह R में बहुत कम हो जाता है।

Comments

मुझे लगता है कि आपको आसपास कुछ परागों की आवश्यकता है (7-d), अन्य बुद्धिमान d%in%dपूर्वता लेते हैं।

— ग्रेगर

@Gregor आप बिल्कुल सही हैं।

— ग्यूसेप

Answer 6

गणितज्ञ, 20 बाइट्स

xFreeQ[#+x&/@x,7]

है\[Function]

मार्टिन एंडर से -12 बाइट्स
मिशा लावरोव से बाइट्स

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

Answer 7

हास्केल , 26 बाइट्स

f x=null[1|7<-(+)<$>x<*>x]

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

Answer 8

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

!@-L7

इसे यहाँ आज़माएँ।

Comments

मैं कसम खा सकता हूं कि मैंने दो मिनट पहले यह कोशिश की और यह काम नहीं किया ... हुह मुझे आश्चर्य है कि क्या गलत हो गया

— श्री Xcoder

पहली बात मैंने सोचा था? द सैंडलोट ।

— मैक्सथौसंड

Answer 9

दरअसल , 8 बाइट्स

;∙♂Σ7@cY

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

स्पष्टीकरण:

;∙♂Σ7@cY
;∙        Cartesian product with self
  ♂Σ      sum all pairs
    7@c   count 7s
       Y  logical negate

Answer 10

भूसी , 5 बाइट्स

Ëo≠7+

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

व्याख्या

Ëo     Check that the following function gives a truthy value for all pairs 
       from the input.
    +    Their sum...
  ≠7     ...is not equal to 7.

Answer 11

रेटिना , 21 20 बाइट्स

O`.
M`1.*6|2.*5|34
0

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। संपादित करें: @MartinEnder के लिए 1 बाइट धन्यवाद सहेजा गया। स्पष्टीकरण:

O`.

इनपुट को क्रमबद्ध करें।

M`1.*6|2.*5|34

विपरीत पक्षों की एक जोड़ी की जाँच करें (3 और 4 एक दूसरे के बगल में)। यह अमान्य 1 के लिए 1 या वैध के लिए 0 रिटर्न देता है।

0

तार्किक रूप से परिणाम को नकारें।

Answer 12

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

7_f⁸Ṇ

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

पोर्ट ऑफ चास ब्राउन का जवाब ।

व्याख्या

7_f⁸Ṇ
7_    Subtract each element from 7
  f⁸  Filter with the original list
    Ṇ Check if empty 

Answer 13

ऐलिस , 18 बाइट्स

/..y1nr@ 
\iReA6o/

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

Jabberwockyमान्य इनपुट के लिए प्रिंट और अन्यथा कुछ भी नहीं।

व्याख्या

ज़िगज़ैग नियंत्रण प्रवाह को अनफॉलो करते हुए, कार्यक्रम वास्तव में सिर्फ:

i.e16r.RyAno

i.  Read all input and duplicate it.
e16 Push "16".
r   Range expansion to get "123456".
.R  Duplicate and reverse.
y   Transliterate, replaces each face with its opposite.
A   Intersection with input.
n   Logical NOT, turns empty strings into "Jabberwocky"
    and everything else into an empty string.

Answer 14

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

-7sM*

परीक्षण सूट।

isaacg ने बाइट को बचा लिया!

Answer 15

रूबी , 36 31 24 23 बाइट्स

->l{l-l.map{|x|7-x}==l}

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

यह बहुत आसान था, मैं हर समय गलत समस्या के समाधान की तलाश में था।

Answer 16

05AB1E , 5 बाइट्स

7αå_P

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

व्याख्या

7α      # absolute difference between 7 an each in input list
  å     # check each element if it exist in input
   _    # logical negate
    P   # product of list

05AB1E में 5 बाइट्स में ऐसा करने के कई तरीकों में से एक

Answer 17

पर्ल 5 , 51 + 1 ( -a) = 52 बाइट्स

say$F[0]+($t=$F[1])-7&&$F[0]+$t-7&&$t+$F[2]-7&&@F<4

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

Comments

3 1 4यह सच है, के बारे में क्याsay 1>grep{$x=$_;grep$_+$x==7,@F}@F

— Nahuel Fouilleul

25 + 1 (-पी)

— सेड

Answer 18

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

T`_654`d
M`(.).*\1
0

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

नील के दृष्टिकोण का एक विकल्प।

व्याख्या

T`_654`d

बारी 6, 5, 4में 1, 2, 3, क्रमशः।

M`(.).*\1

बार-बार वर्ण खोजने और मैचों की संख्या गिनने का प्रयास करें।

0

सुनिश्चित करें कि परिणाम शून्य (प्रभावी रूप से एक तार्किक निषेध) था।

Answer 19

जावा (ओपनजेडके 8) , 43 बाइट्स

l->l.stream().noneMatch(x->l.contains(7-x))

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

Answer 20

GNU sed , 37 22 + 1 = 23 बाइट्स

-rझंडे के लिए +1 बाइट । अंकों के रूप में इनपुट लेता है; सत्य के लिए और झूठे के लिए इनपुट प्रिंट करता है 0।

-10 बाइट्स @MartinEnder को धन्यवाद।

y/123/654/
/(.).*\1/c0

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

व्याख्या

@ मार्टिनएंडर के एलिस जवाब के समान ।

y/123/654/   # Transliterate 1-3 to 6-4
/(.).*\1/c0  # If a digit appears twice, replace the pattern space with 0

Comments

यह पूरी तरह से सत्य के लिए इनपुट को प्रिंट नहीं करता है, यह इनपुट को 6-4 द्वारा प्रतिस्थापित 1-3 के साथ प्रिंट करता है।

— एंड्रयू का कहना है कि

Answer 21

पर्ल 6 , 18 बाइट्स

!(1&6|2&5|3&4∈*)

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

1 & 6 | 2 & 5 | 3 & 4एक जंक्शन है जिसमें संख्या 1 और 6, या संख्या 2 और 5, या संख्या 3 और 4 है। यह जंक्शन ∈इनपुट सूची का एक तत्व है ( *यदि इसमें 1 और 6, या 2 और 5, या 3 शामिल हैं। और 4. यह परिणाम !आवश्यक बूलियन मान प्राप्त करने के लिए तब ( ) उपेक्षित है।

Answer 22

हास्केल, 46 41 37 बाइट्स

f z=all ((/=7).sum) [[x,y]|x<-z,y<-z]

सूची के कार्टेशियन उत्पाद को अपने साथ ले जाता है, फिर जांचता है कि परिणामी सूचियों में से सभी का योग 7 से नहीं है (यदि उनमें से कोई 7 को सम्मनित किया गया, तो विपरीत चेहरे दिखाई देंगे, और "सभी" से छोटा है "नहीं" कोई भी ")

Answer 23

जे , 12 बाइट्स

7-.@e.[:,+/~

यह बहुत हद तक उरीएल द्वारा पहले एपीएल समाधान के समान है

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

Answer 24

आईबीएम / लोटस नोट्स फॉर्मूला, 7 बाइट्स

!7-i*=i

एक बहु-मूल्य संख्या क्षेत्र से इनपुट लेता है i।

पुन: 7 से i के प्रत्येक मान को पुन: घटाता है और यह देखने के लिए जाँच करता है कि क्या यह मूल सूची में है। ! 1 को बदलता है यदि यह 0 पर है (चेहरे सभी नहीं देखे जा सकते हैं)।

टेस्ट केस (नोट्स फॉर्मूला के लिए कोई TIO उपलब्ध नहीं)

Answer 25

क्लीन , 49 बाइट्स

import StdEnv
f l=and[(a+b)<>7\\(a,b)<-diag2 l l]

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

Comments

@StephenLeppik मुझे नहीं लगता कि यह उत्तर आवश्यक रूप से जानकारी संग्रहीत करने के लिए फ़ाइल नाम का उपयोग कर रहा है ।

— स्टेडीबॉक्स

@StephenLeppik ओह फेयर पॉइंट वहाँ, आयात की आवश्यकता है, लेकिन फ़ंक्शन को एक विशिष्ट मॉड्यूल में घोषित करने की आवश्यकता नहीं है। धन्यवाद।

— Οवस

Answer 26

स्विफ्ट , 46 बाइट्स

f(a:Int)->[Int]{!a.contains{a.contains(7-$0)}}

इनपुट [Int](पूर्णांक सरणी) के रूप में लेता है और एक Bool(बूलियन) देता है।

लघु व्याख्या (अपुष्ट)

f(a:Int)->[Int]{
    !a.contains (where: {n in    // The input doesn't have an element where
        a.contains(7 - n)        //    the opposite side is in the input
    })
}

Answer 27

क्लोजर , 89 80 72 बाइट्स

-9 बाइट्स क्योंकि मुझे एहसास हुआ कि उपयोग reducedअनावश्यक है

-8 बाइट्स का उपयोग करके उपयोग reduceकरने से बदलकरsome

#(if(< 0(count %)4)(not(some(fn[[a b]](=(+ a b)7))(for[a % b %][a b]))))

मैं किसी भी चाल अन्य जवाब का उपयोग कर के बिना यह लिखने की कोशिश की। मैं इस पर बाद में सुधार करने में सक्षम हो सकता हूं।

trueसही मामलों के लिए रिटर्न , falseयदि कोई पक्ष 7 के योग और nilयदि पक्षों की संख्या अवैध है।

---

(defn can-see? [dice-sides]
  ; Ensure its a valid length
  (if (< 0 (count dice-sides) 4)

    ; Then check if any of the permutations sum to 7
    (not (some (fn [[a b]]
                 (= (+ a b) 7))

               ; Generate all permutations
               (for [a dice-sides, b dice-sides] [a b])))))