Gần sáu năm trước, thành viên PPCGag, thành viên PPCG đã đăng tải thử thách sau:

Trong một con xúc xắc tiêu chuẩn (chết), các con số được sắp xếp sao cho các mặt đối diện thêm vào bảy. Viết chương trình ngắn nhất có thể bằng ngôn ngữ ưa thích của bạn, kết quả là ném ngẫu nhiên theo sau là 9 lần rút ngẫu nhiên. Một lần lật là một phần tư của xúc xắc, ví dụ: nếu xúc xắc phải đối mặt với 5, tất cả các lần nhảy có thể là 1,3,4 và 6.

Ví dụ về đầu ra mong muốn:

1532131356

Vì vậy, bây giờ mọi người đã hoàn toàn quên nó và câu trả lời chiến thắng đã được chấp nhận từ lâu, chúng tôi sẽ viết một chương trình để xác nhận các chuỗi giới hạn được tạo ra bởi các giải pháp được gửi. (Điều này có ý nghĩa. Chỉ cần giả vờ như vậy.)

Thử thách

Chương trình hoặc chức năng của bạn được đưa ra một chuỗi như 1532131356. Xác thực rằng mỗi chữ số liên tiếp là:

• Không bằng chữ số trước
• Không bằng 7 trừ chữ số trước

(Bạn không phải xác nhận chữ số đầu tiên.)

Quy tắc

• Chương trình của bạn phải trả về giá trị trung thực nếu đầu vào hợp lệ và giá trị falsey khác.
• Bạn có thể giả sử rằng đầu vào chỉ bao gồm các chữ số 1-6 và dài ít nhất 1 ký tự. Các chuỗi sẽ không có độ dài cố định như trong thử thách của steenslag.
• Bạn có thể lấy đầu vào dưới dạng một chuỗi ( "324324"), một cơ sở dữ liệu giống như mảng hoặc mảng ( [1,3,5]) hoặc dưới dạng nhiều đối số ( yourFunction(1,2,4)).

_{Áp dụng quy tắc I / O và kẽ hở tiêu chuẩn .}

Các trường hợp thử nghiệm

Sự thật

1353531414
3132124215
4142124136
46
4264626313135414154
6
2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323
5414142

Falsey

• Chữ số lặp lại

  11
  3132124225
  6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245
  553141454631
  14265411
  

• Đối diện của cái chết

  16
  42123523545426464236231321
  61362462636351
  62362462636361
  

Python 2, 43 45 byte

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

43 byte (lấy cảm hứng rất nhiều từ @Zgarb)

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

Hàm này kết hợp câu lệnh rút gọn của tôi với logic nhấp nháy từ câu trả lời của @ Zgarb, cho một kết hợp ngắn hơn cả hai.

Cả hai câu trả lời đều cho ra kết quả như sau:

• 0 nếu đầu vào không phải là một chuỗi hợp lệ
• Chữ số cuối cùng của chuỗi nếu nó hợp lệ

Python, 44 byte

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

Phép thuật bitwise! Đây là một hàm ẩn danh lấy danh sách các số nguyên và kiểm tra xem XOR của mỗi hai phần tử liên tiếp nằm trong khoảng từ 1 đến 6.

Tại sao nó hoạt động

Đầu tiên, XOR luôn nằm trong khoảng từ 0 đến 7, vì 7 nằm 111trong cơ sở 2 và các số của chúng tôi có nhiều nhất là 3 chữ số nhị phân. Đối với sự bình đẳng, a^b == 0nếu và chỉ khi a == b. Ngoài ra, chúng ta có 7-a == 7^akhi 0 ≤ a ≤ 7, và do đó a^b == 7nếu và chỉ khi a == 7^b == 7-b.

05AB1E , 11 9 byte

-2 byte cho ý tưởng thông minh của Osable về việc sử dụng sản phẩm.

¥¹D7-Á+«P

Hãy thử trực tuyến!

¥           # 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.

Cách tiếp cận thứ ba bằng cách sử dụng 05AB1E, không sử dụng lệnh cặp đôi:

• 0 nếu nó vi phạm các thuộc tính mẹo.
• Not 0 nếu không có gì ngăn cản nó trở nên khó khăn.

R, 39 37 32 31 byte

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

Hãy thử trực tuyến!

Lấy đầu vào từ stdin. Sử dụng diffđể xem nếu bất kỳ hai chữ số liên tiếp là như nhau; sau đó so sánh mỗi chữ số với 7 trừ đi chữ số trước đó. Trả về TRUEhoặcFALSE .

Đã lưu 5 byte nhờ Jarko Dubbeldam và một lời cảm ơn khác cho JayCe.

05AB1E , 10 byte

$ü+7ʹüÊ*P

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

R, 49 44 byte

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

Đọc đầu vào từ stdin (cách nhau bởi khoảng trắng) và đầu ra TRUE/FALSE. Sẽ đưa ra cảnh báo nếu đầu vào có độ dài một nhưng vẫn hoạt động.

Chỉnh sửa: đã lưu một vài byte nhờ @rturnbull

05AB1E , 15 byte

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

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

JavaScript (ES6), 43 40 byte

Trả về 0/ true.

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

Các trường hợp thử nghiệm

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

Sử dụng biểu thức chính quy:

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

Lấy đầu vào là một chuỗi. Lấy cảm hứng từ câu trả lời Ruby của GB .
Làm thế nào nó hoạt động:

• / /: Một regex.
• (.): Phù hợp với bất kỳ nhân vật nào, và bắt nó là $0.
• <{ }>: Tự động tạo một biểu thức con được khớp ở vị trí đó.
• "$0|" ~ (7 - $0): Regex phụ chúng tôi tạo là một chỉ khớp với chữ số trước hoặc 7 trừ đi chữ số trước đó (ví dụ 5|2).
  Do đó, regex tổng thể sẽ khớp với iff, nó tìm thấy một cặp chữ số liên tiếp không hợp lệ ở bất cứ đâu.
• {! }: Ép buộc vào một boolean (làm cho regex được khớp với $_), phủ định nó và biến toàn bộ thành một lambda (với tham số ẩn $_).

Perl 6 , 38 byte

Sử dụng xử lý danh sách:

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

Lấy đầu vào là một mảng các số nguyên.
Làm thế nào nó hoạt động:

• .[1..*] Z $_: Zip danh sách đầu vào với phiên bản offset của chính nó, để tạo danh sách gồm 2 bộ chữ số liên tiếp.
• [!=] 7 - .[1], |$_: Đối với mỗi người, kiểm tra xem (7 - b) != a != b.
• all ( ): Trả về giá trị trung thực hoặc sai lệch tùy thuộc vào việc tất cả các lần lặp lại có trả về True hay không.

Python, 38 byte

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

Một hàm đệ quy có các đối số như thế nào f(1,2,3).

Điều này làm cho việc sử dụng giải nén đối số để trích xuất số đầu tiên hvà phần còn lại vào bộ dữ liệu t. Nếu ttrống, xuất True. Mặt khác, sử dụng mẹo bit của Zgarb để kiểm tra xem hai cuộn chết đầu tiên không tương thích. Sau đó, kiểm tra xem kết quả cũng giữ cuộc gọi đệ quy trên đuôi.

Ruby, 34 byte

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

JavaScript 61 43 byte

Các nhận xét đã đề cập Tôi không thể sử dụng các hàm linq C # mà không bao gồm câu lệnh sử dụng, vì vậy đây là chính xác trong ít byte hơn bằng cách sử dụng tiêu chuẩn ...

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

C #, 99 67 65 byte

Đưa đầu vào dưới dạng một mảng 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;}

Giải trình:

// 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)
}

> <> (Cá) 47 byte

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

Khá đơn giản;

Dòng 1: kiểm tra xem nếu nhập một số, nếu không có số (EOF) thì chúng tôi có một sự thật để in các kiểm tra khác.

Dòng 2: kết quả in.

Dòng 3: biến đầu vào thành số (ASCII 0 - từ đầu vào), sau đó kiểm tra xem nó có bằng đầu vào trước đó không.

Dòng 4: kiểm tra xem đầu vào có nằm đối diện với khuôn không.

Brain-Flak 128 byte

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

Kết quả 0 cho falsey, hoặc -7 cho sự thật.

Hãy thử trực tuyến! (Sự thật)
Hãy thử trực tuyến! (Flasey)

Giải thích (t là viết tắt của top và s là viết tắt của thứ hai từ trên xuống):

(())                # 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);

lấy đầu vào làm danh sách các đối số lệnh; thoát với 1(lỗi) nếu đầu vào không hợp lệ,0 (ok) nếu hợp lệ.

Chạy với -nr.

đầu vào dưới dạng đối số chuỗi, 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

_{( Vượt qua 44 vẫn là thường xuyên 44 )}

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

Hãy thử trực tuyến!

(OP đã làm rõ rằng lấy đầu vào làm đối số riêng biệt là OK - đã lưu 13 byte ... đã lưu thêm 3 byte bằng cách loại bỏ $b)

Chúng tôi đang lặp qua đầu vào $argsmột chữ số tại một thời điểm. Mỗi chữ số, chúng tôi xác minh rằng $lchữ số ast là -note qual đến chữ số hiện tại $_, và đó 7-$_-$llà một số số khác hơn không (đó là truthy). Các kết quả Boolean đó được gói gọn trong parens và đưa vào toán hạng bên phải của -notintoán tử, kiểm tra lại 0. Nói cách khác, nếu có bất kỳ Falsegiá trị nào ở bất kỳ đâu trong vòng lặp, -notinthì cũng sẽ có False. Boolean đó được để lại trên đường ống và đầu ra là ẩn.

Dài dòng vì $yêu cầu về tên biến và các lệnh Boolean đó-ne -and dài dòng trong PowerShell. Ồ tốt

Chế biến, 93 92 90 byte

Thay đổi || thành | : 1 byte được lưu nhờ @ClaytonRamsey

Bắt đầu đếm ngược: 2 byte được lưu nhờ @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;}

Lấy đầu vào là một mảng của ints, đầu ra 1 là true hoặc0 false.

Bị đánh cắp

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);}

lấy một chuỗi các chữ số (hoặc một mảng byte kết thúc bằng 0)

Giải trình

F(char*s){

theo intloại trả lại tiêu chuẩn được ngụ ý. (tiết kiệm 4 byte)

return lợi nhuận vô điều kiện vì đây là hàm đệ quy

sử dụng đánh giá phím tắt:

!s[1]||nếu nhân vật thứ hai là nul trở thành sự thật

((*s^s[1])%7&& nếu hai charcters đầu tiên không hợp pháp sai

F(s+1)) kiểm tra phần còn lại của chuỗi theo cùng một cách

biểu hiện khó hiểu đó

*s là nhân vật đầu tiên s[1] là thứ hai

*s^s[1] độc quyền kết hợp chúng với nhau nếu chúng giống nhau thì kết quả là 0 nếu chúng cộng vào 7 kết quả là 7, (nếu chúng khác nhau và không thêm vào 7 thì kết quả nằm trong khoảng từ 1 đến 6)

vì thế (*s^s[1])%7 bằng 0 đối với đầu vào xấu và khác không, do đó sai nếu 2 ký tự này là xấu và ngược lại là đúng

nhận xét: vì lệnh gọi hàm này chỉ sử dụng đệ quy kết thúc (chỉ câu lệnh cuối cùng là cuộc gọi đệ quy) một trình tối ưu hóa có thể dịch đệ quy thành một vòng lặp, đây là một kết luận vui vẻ và rõ ràng là không có giá trị bất kỳ điểm golf nào, nhưng trong từ thực làm cho nó có thể xử lý các chuỗi có độ dài bất kỳ mà không bị hết stack.

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

Sử dụng một cách tiếp cận đệ quy.

Giải trình:

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

Võng mạc , 28 byte

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

Hãy thử trực tuyến!

Cách khác:

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

Hãy thử trực tuyến!

MATL , 9 byte

dG2YCs7-h

Đầu vào là một dãy số đại diện cho các chữ số.

Đầu ra là một mảng không trống, điều này là sự thật nếu tất cả các mục nhập của nó là khác không và giả mạo (đọc thêm về tiêu chí của MATL về tính trung thực và giả mạo ở đây ).

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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 # (với Linq) 90 81 73 71 69 68 byte

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

Giải trình:

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, là 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;}

Đầu vào là một mảng các số nguyên A có độ dài L. Trả về 1 cho đúng và 0 cho sai. Đầu vào được kiểm tra từ đầu đến cuối bằng cách sử dụng độ dài đầu vào L làm chỉ số mảng.

Haskell, 37 byte

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

Ví dụ sử dụng: f [1,5,2]-> False.

Đệ quy đơn giản. Trường hợp cơ sở: danh sách phần tử đơn, trả về True. Trường hợp đệ quy: hãy avà blà hai phần tử đầu tiên của danh sách đầu vào và cphần còn lại. Tất cả các điều kiện sau đây phải giữ : a+b/=7, a/=bvà cuộc gọi đệ quy abị hủy.

JavaScript, 40 byte

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

Tận dụng lợi thế của tính năng JavaScript &&sẽ trả về giá trị cuối cùng được phân tích cú pháp (thuật ngữ giả mạo hoặc thuật ngữ cuối cùng). 0được thông qua nếu nó không đáp ứng các điều kiện và thuật ngữ trước đó được thông qua khác. Số 9 đảm bảo rằng nó bắt đầu bằng một giá trị trung thực.

Groovy, 61 byte

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

Python 2, 58 byte

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^

Hãy thử trực tuyến!

Mẻ, 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

Ung dung:

@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