Prawie sześć lat temu kolega PPCG, steenslag, opublikował następujące wyzwanie:

W standardowych kościach (kostkach) liczby są ułożone w taki sposób, że przeciwne twarze dodają siedem. Napisz najkrótszy możliwy program w preferowanym języku, który generuje losowy rzut, po którym następuje 9 losowych napiwków. Przechylenie to ćwierć obrotu kostki, np. Jeśli kostka jest skierowana w stronę 5, wszystkie możliwe przechylenia to 1,3,4 i 6.

Przykład pożądanej wydajności:

1532131356

Tak więc teraz, gdy wszyscy całkowicie o tym zapomnieli, a zwycięska odpowiedź już dawno została zaakceptowana, będziemy pisać program do sprawdzania sekwencji przechylania matryc generowanych przez przesłane rozwiązania. (To ma sens. Udawaj, że tak.)

Wyzwanie

Twój program lub funkcja ma taką sekwencję jak 1532131356. Sprawdź, czy każda kolejna cyfra to:

• Nie równa poprzedniej cyfrze
• Nie równa 7 minus poprzednia cyfra

(Nie musisz sprawdzać poprawności pierwszej cyfry.)

Zasady

• Twój program musi zwrócić wartość prawdy, jeśli dane wejściowe są poprawne, a w przeciwnym razie wartość falsey .
• Możesz założyć, że dane wejściowe składają się tylko z cyfr 1-6 i mają co najmniej 1 znak. Sekwencje nie będą miały ustalonej długości jak w wyzwaniu steenslag.
• Dane wejściowe można traktować jako string ( "324324"), tablicę lub podobną do tablicy strukturę danych ( [1,3,5]) lub jako wiele argumentów ( yourFunction(1,2,4)).

_{Obowiązują standardowe zasady we / wy i luki .}

Przypadki testowe

Prawda

1353531414
3132124215
4142124136
46
4264626313135414154
6
2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323
5414142

Falsey

• Powtarzana cyfra

  11
  3132124225
  6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245
  553141454631
  14265411
  

• Przeciwna strona umiera

  16
  42123523545426464236231321
  61362462636351
  62362462636361
  

Python 2, 43 45 bajtów

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

43 bajty (inspirowane głównie przez @Zgarb)

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

Ta funkcja łączy moją instrukcję redukującą z logiką przestawiania bitów z odpowiedzi @ Zgarb, dla kombinacji krótszej niż obie.

Obie odpowiedzi dają następujące wyniki:

• 0, jeśli dane wejściowe nie są prawidłową sekwencją
• Ostatnia cyfra sekwencji, jeśli jest poprawna

Python, 44 bajty

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

Bitowa magia! Jest to anonimowa funkcja, która pobiera listę liczb całkowitych i sprawdza, czy XOR każdego z dwóch kolejnych elementów zawiera się między 1 a 6 włącznie.

Dlaczego to działa?

Po pierwsze, XOR ma zawsze wartość od 0 do 7 włącznie, ponieważ 7 jest 111w bazie 2, a nasze liczby mają najwyżej 3 cyfry binarne. Dla równości, a^b == 0jeśli i tylko jeśli a == b. Ponadto mamy 7-a == 7^akiedy 0 ≤ a ≤ 7, a więc a^b == 7wtedy i tylko wtedy a == 7^b == 7-b.

05AB1E , 11 9 bajtów

-2 bajty dla inteligentnego pomysłu Osable na użycie produktu.

¥¹D7-Á+«P

Wypróbuj 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.

Trzecie podejście z użyciem 05AB1E, które nie korzysta z polecenia parowania:

• 0 jeśli narusza podpowiedziowe właściwości.
• Not 0 jeśli nie było nic, co mogłoby przeszkadzać.

R, 39 37 32 31 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe ze standardowego wejścia. Używa, diffaby sprawdzić, czy dwie kolejne cyfry są takie same; następnie porównuje każdą cyfrę z 7 minus poprzednia cyfra. Zwraca TRUElub FALSE.

Zaoszczędź 5 bajtów dzięki Jarko Dubbeldam i kolejne dzięki JayCe.

05AB1E , 10 bajtów

$ü+7ʹüÊ*P

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

R, 49 44 bajtów

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

Odczytuje dane wejściowe ze standardowego wejścia (oddzielone spacją) i dane wyjściowe TRUE/FALSE. Daje ostrzeżenie, jeśli dane wejściowe mają długość 1, ale nadal działają.

Edycja: zapisano kilka bajtów dzięki @rturnbull

05AB1E , 15 bajtów

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

Wypróbuj online! lub jako pakiet testowy

JavaScript (ES6), 43 40 bajtów

Zwraca 0/ true.

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

Przypadki testowe

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 bajtów

Za pomocą wyrażenia regularnego:

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

Pobiera dane wejściowe jako ciąg. Zainspirowany odpowiedzią Ruby GB .
Jak to działa:

• / /: Wyrażenie regularne.
• (.): Dopasuj dowolną postać i złap ją jako $0.
• <{ }>: Dynamicznie generuj podwyrażenie regularne, które ma zostać dopasowane w tej pozycji.
• "$0|" ~ (7 - $0): Wygenerowane przez nas wyrażenie podrzędne jest takie, które pasuje tylko do poprzedniej cyfry lub 7 minus poprzednia cyfra (np 5|2.).
  Tak więc ogólna regex będzie pasować, jeśli znajdzie gdziekolwiek niepoprawną kolejną parę cyfr.
• {! }: Zmusza do wartości logicznej (powodującej dopasowanie wyrażenia regularnego $_), neguje ją i zamienia całość w lambda (z niejawnym parametrem $_).

Perl 6 , 38 bajtów

Korzystanie z przetwarzania listy:

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

Pobiera dane wejściowe jako tablicę liczb całkowitych.
Jak to działa:

• .[1..*] Z $_: Spakuj listę wejściową samą wersją z przesunięciem o jeden, aby wygenerować listę 2-krotek kolejnych cyfr.
• [!=] 7 - .[1], |$_: Dla każdego z nich sprawdź, czy (7 - b) != a != b.
• all ( ): Zwraca wartość prawdy lub fałszu w zależności od tego, czy wszystkie iteracje pętli zwróciły wartość Prawda.

Python, 38 bajtów

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

Funkcja rekurencyjna, która przyjmuje takie argumenty f(1,2,3).

Wykorzystuje to rozpakowywanie argumentów, aby wyodrębnić pierwszą liczbę, ha resztę do krotki t. Jeśli tjest pusty, wyślij True. W przeciwnym razie użyj sztuczki Zgarba, aby sprawdzić, czy pierwsze dwa rzuty nie są niezgodne. Następnie sprawdź, czy wynik utrzymuje się również na rekurencyjnym wywołaniu na ogonie.

Rubinowy, 34 bajty

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

JavaScript 61 43 bajty

Komentarze wspominają, że nie mogę używać funkcji linq w języku C # bez dołączenia instrukcji using, więc oto dokładnie to samo w mniejszej liczbie bajtów przy użyciu standardowego JS ...

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

C #, 99 67 65 bajtów

Pobiera dane wejściowe jako tablicę 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;}

Wyjaśnienie:

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

> <> (Fish) 47 bajtów

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

Dość proste;

Wiersz 1: sprawdź, czy wprowadzono liczbę, jeśli nie ma liczby (EOF), mamy prawdę, aby wydrukować inne czeki.

Wiersz 2: wydrukuj wynik.

Wiersz 3: zamień wejście na liczbę (ASCII 0 - z wejścia), a następnie sprawdź, czy jest równe poprzedniemu wprowadzeniu.

Wiersz 4: sprawdź, czy wejście jest po przeciwnej stronie matrycy.

Brain-Flak 128 bajtów

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

Wyjście 0 dla falsey lub -7 dla prawdy.

Wypróbuj online! (Prawda)
Wypróbuj online! (Flasey)

Objaśnienie (t oznacza górę, a s oznacza drugą od góry):

(())                # 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 bajtów

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

PHP, 63 bajty

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

przyjmuje dane wejściowe jako listę argumentów poleceń; wychodzi z 1(błąd), jeśli dane wejściowe są nieprawidłowe, 0(ok), jeśli są prawidłowe.

Uruchom z -nr.

Wprowadź jako argument ciągu, 65 bajtów

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

PowerShell , 57 44 41 bajtów

_{( Przekreślone 44 jest nadal regularne 44 )}

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

Wypróbuj online!

(OP wyjaśnił, że przyjmowanie danych wejściowych jako osobnych argumentów jest w porządku - zapisano 13 bajtów ... zapisano kolejne 3 bajty, eliminując $b)

Za każdym razem zapętlamy $argscyfrę. Każda cyfra, stwierdzamy, że $lcyfra ast jest -not equal do bieżącej cyfry $_i że 7-$_-$ljest jakiś inny numer niż zero (co jest truthy). Te logiczne wyniki są kapsułkowane w pareny i podawane do operandu po prawej stronie -notinoperatora, sprawdzając względem 0. Innymi słowy, jeśli Falsew pętli jest jakakolwiek wartość, -notinto również będzie False. To, że wartość logiczna jest pozostawiana w potoku, a dane wyjściowe są niejawne.

Długie ze względu na $wymaganie dotyczące nazw zmiennych oraz to, że komendy boolowskie -ne -andsą pełne w programie PowerShell. No cóż.

Przetwarzanie, 93 92 90 bajtów

Zmieniono || na | : 1 bajt zapisany dzięki @ClaytonRamsey

Rozpoczęto odliczanie do tyłu: 2 bajty zapisane dzięki @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;}

Pobiera dane wejściowe jako tablicę liczb całkowitych, dane wyjściowe 1dla wartości true lub 0false.

Bez golfa

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

do 47 44 bajty

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

pobiera ciąg cyfr (lub tablicę bajtów zakończoną zerami)

Wyjaśnienie

F(char*s){

zgodnie ze standardowym introdzajem zwrotu. (oszczędność 4 bajtów)

return bezwarunkowy powrót, ponieważ jest to funkcja rekurencyjna

za pomocą oceny skrótów:

!s[1]||jeśli drugi znak ma wartość nul, zwraca true

((*s^s[1])%7&& jeśli pierwsze dwa znaki nie są zgodne z prawem, fałszywe

F(s+1)) sprawdź resztę ciągu w ten sam sposób

ten mylący wyraz

*sjest pierwszą postacią s[1]jest drugą

*s^s[1] exclusive-ors je razem, jeśli są takie same, wynik wynosi 0, jeśli dodają do 7, wynik wynosi 7, (jeśli się różnią i nie dodają do 7, wynik wynosi od 1 do 6 włącznie)

więc (*s^s[1])%7zero dla złych danych wejściowych i niezerowe w przeciwnym razie, więc false, jeśli te 2 znaki są złe, a prawda w przeciwnym razie

komentarz: ponieważ to wywołanie funkcji wykorzystuje tylko rekurencję końcową (tylko ostatnia instrukcja jest wywołaniem rekurencyjnym), optymalizator może przetłumaczyć rekurencję w pętlę, jest to szczęśliwy conicidence i oczywiście nie jest wart żadnej oceny golfa, ale tak naprawdę umożliwia przetwarzanie ciągów o dowolnej długości bez wyczerpania stosu.

Python, 71 bajtów

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

Stosuje podejście rekurencyjne.

Wyjaśnienie:

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

Siatkówka , 28 bajtów

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

Wypróbuj online!

Alternatywnie:

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

Wypróbuj online!

MATL , 9 bajtów

dG2YCs7-h

Dane wejściowe to tablica liczb reprezentujących cyfry.

Dane wyjściowe to niepusta tablica, która jest prawdziwa, jeśli wszystkie jej wpisy są niezerowe, a fałsz jest inny (czytaj więcej o kryterium MATL dla prawdy i fałszu tutaj ).

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

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 # (z Linq) 90 81 73 71 69 68 bajtów

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

Wyjaśnienie:

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 bajtów, miał 85 bajtów

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

Dane wejściowe to tablica liczb całkowitych A o długości L. Zwraca 1 dla wartości true i 0 dla wartości false. Dane wejściowe są sprawdzane od końca do początku, używając długości wejściowej L jako indeksu tablicy.

Haskell, 37 bajtów

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

Przykład użycia: f [1,5,2]-> False.

Prosta rekurencja. Przypadek podstawowy: lista pojedynczych elementów, która zwraca True. Rekurencyjne sprawa: niech ai bbyć dwa pierwsze elementy listy wejściowej i creszta. Wszystkie poniższe warunki muszą posiadać: a+b/=7, a/=ba wywołanie rekurencyjne z aspadły.

JavaScript, 40 bajtów

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

Korzysta z funkcji JavaScript, &&która zwraca ostatnią analizowaną wartość (albo falsy, albo ostatni termin). 0jest przekazywany, jeśli nie spełnia warunków, a poprzedni termin jest przekazywany w inny sposób. 9 gwarantuje, że zaczyna się od prawdziwej wartości.

Groovy, 61 bajtów

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

Python 2, 58 bajtów

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

> <> , 39 bajtów

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

Wypróbuj online!

Partia, 102 bajty

@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

Nie golfowany:

@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