目に見えるサイコロの顔

21

伝統的な西洋ダイは 1〜6の整数が顔にマークされているキューブ、です。7に追加されるペアは、反対側の面に配置されます。

立方体であるため、常に1〜3面（両端を含む）¹面しか見ることができません。反対側の顔を同時に見ることはできません。

あなたの仕事は、ダイ上の辺を表す整数のリストを与えられて、これらの面を同時に見ることができるかどうかを決定するプログラムまたは関数を書くことです。

¹_{さて、多分あなたは一対の目で4つまたは5つの顔を見ることができますが、この挑戦の目的のために、私たちは一点からダイを観察します。}

ルール：

あなたの提出物は入力リストを仮定するかもしれません：
- 空ではありません。
- を満たす値のみが含まれます1 ≤ n ≤ 6。
- 重複する要素は含まれていません。
入力がソートされているとは思わないかもしれません。
あなたの提出物は、真実/偽の値を出力する必要があります：真実は、顔が同時に見ることができ、そうでなければ偽です。
これはcode-golfなので、最短の回答（バイト単位）が勝ちです！
デフォルトでは、標準の抜け穴は禁止されています。

テストケース

真実：

[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)

偽物：

[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)

code-golf decision-problem

— FlipTack
ソース

関連。

— FlipTack

3つより長いリストには反対の値が含まれるため、最後の2つの偽のケースは不要であるようです。

— ウェッカルE.

@WeckarEはい、明らかに-あなたが答えを見れば、彼らはすべてこれを活用しています。書くのは簡単な説明でした。

— FlipTack

@FlipTack実際には、長さをまったくチェックする必要はありません。3要素より長いリストには、少なくとも1組の反対側があります。

— エリックアウトゴルファー

1

ブラックホールのような重いもので光の波を曲げると、1つのポイントから最大5つの顔を見ることができます

— Ferrybig

回答:

15

Python 2、35バイト

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

オンラインでお試しください！

— チャス・ブラウン
ソース

5

Python 3では-1バイト。

— 17

14

JavaScript（ES6）、 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：（a、b、c）の順序は重要ではありません。それらは常にXORされているからです。

最も難しいケースは3番目のケースです。すべての可能な組み合わせを示す表は次のとおりです。

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

Alt。バージョン＃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]))

スニペットを展開

Alt。バージョン＃2、Chrome / Firefox、34バイト

これは、ChromeとFirefoxのソート方法を悪用します。Edgeでは機能しません。

入力を配列として受け取ります。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]))

スニペットを展開

— アーノールド
ソース

8

Haskell、24バイト

H.PWizのおかげで-3バイト。

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

— 完全に人間
ソース

5

APL（Dyalog）、7バイト

~7∊∘.+⍨

オンラインでお試しください！

∘.+⍨ -追加テーブル（すべての要素とすべての要素）

7∊ -7つ存在しますか？

~ -否定

APL（Dyalog）、7バイト

⍬≡⊢∩7-⊢

オンラインでお試しください！

7-⊢ -7から各要素を引きます

⊢∩ -元の配列と交差する

⍬≡ - 空の？

— ウリエル
ソース

5

R、27バイト

バグを修正してくれたGregorに感謝

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

オンラインでお試しください！

ポートオブチャスブラウンの回答。ベクトル化された操作を行うと、Rでこれを大幅に短縮できます。

— ジュゼッペ
ソース

あなたは周り(7-d)にいくつかの括弧が必要だと思う、そうでない場合d%in%dは優先されます。

— グレゴール

@Gregorあなたは絶対に正しい。

— ジュゼッペ

4

Mathematica、20バイト

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

あります\[Function]

Martin Enderから-12バイト
Misha Lavrovから-7バイト

オンラインでお試しください！

— J42161217
ソース

3

Haskell、26バイト

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

オンラインでお試しください！

— H.PWiz
ソース

3

Pyth、5バイト

!@-L7

ここで試してみてください。

— エリック・ザ・アウトゴルファー
ソース

私は2分前にこれを試してみました誓う可能性があり、それはうまくいきませんでした...何が悪かったのかえっ私の不思議

— 氏Xcoder

私が最初に考えたのは？サンドロット。

— maxathousand

3

実際には、8バイト

;∙♂Σ7@cY

オンラインでお試しください！（すべてのテストケースを実行します）

説明：

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

— メゴ
ソース

3

殻、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.

— マーティン・エンダー
ソース

3

網膜、21 20バイト

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

オンラインでお試しください！リンクにはテストケースが含まれます。編集：@MartinEnderのおかげで1バイト保存されました。説明：

O`.

入力を並べ替えます。

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

反対側のペア（3と4が隣り合っている）を確認します。無効なダイの場合は1、有効なダイの場合は0を返します。

結果を論理的に否定します。

— ニール
ソース

2

ゼリー、5バイト

7_f⁸Ṇ

オンラインでお試しください！

ポートオブチャスブラウンの回答。

説明

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

— エリック・ザ・アウトゴルファー
ソース

2

アリス、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.

— マーティン・エンダー
ソース

2

Pyth、5バイト

-7sM*

テストスイート。

isaacgが1バイト節約しました！

— Xcoder氏
ソース

2

ルビー、36 31 24 23バイト

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

オンラインでお試しください！

それはとても簡単だったので、間違った問題の解決策を常に探していました。

— GB
ソース

1

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バイトでこれを行ういくつかの方法の1つ

— エミグナ
ソース

1

Perl 5、51 + 1（`-a`）= 52バイト

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

オンラインでお試しください！

— Xcali
ソース

3 1 4真実を与える、どうでしょうsay 1>grep{$x=$_;grep$_+$x==7,@F}@F

— ナウエルフイユ

sedソリューションに触発された25 + 1（-p）

— ナウエルフイユ

1

網膜、20バイト

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

オンラインでお試しください！

ニールのアプローチの代替。

説明

T`_654`d

回し6、5、4へ1、2、3それぞれ。

M`(.).*\1

繰り返される文字を見つけて、一致した数を数えてみてください。

結果がゼロであることを確認してください（実質的に論理否定）。

— マーティン・エンダー
ソース

1

Java（OpenJDK 8）、43バイト

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

オンラインでお試しください！

— オリヴィエ・グレゴワール
ソース

1

GNU sed、37 22 + 1 = 23バイト

-rフラグ用に+1バイト。入力を数字として受け取ります。真実および偽の入力を出力します0。

@MartinEnderのおかげで-10バイト。

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

オンラインでお試しください！

説明

@MartinEnderのAlice answerに似ています。

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

— ヨルダン
ソース

正確に入力を印刷するのではなく、1-3を6-4に置き換えて入力を印刷します。

— アンドリューは、モニカを

1

Perl 6、18バイト

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

オンラインでお試しください！

1 & 6 | 2 & 5 | 3 & 41と6の数字、または2と5の数字、または3と4の数字で構成されるジャンクションです。このジャンクションは、1と6、または2と5、または3を含む場合∈、入力リストの要素です。*4.次に、その結果は否定（!）され、必要なブール値が取得されます。

— ショーン
ソース

0

Haskell、46 41 37バイト

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

リストとそれ自体のデカルト積を取得し、結果のリストの合計が7にならないかどうかをチェックします（合計が7になった場合、反対面が表示され、「すべてしない」は「ない」より短い何でも」。）

— ドラコニス
ソース

0

J、12バイト

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

これは、Urielによる最初のAPLソリューションとほとんど同じです。

オンラインでお試しください！

— ガレン・イワノフ
ソース

0

IBM / Lotus Notes式、7バイト

!7-i*=i

複数値の数値フィールドiから入力を取得します。

7からiの各値を再帰的に減算し、元のリストにあるかどうかを確認します。！0の場合は1を変更します（すべての顔を表示することはできません）。

テストケース（Notes Formulaで利用できるTIOはありません）

— エルペドロ
ソース

0

クリーン、49バイト

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

オンラインでお試しください！

— Ο々しい
ソース

1

@StephenLeppikこの答えは、情報を保存するために必ずしもファイル名を使用しているとは思わない。

— Steadybox

@StephenLeppikそうですね、インポートは必要ですが、特定のモジュールで関数を宣言する必要はありません。ありがとう。

— 17

0

Swift、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
    })
}

— ハーマンL
ソース

0

Clojure、89 80 72バイト

-9バイトの使用reducedは不要だとわかったため

使用から使用reduceに変更することにより、-8バイトsome

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

私は、他の回答が使用するトリックを見ずにこれを書いてみました。これについては後で改善できるかもしれません。

いずれかの辺の合計が7であり、辺の数が違法trueである場合、真の場合に戻ります。falsenil

(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])))))

— 発がん性
ソース

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。

Licensed under cc by-sa 3.0 with attribution required.