Vor fast sechs Jahren hat ein PPCG-Mitglied, steenslag , die folgende Herausforderung gestellt:

In einem Standardwürfel sind die Zahlen so angeordnet, dass sich gegenüberliegende Flächen zu sieben addieren. Schreiben Sie das kürzestmögliche Programm in Ihrer bevorzugten Sprache, das einen zufälligen Wurf gefolgt von 9 zufälligen Tipps ausgibt. Ein Tipp ist eine Vierteldrehung des Würfels. Wenn der Würfel z. B. auf 5 zeigt, sind alle möglichen Tipps 1,3,4 und 6.

Beispiel für die gewünschte Ausgabe:

1532131356

Jetzt, da alle das völlig vergessen haben und die siegreiche Antwort längst angenommen wurde, werden wir ein Programm schreiben, um die von den eingereichten Lösungen erzeugten Kippsequenzen zu validieren. (Das macht Sinn. Tu einfach so.)

Herausforderung

Ihr Programm oder Ihre Funktion erhält eine Sequenz wie 1532131356. Vergewissern Sie sich, dass jede aufeinanderfolgende Ziffer:

• Nicht gleich der vorherigen Ziffer
• Nicht gleich 7 minus der vorherigen Ziffer

(Sie müssen die erste Ziffer nicht validieren.)

Regeln

• Ihr Programm muss einen Wahrheitswert zurückgeben, wenn die Eingabe gültig ist, und andernfalls einen Falsey-Wert .
• Sie können davon ausgehen, dass die Eingabe nur aus den Ziffern 1-6 besteht und mindestens 1 Zeichen lang ist. Sequenzen haben keine feste Länge wie in der Herausforderung von steenslag.
• Sie können die Eingabe als Zeichenfolge ( "324324"), als Array oder Array-ähnliche Datenstruktur ( [1,3,5]) oder als mehrere Argumente ( yourFunction(1,2,4)) verwenden.

_{Standard I / O und Schlupfloch Regeln gelten.}

Testfälle

Wahrheit

1353531414
3132124215
4142124136
46
4264626313135414154
6
2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323
5414142

Falsey

• Wiederholte Ziffer

  11
  3132124225
  6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245
  553141454631
  14265411
  

• Gegenseite sterben

  16
  42123523545426464236231321
  61362462636351
  62362462636361
  

Python 2, 43 45 Bytes

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

43 Bytes (stark inspiriert von @Zgarb)

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

Diese Funktion kombiniert meine Reduce-Anweisung mit der Bit-Flicking-Logik aus @ Zgarbs Antwort für eine Kombination, die kürzer als beide ist.

Beide Antworten geben Folgendes aus:

• 0, wenn die Eingabe keine gültige Sequenz ist
• Die letzte Ziffer der Sequenz, wenn sie gültig ist

Python, 44 Bytes

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

Bitweise Magie! Dies ist eine anonyme Funktion, die eine Liste von Ganzzahlen aufnimmt und prüft, ob das XOR von jeweils zwei aufeinanderfolgenden Elementen zwischen 1 und 6 liegt.

Warum es funktioniert

Erstens ist das XOR immer zwischen 0 und 7 einschließlich, da 7 zur 111Basis 2 gehört und unsere Zahlen höchstens 3 Binärziffern haben. Für die Gleichheit, a^b == 0wenn und nur wenn a == b. Auch haben wir 7-a == 7^awann 0 ≤ a ≤ 7und damit a^b == 7wenn und nur wenn a == 7^b == 7-b.

05AB1E , 11 9 Bytes

-2 Byte für die clevere Idee von Osable, ein Produkt zu verwenden.

¥¹D7-Á+«P

Probieren Sie es 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.

Dritter Ansatz mit 05AB1E, bei dem der Befehl pairwise nicht verwendet wird:

• 0 wenn es die beschwipsten Eigenschaften verletzt.
• Not 0 wenn es nichts gab, das es daran hinderte, beschwipst zu sein.

R 39 37 32 31 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe von stdin. Prüft diff, ob zwei aufeinanderfolgende Ziffern identisch sind. vergleicht dann jede Ziffer mit 7 minus der vorherigen Ziffer. Rückgabe TRUEoder FALSE.

5 Bytes dank Jarko Dubbeldam und ein weiterer Dank an JayCe.

05AB1E , 10 Bytes

$ü+7ʹüÊ*P

Verwendet die CP-1252- Codierung. Probieren Sie es online!

R, 49 44 Bytes

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

Liest Eingaben von stdin (durch Leerzeichen getrennt) und Ausgaben TRUE/FALSE. Gibt eine Warnung aus, wenn die Eingabe die Länge 1 hat, aber noch funktioniert.

Bearbeiten: hat dank @rturnbull ein paar Bytes gespart

05AB1E , 15 Bytes

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

Probieren Sie es online! oder als Testsuite

JavaScript (ES6), 43 - 40 Byte

Rückgabe 0/ true.

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

Testfälle

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 Bytes

Regex verwenden:

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

Nimmt die Eingabe als String. Inspiriert von GBs Ruby-Antwort .
Wie es funktioniert:

• / /: Ein Regex.
• (.): Finde einen beliebigen Charakter und nimm ihn auf als $0.
• <{ }>: Erzeugt dynamisch eine Unter-Regex, die an dieser Position abgeglichen werden soll.
• "$0|" ~ (7 - $0): Der Sub-Regex, den wir generieren, stimmt nur mit der vorherigen Ziffer überein oder mit 7 minus der vorherigen Ziffer (z 5|2. B. ).
  Somit stimmt der gesamte reguläre Ausdruck überein, wenn er irgendwo ein ungültiges aufeinanderfolgendes Ziffernpaar findet.
• {! }: Erzwinge einen Booleschen Wert (wodurch die Regex mit dem Booleschen Wert verglichen wird $_ ), negiere ihn und verwandle das Ganze in ein Lambda (mit implizitem Parameter $_).

Perl 6 , 38 Bytes

Verwenden der Listenverarbeitung:

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

Nimmt die Eingabe als Array von Ganzzahlen.
Wie es funktioniert:

• .[1..*] Z $_: Zippen Sie die Eingabeliste mit einer um eins versetzten Version von sich selbst, um eine Liste mit 2 Tupeln aufeinanderfolgender Ziffern zu erstellen.
• [!=] 7 - .[1], |$_: Überprüfen Sie für jedes davon, ob (7 - b) != a != b .
• all ( ): Gibt einen Wahrheits- oder Falschwert zurück, abhängig davon, ob alle Schleifeniterationen True zurückgegeben haben.

Python, 38 Bytes

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

Eine rekursive Funktion, die Argumente wie annimmt f(1,2,3) .

Dies nutzt das Entpacken von Argumenten, um die erste Zahl hund den Rest in das Tupel zu extrahieren t. Wenn tleer, wird True ausgegeben. Verwenden Sie andernfalls den Bit-Trick von Zgarb, um zu überprüfen, ob die ersten beiden Würfelwürfe nicht inkompatibel sind. Überprüfen Sie dann, ob das Ergebnis auch für den rekursiven Aufruf am Ende gültig ist.

Ruby, 34 Bytes

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

JavaScript 61 43 Bytes

In den Kommentaren wurde erwähnt, dass ich C # -Linq-Funktionen nicht ohne die using-Anweisung verwenden kann. Daher ist hier das Gleiche in weniger Bytes unter Verwendung von Standard-JS ...

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

C #, 99 67 65 Bytes

Übernimmt die Eingabe als int-Array 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;}

Erläuterung:

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

> <> (Fisch) 47 Bytes

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

Ziemlich einfach;

Zeile 1: Überprüfen Sie, ob eine Zahl eingegeben wurde. Wenn keine Zahl (EOF) angegeben wurde, müssen wir die Wahrheit bestätigen, um die anderen Schecks auszudrucken.

Zeile 2: Druckergebnis.

Zeile 3: Wandle die Eingabe in eine Zahl um (ASCII 0 - von der Eingabe) und überprüfe dann, ob sie mit der vorherigen Eingabe übereinstimmt.

Zeile 4: Überprüfen Sie, ob sich der Eingang auf der gegenüberliegenden Seite des Chips befindet.

Brain-Flak 128 Bytes

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

Gibt 0 für Falsey oder -7 für Truthy aus.

Probieren Sie es online! (Wahrheit)
Probieren Sie es online! (Flasey)

Erklärung (t steht für top und s steht für second from the top):

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

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

PHP, 63 Bytes

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

Nimmt Eingaben als Liste von Befehlsargumenten entgegen; Beendet mit 1(Fehler), wenn die Eingabe ungültig ist, 0(OK), wenn sie gültig ist.

Laufen Sie mit -nr .

Eingabe als String-Argument, 65 Bytes

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

PowerShell , 57 44 41 Byte

_{( Durchgestrichen 44 ist immer noch regulär 44 )}

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

Probieren Sie es online!

(OP hat klargestellt, dass die Eingabe als separate Argumente in Ordnung ist - 13 Bytes gespart ... weitere 3 Bytes durch Eliminierung gespart $b )

Wir durchlaufen die Eingabe $argsziffernweise. Jede Ziffer, überprüfen wir , dass die $last Ziffer -not equal der aktuellen Ziffer $_, und das 7-$_-$list eine Zahl von Null (was truthy). Diese Booleschen Ergebnisse werden in Parens eingekapselt und unter Gegenprüfung in den rechten Operanden des -notinOperators eingespeist 0. Mit anderen Worten, wenn Falseirgendwo in der Schleife ein Wert vorhanden ist , -notinwird dies auch der Fall seinFalse . Dieser Boolesche Wert verbleibt in der Pipeline, und die Ausgabe ist implizit.

Langwierig, da $Variablennamen erforderlich sind und die Booleschen Befehle -ne -andin PowerShell ausführlich sind. Naja.

Verarbeitung, 93 92 90 Bytes

Geändert || zu | : 1 Byte gespeichert dank @ClaytonRamsey

Begonnen rückwärts zu zählen: 2 Bytes gespart dank @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;}

Nimmt die Eingabe als Array von Ints, die Ausgabe 1als true oder0 falsch aus.

Ungolfed

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 Bytes

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

Nimmt eine Folge von Ziffern (oder ein nullterminiertes Array von Bytes)

Erläuterung

F(char*s){

gemäß dem Standardrückgabetyp intwird impliziert. (4 Bytes sparen)

return Bedingungslose Rückgabe, da dies eine rekursive Funktion ist

Verwenden der Verknüpfungsauswertung:

!s[1]||Wenn das zweite Zeichen nul ist , wird true zurückgegeben

((*s^s[1])%7&& wenn die ersten beiden Zeichen nicht legal sind falsch

F(s+1)) Überprüfen Sie den Rest der Zeichenfolge auf die gleiche Weise

dieser verwirrende Ausdruck

*s ist das erste Zeichen s[1] ist das zweite

*s^s[1] Wenn sie gleich sind, ist das Ergebnis 0, wenn sie zu 7 addieren, ist das Ergebnis 7 (wenn sie sich unterscheiden und nicht zu 7 addieren, ist das Ergebnis zwischen 1 und 6 inklusive).

So (*s^s[1])%7ist Null für fehlerhafte Eingaben und andernfalls ungleich Null, also falsch, wenn diese beiden Zeichen fehlerhaft sind, und andernfalls wahr

Kommentar: Da dieser Funktionsaufruf nur End-Rekursion verwendet (nur die letzte Anweisung ist ein rekursiver Aufruf), könnte ein Optimierer die Rekursion in eine Schleife übersetzen ermöglicht die Verarbeitung beliebig langer Zeichenketten, ohne dass der Stapel ausgeht.

Python, 71 Bytes

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

Verwendet einen rekursiven Ansatz.

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Alternative:

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

Probieren Sie es online!

MATL , 9 Bytes

dG2YCs7-h

Die Eingabe ist ein Array von Zahlen, die die Ziffern darstellen.

Die Ausgabe ist ein nicht leeres Array, das wahr ist, wenn alle seine Einträge ungleich Null sind, und ansonsten falsch ist (lesen Sie mehr über das MATL-Kriterium für Wahr und Falsch hier ).

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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

Erläuterung:

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 Bytes, war 85 Bytes

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

Die Eingabe ist ein Array von Ganzzahlen A mit der Länge L. Gibt 1 für wahr und 0 für falsch zurück. Die Eingabe wird vom Ende bis zum Beginn mit der Eingabelänge L als Array-Index überprüft.

Haskell, 37 Bytes

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

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

Einfache Rekursion. Basisfall: Einzelelementliste, die zurückgibt True. Rekursive Fall: lassen aund bdie ersten beiden Elemente der Eingabeliste und werden cden Rest. Alle folgenden Bedingungen müssen erfüllt sein:a+b/=7 , a/=bund der rekursive Aufruf mit agesunken.

JavaScript, 40 Bytes

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

&&Nutzt die JavaScript-Funktion, die den letzten analysierten Wert zurückgibt (entweder den falschen oder den letzten Ausdruck). 0wird weitergereicht, wenn die Bedingungen nicht erfüllt sind, und der vorherige Begriff wird ansonsten weitergereicht. Die 9 stellt sicher, dass es mit einem Wahrheitswert beginnt.

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^

Probieren Sie es 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