Quasi sei anni fa, Steenslag, membro del PPCG, ha pubblicato la seguente sfida:

In un dado standard (dado) i numeri sono disposti in modo tale che le facce opposte si sommino a sette. Scrivi il programma più breve possibile nella tua lingua preferita che genera un lancio casuale seguito da 9 suggerimenti casuali. Una mancia è un quarto di giro del dado, ad esempio se il dado è rivolto verso 5, tutti i possibili ribaltamenti sono 1,3,4 e 6.

Esempio di output desiderato:

1532131356

Quindi, ora che tutti se ne sono completamente dimenticati e la risposta vincente è stata accettata da tempo, scriveremo un programma per convalidare le sequenze di ribaltamento generate dalle soluzioni presentate. (Questo ha senso. Fingi di sì.)

Sfida

Al programma o alla funzione viene assegnata una sequenza come 1532131356. Convalida che ogni cifra consecutiva è:

• Non uguale alla cifra precedente
• Non uguale a 7 meno la cifra precedente

(Non è necessario convalidare la prima cifra.)

Regole

• Il programma deve restituire un valore di verità se l'input è valido e un valore di falsa in caso contrario.
• Si può presumere che l'input sia composto solo dalle cifre 1-6 e sia lungo almeno 1 carattere. Le sequenze non avranno una lunghezza fissa come nella sfida di steenslag.
• Puoi prendere l'input come stringa ( "324324"), una matrice o una struttura di dati simile a matrice ( [1,3,5]) o come argomenti multipli ( yourFunction(1,2,4)).

_{Si applicano le regole I / O standard e scappatoia .}

Casi test

Truthy

1353531414
3132124215
4142124136
46
4264626313135414154
6
2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323
5414142

Falsey

• Cifra ripetuta

  11
  3132124225
  6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245
  553141454631
  14265411
  

• Lato opposto del dado

  16
  42123523545426464236231321
  61362462636351
  62362462636361
  

Python 2, 43 45 byte

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

43 byte (fortemente ispirato a @Zgarb)

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

Questa funzione combina la mia dichiarazione di riduzione con la logica del bit-flicking dalla risposta di @ Zgarb, per una combinazione più breve di entrambe.

Entrambe le risposte generano quanto segue:

• 0 se l'ingresso non è una sequenza valida
• L'ultima cifra della sequenza se è valida

Python, 44 byte

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

Magia bit a bit! Questa è una funzione anonima che accetta un elenco di numeri interi e verifica che l'XOR di ogni due elementi consecutivi sia compreso tra 1 e 6 inclusi.

Perché funziona

Innanzitutto, XOR è sempre compreso tra 0 e 7, poiché 7 è 111nella base 2 e i nostri numeri hanno al massimo 3 cifre binarie. Per l'uguaglianza, a^b == 0se e solo se a == b. Inoltre, abbiamo 7-a == 7^aquando 0 ≤ a ≤ 7, e quindi a^b == 7se e solo se a == 7^b == 7-b.

05AB1E , 11 9 byte

-2 byte per l'idea intelligente di Osable di utilizzare un prodotto.

¥¹D7-Á+«P

Provalo 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.

Terzo approccio usando 05AB1E, che non usa il comando pairwise:

• 0 se viola le proprietà alticcio.
• Not 0 se non c'era nulla che gli impedisse di essere alticcio.

R, 39 37 32 31 byte

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

Provalo online!

Riceve input dallo stdin. Usa diffper vedere se due cifre consecutive sono uguali; quindi confronta ogni cifra a 7 meno la cifra precedente. Restituisce TRUEo FALSE.

Risparmiato 5 byte grazie a Jarko Dubbeldam e un altro grazie a JayCe.

05AB1E , 10 byte

$ü+7ʹüÊ*P

Utilizza la codifica CP-1252 . Provalo online!

R, 49 44 byte

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

Legge l'input dallo stdin (separato dallo spazio) e gli output TRUE/FALSE. Fornirà un avviso se l'ingresso è di lunghezza uno ma funziona ancora.

Modifica: salvato un paio di byte grazie a @rturnbull

05AB1E , 15 byte

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

Provalo online! o come una suite di test

JavaScript (ES6), 43 40 byte

Restituisce 0/ true.

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

Casi test

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

Usando un regex:

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

Prende l'input come stringa. Ispirato dalla risposta di Ruby di GB .
Come funziona:

• / /: Una regex.
• (.): Abbina qualsiasi personaggio e catturalo come $0.
• <{ }>: Genera dinamicamente un sotto-regex da abbinare in quella posizione.
• "$0|" ~ (7 - $0): Il sotto-regex che generiamo è uno che corrisponde solo alla cifra precedente, o 7 meno la cifra precedente (ad es 5|2.).
  Quindi la regex complessiva corrisponderà se trova ovunque una coppia di cifre consecutive non valida.
• {! }: Costringilo a un booleano (facendo corrispondere il regex $_), negalo e trasforma il tutto in un lambda (con parametro implicito $_).

Perl 6 , 38 byte

Utilizzando l'elaborazione dell'elenco:

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

Prende l'input come una matrice di numeri interi.
Come funziona:

• .[1..*] Z $_: Comprime l'elenco di input con una versione offset di uno di se stesso, per generare un elenco di 2 tuple di cifre consecutive.
• [!=] 7 - .[1], |$_: Per ognuno di questi, controlla se (7 - b) != a != b.
• all ( ): Restituisce un valore di verità o falsa a seconda che tutte le iterazioni di loop abbiano restituito True.

Python, 38 byte

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

Una funzione ricorsiva che accetta argomenti come f(1,2,3).

Questo fa uso dell'argomento unpacking per estrarre il primo numero he il resto nella tupla t. Se tè vuoto, genera True. Altrimenti, usa il piccolo trucco di Zgarb per verificare che i primi due tiri di dado non siano incompatibili. Quindi, controlla che il risultato valga anche per la chiamata ricorsiva sulla coda.

Rubino, 34 byte

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

JavaScript 61 43 byte

I commenti hanno menzionato che non posso usare le funzioni C # linq senza includere l'istruzione using, quindi ecco lo stesso in meno byte usando JS standard ...

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

C #, 99 67 65 byte

Accetta input come 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;}

Spiegazione:

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

> <> (Pesce) 47 byte

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

Abbastanza semplice;

Riga 1: controlla se è stato immesso un numero, se non c'è un numero (EOF), allora abbiamo una verità per stampare altri controlli.

Riga 2: risultato di stampa.

Riga 3: trasforma l'ingresso in numero (ASCII 0 - dall'ingresso), quindi controlla se è uguale all'input precedente.

Linea 4: verificare se l'ingresso è sul lato opposto della matrice.

Brain-Flak 128 byte

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

Emette 0 per falsey o -7 per verità.

Provalo online! (Sinceramente)
Provalo online! (Flasey)

Spiegazione (t sta per cima e s sta per seconda dalla cima):

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

accetta input come elenco di argomenti di comando; esce con 1(errore) se l'input non è valido, 0(ok) se valido.

Corri con -nr.

input come argomento stringa, 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

_{( Barrato 44 è ancora regolare 44 )}

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

Provalo online!

(OP ha chiarito che accettare input come argomenti separati è OK - salvato 13 byte ... salvato altri 3 byte eliminando $b)

Effettuiamo il ciclo dell'input $argsuna cifra alla volta. Ad ogni cifra, verifichiamo che la $lcifra ast sia -not equala alla cifra corrente $_e che 7-$_-$lsia un numero diverso da zero (che è vero). Questi risultati booleani sono incapsulati in parentesi e immessi nell'operando di destra -notindell'operatore, verificando il contrario 0. In altre parole, se c'è qualche Falsevalore in qualsiasi punto del loop, lo -notinsarà anche False. Quel booleano è rimasto sulla pipeline e l'output è implicito.

Lungo a causa del $requisito per i nomi delle variabili e che i comandi booleani -ne -andsono dettagliati in PowerShell. Oh bene.

Elaborazione, 93 92 90 byte

Modificato || in | : 1 byte salvato grazie a @ClaytonRamsey

Iniziato il conteggio all'indietro: 2 byte salvati grazie a @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;}

Accetta l'input come una matrice di ints, l'output 1per true o 0per false.

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 byte

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

accetta una stringa di cifre (o una matrice di byte con terminazione zero)

Spiegazione

F(char*s){

secondo il inttipo di ritorno standard è implicito. (salvataggio di 4 byte)

return ritorno incondizionato perché questa è una funzione ricorsiva

usando la valutazione scorciatoia:

!s[1]||se il secondo carattere è nullo, restituisce vero

((*s^s[1])%7&& se i primi due caratteri non sono falsi legali

F(s+1)) controlla il resto della stringa allo stesso modo

quell'espressione confusa

*sè il primo personaggio s[1]è il secondo

*s^s[1] li ordina in modo esclusivo se sono uguali il risultato è 0 se si sommano a 7 il risultato è 7, (se differiscono e non si aggiungono a 7 il risultato è compreso tra 1 e 6 inclusi)

così (*s^s[1])%7è zero per input errato e diverso da zero altrimenti, quindi falso se questi 2 caratteri sono errati e vero altrimenti

commento: poiché questa chiamata di funzione utilizza solo la ricorsione finale (solo l'ultima affermazione è una chiamata ricorsiva) un ottimizzatore potrebbe tradurre la ricorsione in un ciclo, questa è una felice coincidenza e ovviamente non vale alcun punteggio di golf, ma nella parola reale rende possibile elaborare stringhe di qualsiasi lunghezza senza esaurire lo 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:])

Utilizza un approccio ricorsivo.

Spiegazione:

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

Provalo online!

In alternativa:

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

Provalo online!

MATL , 9 byte

dG2YCs7-h

L'input è una matrice di numeri che rappresentano le cifre.

L'output è un array non vuoto, che è vero se tutte le sue voci sono diverse da zero, e falsa altrimenti (leggi di più sul criterio MATL per verità e falsità qui ).

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

Spiegazione:

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

L'input è un array di numeri interi A con lunghezza L. Restituisce 1 per true e 0 per false. L'input viene verificato dall'inizio alla fine utilizzando la lunghezza di input L come indice dell'array.

Haskell, 37 byte

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

Esempio di utilizzo: f [1,5,2]-> False.

Ricorsione semplice. Caso di base: elenco di elementi singoli, che restituisce True. Caso ricorsivo: lascia ache bsiano i primi due elementi dell'elenco di input e cil resto. Tutte le seguenti condizioni devono contenere: a+b/=7, a/=be la chiamata ricorsiva con acaduto.

JavaScript, 40 byte

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

Sfrutta la funzionalità JavaScript che && restituirà l'ultimo valore analizzato (il termine falsy o l'ultimo termine). 0viene passato se non soddisfa le condizioni e il termine precedente viene passato diversamente. Il 9 si assicura che inizi con un valore veritiero.

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^

Provalo online!

Lotto, 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

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