거의 6 년 전에, 동료 PPCG 회원 steenslag 는 다음과 같은 도전을 게시 했습니다.

표준 주사위 (다이)에서 숫자는 반대쪽면이 7 개가되도록 배열됩니다. 원하는 언어로 가장 짧은 프로그램을 작성하여 무작위 던지기와 9 개의 무작위 팁을 출력하십시오. 팁핑은 주사위의 1/4 회전입니다. 예를 들어 주사위가 5를 향한 경우 가능한 모든 팁은 1,3,4 및 6입니다.

원하는 출력 예 :

1532131356

이제 모든 사람들이 그것에 대해 완전히 잊어 버렸고 당첨 된 답변이 오랫동안 받아 들여 졌으므로 제출 된 솔루션으로 생성 된 다이 팁 시퀀스를 검증하는 프로그램을 작성하게 될 것입니다. (이것은 말이됩니다. 그냥 척하십시오.)

도전

귀하의 프로그램이나 기능 과 같은 순서가 주어집니다 1532131356. 각 연속 숫자가 다음과 같은지 확인하십시오.

• 이전 자릿수와 같지 않습니다
• 7 에서 이전 숫자를 뺀 값 과 같지 않음

첫 번째 숫자를 확인할 필요는 없습니다.

규칙

• 입력이 유효하면 프로그램 은 정확한 값을, 그렇지 않으면 거짓 값을 반환해야합니다.
• 입력은 1-6의 숫자로만 구성되고 1 자 이상이라고 가정 할 수 있습니다. 시퀀스는 steenslag의 도전과 같이 고정 길이를 갖지 않습니다.
• 입력을 문자열 ( "324324"), 배열 또는 배열과 유사한 데이터 구조 ( [1,3,5]) 또는 여러 인수 ( yourFunction(1,2,4))로 사용할 수 있습니다.

_{표준 I / O 및 허점 규칙이 적용됩니다.}

테스트 사례

Truthy

1353531414
3132124215
4142124136
46
4264626313135414154
6
2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323
5414142

팔시

• 반복 자리

  11
  3132124225
  6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245
  553141454631
  14265411
  

• 다이의 반대쪽

  16
  42123523545426464236231321
  61362462636351
  62362462636361
  

파이썬 2, 43 45 바이트

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

43 바이트 (@Zgarb에서 많은 영감을 얻음)

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

이 함수는 내 Reduce 문과 @Zgarb의 답변에서 나오는 비트 깜박임 논리를 결합하여 둘 다보다 짧은 조합을 만듭니다.

두 답변 모두 다음을 출력합니다.

• 입력이 유효한 순서가 아닌 경우 0
• 유효한 경우 시퀀스의 마지막 숫자

파이썬, 44 바이트

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

비트 마법! 이것은 정수 목록을 취하는 익명 함수이며, 두 연속 요소마다 XOR이 1에서 6 사이인지 확인합니다.

작동하는 이유

첫째, XOR은 항상 0과 7 사이에 있습니다. 7은 111밑이 2이고 숫자는 최대 3 개의 이진수를 갖기 때문입니다. 평등의 a^b == 0경우 if 만 a == b. 또한 우리는 7-a == 7^awhen 0 ≤ a ≤ 7이므로 a^b == 7if 그리고 if if 만 a == 7^b == 7-b있습니다.

05AB1E , 11 9 바이트

제품 사용에 대한 Osable의 현명한 아이디어를 위해 -2 바이트.

¥¹D7-Á+«P

온라인으로 사용해보십시오!

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

pairwise 명령을 사용하지 않는 05AB1E를 사용하는 세 번째 방법 :

• 0 그것이 기운 속성을 위반하는 경우.
• Not 0 그것이 기운을 막는 것이 없다면.

R, 39 37 32 31 바이트

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

온라인으로 사용해보십시오!

stdin에서 입력을받습니다. diff두 개의 연속 숫자가 동일한 지 확인하는 데 사용 합니다. 그런 다음 각 숫자를 7에서 이전 숫자를 뺀 값과 비교합니다. 반환 TRUE또는 FALSE.

Jarko Dubbeldam 덕분에 5 바이트를 절약하고 JayCe 덕분에 5 바이트를 절약했습니다.

05AB1E , 10 바이트

$ü+7ʹüÊ*P

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

R, 49 44 바이트

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

stdin (공백으로 구분)에서 입력을 읽고 출력 TRUE/FALSE합니다. 입력 길이가 1이지만 여전히 작동하는 경우 경고를 표시합니다.

편집 : @rturnbull 덕분에 몇 바이트를 절약했습니다.

05AB1E , 15 바이트

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

온라인으로 사용해보십시오! 또는 테스트 스위트

자바 스크립트 (ES6), 43 40 바이트

0/를 반환 true합니다.

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

테스트 사례

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

펄 6 , 22 바이트

정규식 사용 :

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

입력을 문자열로 사용합니다. GB의 Ruby 답변에서 영감을 얻었습니다 .
작동 방식 :

• / /: 정규식.
• (.): 모든 문자를 일치시키고로 캡처하십시오 $0.
• <{ }>: 해당 위치에서 일치시킬 하위 정규식을 동적으로 생성합니다.
• "$0|" ~ (7 - $0): 우리가 생성하는 하위 정규 표현식은 이전 자리 만 일치하거나 이전 자리에서 7을 뺀 것과 일치합니다 (예 :) 5|2.
  따라서 전체 정규 표현식은 유효하지 않은 연속 숫자 쌍이 어디에서나 발견되면 일치합니다.
• {! }: 부울로 강제 변환하고 (정규 표현식과 일치하도록 $_) 무효화하고 모든 것을 람다로 변환합니다 (암시 적 매개 변수 사용 $_).

펄 6 , 38 바이트

목록 처리 사용 :

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

입력을 정수 배열로 가져옵니다.
작동 방식 :

• .[1..*] Z $_: 입력 목록을 한 세트 씩 오프셋 버전으로 압축하여 2 자리 연속 숫자 목록을 생성합니다.
• [!=] 7 - .[1], |$_: 각각에 대해 확인하십시오 (7 - b) != a != b.
• all ( ): 모든 루프 반복이 True를 반환했는지 여부에 따라 true 또는 false 값을 반환합니다.

파이썬, 38 바이트

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

같은 인수를 취하는 재귀 함수 f(1,2,3).

이것은 인수 unpacking을 사용하여 첫 번째 숫자를 추출 h하고 나머지는 터플 에 추출합니다 t. t비어 있으면 True를 출력하십시오. 그렇지 않으면 Zgarb의 비트 트릭 을 사용 하여 처음 두 다이 롤이 호환되지 않는지 확인하십시오. 그런 다음 결과가 꼬리의 재귀 호출에도 적용되는지 확인하십시오.

루비, 34 바이트

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

자바 스크립트 61 43 바이트

의견은 using 문을 포함하지 않고 C # linq 함수를 사용할 수 없다고 언급 했으므로 표준 JS를 사용하면 적은 바이트로 정확하게 동일합니다 ...

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

C #, 99 67 65 바이트

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

설명:

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

> <> (물고기) 47 바이트

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

꽤 간단합니다.

1 행 : 숫자가 입력되지 않았는지 확인하고, 숫자가 없으면 (EOF), 그렇지 않으면 인쇄 할 수 있습니다.

2 행 : 인쇄 결과.

3 행 : 입력을 숫자 (ASCII 0-입력에서)로 바꾸고 이전 입력과 같은지 확인합니다.

라인 4 : 입력이 다이의 반대쪽에 있는지 확인하십시오.

Brain-Flak 128 바이트

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

거짓이면 0을, 참이면 -7을 출력합니다.

온라인으로 사용해보십시오! (진실)
온라인으로 사용해보십시오! (플래시)

설명 (t는 top을 나타내고 s는 위에서부터 두 번째를 나타냄) :

(())                # 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 바이트

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

PHP, 63 바이트

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

명령 인수 목록으로 입력을받습니다. 1입력이 유효하지 않으면 (오류)로 종료되고 유효하면 0( 확인)으로 종료됩니다 .

로 실행하십시오 -nr.

문자열 인자로 입력, 65 바이트

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

PowerShell , 57 44 41 바이트

_{( 44로 넘어가는 것은 여전히 ​​규칙적이다 44 )}

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

온라인으로 사용해보십시오!

(OP는 별도의 인수로 입력하는 것이 OK-saved 13 bytes ... 제거하여 다른 3 바이트를 저장함을 분명히했습니다 $b)

우리는 $args한 번에 숫자를 입력을 반복합니다 . 각 디지트를, 우리는 확인 $lAST 자리가 -n구약 e현재 자리에 QUAL를 $_, 그것은 7-$_-$l(truthy 인) 제로 이외의 수이다. 이러한 부울 결과는 parens로 캡슐화되어 연산자의 오른쪽 피연산자로 공급되어 -notin에 대해 검사 0합니다. 즉, False루프의 어느 곳에 도 값 이 있으면-notin 또한있을 것입니다False . 해당 부울은 파이프 라인에 남아 있으며 출력은 암시 적입니다.

$변수 이름 이 필요 -ne -and하고 PowerShell에서 부울 명령 이 상세 하기 때문에 시간이 오래 걸립니다 . 오 잘

처리 중, 93 92 90 바이트

변경 || 에 | @ClaytonRamsey 1 바이트 저장 감사 :

거꾸로 세기 시작 : @IsmaelMiguel 덕분에 2 바이트 절약

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

입력을 정수 배열로 취하여 1true 또는 0false로 출력 합니다 .

언 골프

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

기음 47 44 바이트

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

자릿수 문자열 (또는 0으로 끝나는 바이트 배열)을 취합니다.

설명

F(char*s){

표준 int반환 유형 에 따라 내포됩니다. (4 바이트 절약)

return 재귀 함수이므로 무조건 리턴

바로 가기 평가 사용 :

!s[1]||두 번째 문자가 널 이면 true를 리턴합니다.

((*s^s[1])%7&& 처음 두 문자가 합법적이지 않은 경우

F(s+1)) 같은 방식으로 나머지 문자열을 확인하십시오.

그 혼란스러운 표현

*s첫 번째 문자 s[1]는 두 번째입니다

*s^s[1] 배타적이거나 함께 같다면 7에 더하면 결과는 0이고 결과는 7입니다 (만약 7에 더하지 않으면 결과는 1에서 6까지입니다)

그래서 (*s^s[1])%7제로 나쁜 입력 0이 아닌 그렇지 않으면, 따라서이 두 문자가 나쁜 경우는 false와 true, 그렇지 않은

주석 : 이 함수 호출은 재귀 종료 만 사용하므로 (마지막 문만 재귀 호출 임) 옵티마이 저는 재귀를 루프로 변환 할 수 있습니다. 스택을 다 사용하지 않고도 모든 길이의 문자열을 처리 할 수 ​​있습니다.

파이썬, 71 바이트

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

재귀 적 접근 방식을 사용합니다.

설명:

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

레티 나 , 28 바이트

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

온라인으로 사용해보십시오!

또는

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

온라인으로 사용해보십시오!

MATL , 9 바이트

dG2YCs7-h

입력은 숫자를 나타내는 숫자 배열입니다.

출력은 비어 있지 않은 배열이며, 모든 항목이 0이 아닌 경우에는 진실이며 그렇지 않은 경우에는 거짓입니다 ( 여기서 MATL의 진실성과 허위 기준에 대해 자세히 알아 보십시오 ).

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

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 # (Linq 포함) 90 81 73 71 69 68 바이트

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

설명:

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 바이트, 85 바이트

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

입력은 길이가 L 인 정수 A의 배열입니다. true의 경우 1을, false의 경우 0을 반환합니다. 입력 길이 L을 배열 인덱스로 사용하여 입력을 처음부터 끝까지 확인합니다.

Haskell, 37 bytes

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

Usage example: f [1,5,2] -> False.

Simple recursion. Base case: single element list, which returns True. Recursive case: let a and b be the first two elements of the input list and c the rest. All of the following conditions must hold: a+b/=7, a/=b and the recursive call with a dropped.

JavaScript, 40 bytes

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

Takes advantage of the JavaScript feature that && will return the last value that is parsed (either the falsy term or the last term). 0 is passed along if it doesn't meet the conditions, and the previous term is passed along otherwise. The 9 makes sure that it starts with a truthy value.

Groovy, 61 bytes

{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 bytes

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

Try it online!

Batch, 102 bytes

@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

Ungolfed:

@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