Hampir enam tahun yang lalu, sesama anggota PPCG steenslag memposting tantangan berikut:

Dalam dadu standar (mati) angka-angkanya diatur sehingga wajah yang berlawanan menambah tujuh. Tuliskan program sesingkat mungkin dalam bahasa pilihan Anda yang menghasilkan lemparan acak diikuti oleh 9 tip acak. Tipping adalah seperempat putaran dadu, misalnya jika dadu menghadap ke 5, semua kemungkinan tip adalah 1,3,4 dan 6.

Contoh output yang diinginkan:

1532131356

Jadi, sekarang semua orang telah benar-benar lupa tentang hal itu dan jawaban yang menang telah lama diterima, kami akan menulis sebuah program untuk memvalidasi urutan die tipping yang dihasilkan oleh solusi yang dikirimkan. (Ini masuk akal. Pura-pura saja.)

Tantangan

Anda program atau fungsi yang diberikan berurutan seperti 1532131356. Validasi bahwa setiap digit berurutan adalah:

• Tidak sama dengan angka sebelumnya
• Tidak sama dengan 7 minus angka sebelumnya

(Anda tidak harus memvalidasi digit pertama.)

Aturan

• Program Anda harus mengembalikan nilai kebenaran jika inputnya valid dan nilai falsey sebaliknya.
• Anda dapat mengasumsikan bahwa input hanya terdiri dari digit 1-6 dan setidaknya sepanjang 1 karakter. Urutan tidak akan memiliki panjang yang tetap seperti di tantangan steenslag.
• Anda dapat mengambil input sebagai string ( "324324"), array atau struktur data array-seperti ( [1,3,5]) atau sebagai beberapa argumen ( yourFunction(1,2,4)).

_{Standar I / O dan aturan celah berlaku.}

Uji kasus

Sejujurnya

1353531414
3132124215
4142124136
46
4264626313135414154
6
2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323
5414142

Falsey

• Digit berulang

  11
  3132124225
  6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245
  553141454631
  14265411
  

• Menentang sisi kematian

  16
  42123523545426464236231321
  61362462636351
  62362462636361
  

Python 2, 43 45 byte

lambda s:reduce(lambda p,n:n*(7-p!=n!=p>0),s)

43 byte (sangat terinspirasi oleh @Zgarb)

lambda s:reduce(lambda p,n:n*(p>0<n^p<7),s)

Fungsi ini menggabungkan pernyataan pengurangan saya dengan logika bit-flicking dari jawaban @ Zgarb, untuk kombinasi yang lebih pendek dari keduanya.

Keduanya menjawab sebagai berikut:

• 0 jika input bukan urutan yang benar
• Digit terakhir dari urutan jika valid

Python, 44 byte

lambda x:all(0<a^b<7for a,b in zip(x,x[1:]))

Sihir bitwise! Ini adalah fungsi anonim yang mengambil daftar bilangan bulat, dan memeriksa bahwa XOR dari setiap dua elemen berturut-turut adalah antara 1 dan 6 inklusif.

Mengapa ini berhasil?

Pertama, XOR selalu antara 0 dan 7 inklusif, karena 7 berada 111di basis 2, dan angka kami memiliki paling banyak 3 digit biner. Untuk kesetaraan, a^b == 0jika dan hanya jika a == b. Juga, kita memiliki 7-a == 7^akapan 0 ≤ a ≤ 7, dan a^b == 7jika dan hanya jika a == 7^b == 7-b.

05AB1E , 11 9 byte

-2 byte untuk ide cerdas Osable menggunakan produk.

¥¹D7-Á+«P

Cobalah online!

¥           # Push deltas.
 ¹D7-Á      # Push original array, and 7 - [Array] shifted right once.
      +     # Add original to the 7 - [Array] shifted right.
       «    # Concat both.
        P   # Product, if either contain a zero, results in 0, meaning false.

Pendekatan ketiga menggunakan 05AB1E, itu tidak menggunakan perintah berpasangan:

• 0 jika itu melanggar properti mabuk.
• Not 0 jika tidak ada yang mencegahnya menjadi mabuk.

R, 39 37 32 31 byte

all(q<-diff(x<-scan()),2*x+q-7)

Cobalah online!

Mengambil input dari stdin. Digunakan diffuntuk melihat apakah ada dua digit berturut-turut yang sama; lalu bandingkan setiap digit hingga 7 minus angka sebelumnya. Pengembalian TRUEatau FALSE.

Disimpan 5 byte berkat Jarko Dubbeldam, dan terima kasih lain kepada JayCe.

05AB1E , 10 byte

$ü+7ʹüÊ*P

Menggunakan pengkodean CP-1252 . Cobalah online!

R, 49 44 byte

!any(rle(x<-scan())$l-1,ts(x)==7-lag(ts(x)))

Membaca input dari stdin (dipisahkan oleh spasi) dan output TRUE/FALSE. Akan memberikan peringatan jika inputnya panjang tetapi masih berfungsi.

Sunting: menyimpan beberapa byte berkat @rturnbull

05AB1E , 15 byte

ü+7å¹ü-0å¹g_~~_

Cobalah online! atau sebagai Test suite

JavaScript (ES6), 43 40 byte

Pengembalian 0/ true.

f=([k,...a],n=0)=>!k||k-n&&7-k-n&&f(a,k)

Uji kasus

f=([k,...a],n=0)=>!k||k-n&&7-k-n&&f(a,k)

console.log('Testing truthy cases ...');
console.log(f('1353531414'));
console.log(f('3132124215'));
console.log(f('4142124136'));
console.log(f('46'));
console.log(f('4264626313135414154'));
console.log(f('6'));
console.log(f('2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323'));
console.log(f('5414142'));

console.log('Testing falsy cases ...');
console.log(f('11'));
console.log(f('3132124225'));
console.log(f('6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245'));
console.log(f('553141454631'));
console.log(f('14265411'));
console.log(f('16'));
console.log(f('42123523545426464236231321'));
console.log(f('61362462636351'));
console.log(f('62362462636361'));

Perl 6 , 22 byte

Menggunakan regex:

{!/(.)<{"$0|"~7-$0}>/}

Mengambil input sebagai string. Terinspirasi oleh jawaban Ruby di GB .
Bagaimana itu bekerja:

• / /: Regex.
• (.): Cocokkan karakter apa saja, dan tangkap sebagai $0.
• <{ }>: Menghasilkan sub-regex secara dinamis untuk dicocokkan pada posisi itu.
• "$0|" ~ (7 - $0): Sub-regex yang kami hasilkan adalah yang hanya cocok dengan digit sebelumnya, atau 7 minus digit sebelumnya (mis 5|2.).
  Dengan demikian keseluruhan regex akan cocok jika menemukan pasangan berturut-turut yang tidak valid di mana saja.
• {! }: Paksa ke boolean (menyebabkan regex dicocokkan dengan $_), meniadakannya, dan mengubah semuanya menjadi lambda (dengan parameter implisit $_).

Perl 6 , 38 byte

Menggunakan pemrosesan daftar:

{all ([!=] 7-.[1],|$_ for .[1..*]Z$_)}

Mengambil input sebagai array bilangan bulat.
Bagaimana itu bekerja:

• .[1..*] Z $_: Rapatkan daftar input dengan versi offset-per-satu itu sendiri, untuk menghasilkan daftar 2-tupel digit berturut-turut.
• [!=] 7 - .[1], |$_: Untuk masing-masing, periksa apakah (7 - b) != a != b.
• all ( ): Mengembalikan nilai true atau falsy tergantung pada apakah semua iterasi loop dikembalikan Benar.

Python, 38 byte

f=lambda h,*t:t==()or 7>h^t[0]>0<f(*t)

Fungsi rekursif yang membutuhkan argumen seperti f(1,2,3).

Ini menggunakan argumen unpacking untuk mengekstrak angka pertama ke dalam hdan sisanya ke dalam tuple t. Jika tkosong, output True. Jika tidak, gunakan bit trick Zgarb untuk memeriksa apakah dua die rolls pertama tidak kompatibel. Kemudian, periksa bahwa hasilnya juga berlaku pada panggilan rekursif pada ekor.

Ruby, 34 byte

->s{!s[/[16]{2}|[25]{2}|[34]{2}/]}

JavaScript 61 43 byte

Komentar telah menyebutkan bahwa saya tidak dapat menggunakan fungsi C # linq tanpa menyertakan pernyataan menggunakan, jadi inilah yang persis sama dalam lebih sedikit byte menggunakan standar JS ...

f=a=>a.reduce((i,j)=>i>6|i==j|i+j==7?9:j)<7

C #, 99 67 65 byte

Mengambil input sebagai array int a

// new solution using linq
bool A(int[]a){return a.Aggregate((i,j)=>i>6|i==j|i+j==7?9:j)<7;}

// old solution using for loop
bool A(int[]a){for(int i=1;i<a.Length;)if(a[i]==a[i-1]|a[i-1]+a[i++]==7)return false;return true;}

Penjelasan:

// method that returns a boolean taking an integer array as a parameter
bool A(int[] a) 
{
    // aggregate loops over a collection, 
    // returning the output of the lambda 
    // as the first argument of the next iteration
    return a.Aggregate((i, j) => i > 6 // if the first arg (i) > than 6
    | i == j      // or i and j match
    | i + j == 7  // or i + j = 7
    ? 9   // return 9 as the output (and therefore the next i value)
    : j   // otherwise return j as the output (and therefore the next i value)
    ) 
    // if the output is ever set to 9 then it will be carried through to the end
    < 7; // return the output is less than 7 (not 9)
}

> <> (Ikan) 47 byte

0:i:1+?!v\!
   0n;n1< >
!?-{:-"0"/^
!? -{-$7:/^

Cukup mudah;

Baris 1: periksa untuk melihat apakah memasukkan nomor, jika tidak ada nomor (EOF) maka kita memiliki kebenaran untuk mencetak cek lain.

Baris 2: hasil cetak.

Baris 3: ubah input menjadi angka (ASCII 0 - dari input), lalu periksa apakah sama dengan input sebelumnya.

Baris 4: periksa apakah input berlawanan dengan die.

Brain-Flak 128 Bytes

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

Output 0 untuk falsey, atau -7 untuk truey.

Cobalah secara Online! (Truthy)
Cobalah Online! (Flasey)

Penjelasan (t adalah singkatan dari s dan singkatan dari kedua dari atas):

(())                # push a 1 to get this loop started
{{}                 # loop through all pairs, or until 2 are equal
(({}<>)<>[({})])    # pop t, push t on the other stack, and t - s on this one
}{}                 # end loop and pop one more time
([])                # push the height of the stack
{                   # if the height isn't 0 (there were equal numbers)...
{{}}<>              # pop everything from this stack and switch
}                   # end if
{{}                 # for every pair on the stack: pop the height and...
({}({})<>)<>        # push t + s on the other stack leaving s on this one
([][()])            # push the height - 1
}                   # end loop when there is only 1 number left
{}(<{}>)<>          # pop t, pop s, push 0 and switch stacks
(([]))              # push the height twice
{                   # loop through every pair
{}{}                # pop the height and what was t - 7
({}[(()()()){}()])  # push t - 7
{<>}<>              # if t is not 0 switch stacks and come come back
                    # if t is 0 (ie, there was a pair that added to 7) just switch once
([][()])            # push height - 1
}                   # end loop
({}{})              # push t + s (either 0 + 0 or 0 + -7)

MATLAB, 30 byte

@(a)all(diff(a)&movsum(a,2)-7)

PHP, 63 byte

for($d=$argv[$i=1];$c=$argv[++$i];$d=$c)$d-$c&&$d+$c-7?:die(1);

mengambil input sebagai daftar argumen perintah; keluar dengan 1(kesalahan) jika input tidak valid, 0(ok) jika valid.

Jalankan dengan -nr.

masukan sebagai argumen string, 65 byte

for($d=($s=$argv[1])[0];$c=$s[++$i];$d=$c)$d-$c&&$d+$c-7?:die(1);

PowerShell , 57 44 41 byte

_{( Coret 44 masih teratur 44 )}

0-notin($args|%{7-$_-$l-and$l-ne($l=$_)})

Cobalah online!

(OP telah mengklarifikasi bahwa mengambil input sebagai argumen terpisah adalah OK - disimpan 13 byte ... disimpan 3 byte lainnya dengan menghilangkan $b)

Kami mengulang-ulang input $argssatu digit pada satu waktu. Setiap digit, kami memverifikasi bahwa $last digit adalah -not equal ke angka saat $_, dan bahwa 7-$_-$lbeberapa nomor lain dari nol (yang truthy). Hasil-hasil Boolean tersebut dienkapsulasi dalam parens dan dimasukkan ke dalam operan tangan kanan -notinoperator, dengan memeriksanya 0. Dengan kata lain, jika ada Falsenilai di mana saja di loop, -notinitu juga akan menjadi False. Boolean itu ditinggalkan di jalur pipa, dan hasilnya tersirat.

Panjang karena $persyaratan untuk nama variabel, dan bahwa perintah Boolean -ne -andbertele-tele di PowerShell. Baiklah.

Memproses, 93 92 90 byte

Diubah || menjadi | : 1 byte disimpan berkat @ClaytonRamsey

Mulai menghitung mundur: 2 byte disimpan berkat @IsmaelMiguel

int b(int[]s){for(int i=s.length;--i>0;)if(s[i-1]==s[i]|s[i-1]==7-s[i])return 0;return 1;}

Mengambil input sebagai array int, output 1untuk true atau 0false.

Tidak disatukan

int Q104044(int[]s){
  for(int i=s.length;--i>0;)
    if(s[i-1]==s[i]|s[i-1]==7-s[i])
      return 0;
  return 1;
}

C 47 44 byte

F(char*s){return!s[1]||(*s^s[1])%7&&F(s+1);}

mengambil string angka (atau array byte yang diakhiri nol)

Penjelasan

F(char*s){

sesuai dengan inttipe pengembalian standar tersirat. (menghemat 4 byte)

return pengembalian tanpa syarat karena ini adalah fungsi rekursif

menggunakan evaluasi jalan pintas:

!s[1]||jika karakter kedua nul return true

((*s^s[1])%7&& jika dua karakter pertama tidak salah secara hukum

F(s+1)) periksa sisa string dengan cara yang sama

ekspresi yang membingungkan

*sadalah karakter pertama s[1]adalah yang kedua

*s^s[1] eksklusif-ors mereka bersama-sama jika mereka sama hasilnya adalah 0 jika mereka menambahkan ke 7 hasilnya adalah 7, (jika mereka berbeda dan tidak menambah ke 7 hasilnya adalah antara 1 dan 6 inklusif)

begitu (*s^s[1])%7juga nol untuk input buruk dan bukan-nol sebaliknya, jadi salah jika 2 karakter ini buruk, dan benar sebaliknya

komentar: karena pemanggilan fungsi ini hanya menggunakan rekursi akhir (hanya pernyataan terakhir adalah panggilan rekursif) pengoptimal dapat menerjemahkan rekursi ke dalam satu lingkaran, ini adalah perasaan senang yang bahagia dan jelas tidak sebanding dengan skor golf apa pun, tetapi dengan kata lain memungkinkan untuk memproses string dengan panjang berapa pun tanpa kehabisan tumpukan.

Python, 71 byte

f=lambda s:len(s)<2or(s[0]!=s[1]and int(s[0])!=7-int(s[1]))and f(s[1:])

Menggunakan pendekatan rekursif.

Penjelasan:

f=lambda s:                                                              # Define a function which takes an argument, s
           len(s)<2 or                                                   # Return True if s is just one character
                      (s[0]!=s[1]                                        # If the first two characters matches or...
                                 and int(s[0])!=7-int(s[1])              # the first character is 7 - the next character, then return False
                                                           )and f(s[1:]) # Else, recurse with s without the first character

Retina , 28 byte

M`(.)\1|16|25|34|43|52|61
^0

Cobalah online!

Kalau tidak:

M`[16]{2}|[25]{2}|[34]{2}
^0

Cobalah online!

MATL , 9 byte

dG2YCs7-h

Input adalah array angka yang mewakili digit.

Outputnya adalah array yang tidak kosong, yang benar jika semua entri-nya tidak nol, dan sebaliknya palsu (baca lebih lanjut tentang kriteria MATL untuk kebenaran dan kepalsuan di sini ).

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

d     % Take input implicitly. Consecutive differences
G     % Push input again
2YC   % Overlapping blocks of length 2, arranged as columns of a matrix
s     % Sum of each column
7-    % Subtract 7, element-wise
h     % Concatenate horizontally. Implicitly display

C # (dengan Linq) 90 81 73 71 69 68 Bytes

using System.Linq;n=>n.Aggregate((p,c)=>p<9|c==p|c==103-p?'\b':c)>9;

Penjelasan:

using System.Linq;           //Obligatory import
n=>n.Aggregate((p,c)=>       //p serves as both previous character in chain and error flag
    p<9                      //8 is the error flag, if true input is already invalid            
        |c==p            
            |c==103-p        //103 comes from 55(7) + 48(0)
                ?'\b'       //'\b' because it has a single digit code (8)
                    :c)      //valid so set previous character, this catches the first digit case as well
                        >8;  //as long as the output char is not a backspace input is valid

C, 81 byte, adalah 85 byte

int F(int *A,int L){int s=1;while(--L)s&=A[L]!=A[L-1]&A[L]!=(7-A[L-1]);return s;}

Input adalah array bilangan bulat A dengan panjang L. Mengembalikan 1 untuk true dan 0 untuk false. Input diperiksa dari ujung ke awal menggunakan panjang input L sebagai indeks array.

Haskell, 37 byte

f(a:b:c)=a+b/=7&&a/=b&&f(b:c)
f _=1<2

Contoh penggunaan: f [1,5,2] -> False.

Rekursi sederhana. Kasus dasar: daftar elemen tunggal, yang mengembalikan True. Kasing rekursif: biarkan adan bmenjadi dua elemen pertama dari daftar input dan csisanya. Semua kondisi berikut harus memegang: a+b/=7, a/=bdan panggilan rekursif dengan amenjatuhkan.

JavaScript, 40 byte

f=i=>i.reduce((a,b)=>a&&a-b&&a+b-7&&b,9)

Mengambil keuntungan dari fitur JavaScript yang &&akan mengembalikan nilai terakhir yang diuraikan (baik istilah palsu atau istilah terakhir). 0diteruskan jika tidak memenuhi persyaratan, dan istilah sebelumnya diteruskan sebaliknya. Angka 9 memastikan bahwa angka itu dimulai dengan nilai yang benar.

Groovy, 61 byte

{i=0;!(true in it.tail().collect{x->x in [7-it[i],it[i++]]})}

Python 2, 58 Bytes

lambda x:all(x[i]!=x[i+1]!=7-x[i]for i in range(len(x)-1))

> <> , 39 byte

0>i'0'-::&0)?v1n;>&!
?=0+=7+@=}:{:<;n0^

Cobalah online!

Batch, 102 byte

@set s=%1
@set/an=0%s:~0,2%,r=n%%9*(n%%7)
@if %r%==0 exit/b
@if %n% gtr 6 %0 %s:~1%
@echo 1

Tidak Disatukan:

@echo off
rem grab the input string
set s=%1
:loop
rem convert the first two digits as octal
set /a n = 0%s:~0,2%
rem check for divisibility by 9 (011...066)
set /a r = n %% 9
rem exit with no (falsy) output if no remainder
if %r% == 0 exit/b
rem check for divisibility by 7 (016...061)
set /a r = n %% 7
rem exit with no (falsy) output if no remainder
if %r% == 0 exit/b
rem remove first digit
set s=%s:~1%
rem loop back if there were at least two digits
if %n% gtr 6 goto loop
rem truthy output
echo 1