Neredeyse altı yıl önce, PPCG üyesi steenslag , aşağıdaki mücadeleyi yayınladı :

Standart bir zarda (kalıp), sayılar, zıt yüzler yediye eklenecek şekilde düzenlenir. 9 rastgele ipucu izledikten sonra rastgele bir atım çıkaran tercih ettiğiniz dile mümkün olan en kısa programı yazın. Bir bahşiş zarın çeyrek turudur, örneğin zar 5'e dönükse, olası tüm bahşişler 1,3,4 ve 6'dır.

İstenilen çıktı örneği:

1532131356

Bu yüzden, herkes bunu tamamen unutmuş ve kazanılan cevap çoktan kabul edildiğinden bu yana, sunulan çözümler tarafından oluşturulan kalıp atma dizilerini onaylamak için bir program yazacağız. (Bu mantıklı. Sadece öyle davran.)

Meydan okuma

İşletme programı veya işlev gibi bir dizi verilir 1532131356. Ardışık her basamağın olduğunu doğrulayın:

• Önceki haneye eşit değil
• Önceki haneye 7 eksi değil

(İlk basamağı doğrulamanız gerekmez.)

kurallar

• Giriş geçerliyse ve bir falsey değeri varsa, programınız bir gerçeğe uygun değer döndürmelidir aksi takdirde .
• Girişin yalnızca 1-6 basamaktan oluştuğunu ve en az 1 karakter uzunluğunda olduğunu varsayabilirsiniz. Dizilerin steenslag mücadelesinde olduğu gibi sabit bir uzunluğu olmaz.
• Girdiyi bir dize ( "324324"), bir dizi veya dizi benzeri bir veri yapısı ( [1,3,5]) veya çoklu argümanlar ( yourFunction(1,2,4)) olarak alabilirsiniz.

_{Standart G / Ç ve kaçamak kuralları uygulanır.}

Test durumları

Truthy

1353531414
3132124215
4142124136
46
4264626313135414154
6
2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323
5414142

Falsey

• Tekrarlanan basamak

  11
  3132124225
  6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245
  553141454631
  14265411
  

• Kalıbın karşı tarafı

  16
  42123523545426464236231321
  61362462636351
  62362462636361
  

Python 2, 43 45 bayt

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

43 bayt (@Zgarb tarafından yoğun bir şekilde esinlenildi)

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

Bu işlev, indirgeme ifademi, her ikisinden de daha kısa bir birleşim için @ Zgarb'ın yanıtından bit titreyen mantıkla birleştirir.

Her iki cevap da aşağıdakileri verir:

• Giriş geçerli bir sıra değilse 0
• Geçerli ise, dizinin son basamağı

Python, 44 bayt

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

Bitsel sihir! Bu, tamsayıların listesini alan ve her iki ardışık öğenin XOR'unun 1 ila 6 arasında olduğunu kontrol eden adsız bir işlevdir.

Neden çalışıyor

Birincisi, XOR her zaman 0 ila 7 arasındadır, çünkü 7 111taban 2'dedir ve sayılarımız en fazla 3 ikili haneye sahiptir. Eşitlik için, a^b == 0eğer ve sadece ise a == b. Ayrıca, 7-a == 7^ane zaman 0 ≤ a ≤ 7ve dolayısıyla a^b == 7eğer ve sadece eğer a == 7^b == 7-b.

05AB1E , 11 9 bayt

Osable'ın akıllı bir ürün kullanma fikri için -2 bayt.

¥¹D7-Á+«P

Çevrimiçi deneyin!

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

05AB1E kullanan üçüncü yaklaşım, çift komutunu kullanmaz:

• 0 sarhoş özelliklerini ihlal ederse.
• Not 0 sarhoş olmasını engelleyen bir şey olmasaydı.

R, 39 37 32 31 bayt

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

Çevrimiçi deneyin!

Stdin'den girdi alır. diffArdışık iki hanenin aynı olup olmadığını görmek için kullanır ; daha sonra her rakamı bir önceki rakam olan 7 eksi ile karşılaştırır. İadeTRUEVeyaFALSE .

Jarko Dubbeldam ve bir de JayCe sayesinde 5 bayt kaydedildi.

05AB1E , 10 bayt

$ü+7ʹüÊ*P

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

R, 49 44 bayt

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

Stdin'den (boşlukla ayrılmış) girdiler ve çıktılar okur TRUE/FALSE. Girdi uzunluğu bir ise ama hala çalışıyorsa bir uyarı verecektir.

Düzenleme: @rturnbull sayesinde birkaç bayt kaydedildi

05AB1E , 15 bayt

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

Çevrimiçi deneyin! veya Test paketi olarak

JavaScript (ES6), 43 40 bayt

Döndürür 0/ true.

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

Test durumları

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 bayt

Bir regex kullanmak:

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

Girdiyi dizge olarak alır. Esinlenerek GB en Yakut cevap .
Nasıl çalışır:

• / /: Bir regex.
• (.): Herhangi bir karakteri eşleştir ve onu yakala $0.
• <{ }>: Dinamik olarak o konumda eşleştirilecek bir alt regex oluşturun.
• "$0|" ~ (7 - $0): Ürettiğimiz alt regex yalnızca önceki rakamlarla eşleşen veya önceki rakamın 7 eksi (örn. 5|2) Olanıdır .
  Bu nedenle, genel regex her yerde geçersiz bir ardışık basamak çifti bulursa, eşleşir.
• {! }: Bir boole zorla (regex'in eşleşmesine neden olacak şekilde $_), onu göz ardı et ve her şeyi bir lambdaya dönüştür (örtük parametreli $_).

Perl 6 , 38 bayt

Liste işlemeyi kullanma:

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

Girdiyi bir tamsayı dizisi olarak alır.
Nasıl çalışır:

• .[1..*] Z $_: Ardışık 2 basamaklı bir liste oluşturmak için giriş listesini, kendisinin ofset bir sürümüyle sıkıştırın.
• [!=] 7 - .[1], |$_: Bunların her biri için kontrol edin (7 - b) != a != b.
• all ( ): Tüm döngü yinelemelerinin Doğru olup olmadığına bağlı olarak bir gerçek veya sahte değer döndürün.

Python, 38 bayt

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

Gibi argümanlar alan özyinelemeli bir işlev f(1,2,3) .

Bu, ilk sayıyı hve geri kalanını demete çıkarmak için paket açma argümanını kullanır t. Eğer tboş, çıkış doğrudur. Aksi takdirde, ilk iki kalıp rulosunun uyumsuz olup olmadığını kontrol etmek için Zgarb'ın bit numarası kullanın. Ardından, sonucun kuyruktaki özyinelemeli çağrıda da tutulduğunu kontrol edin.

Ruby, 34 bayt

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

JavaScript 61 43 bayt

Yorumlar, use ifadesini kullanmadan C # linq işlevlerini kullanamayacağımı belirtti, bu yüzden burada standart JS kullanan daha az byte ile aynı ...

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

C #, 99 67 65 bayt

Bir int dizisi olarak girdi alır 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;}

Açıklama:

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

> <> (Balık) 47 bayt

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

Oldukça basit;

Satır 1: numara girilip girilmediğini kontrol edin, numara yoksa (EOF), başka kontroller basmak için bir gerçekimiz olur.

Satır 2: sonucu yazdırın.

Satır 3: girişi sayıya (ASCII 0 - girişten) çevirin, ardından önceki girişe eşit olup olmadığını kontrol edin.

Satır 4: girişin kalıbın karşı tarafında olup olmadığını kontrol edin.

Brain-Flak 128 Bayt

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

Falsey için 0, ya da truthy için -7 çıktılar.

Çevrimiçi Deneyin! (Truthy)
Çevrimiçi Deneyin! (Flasey)

Açıklama (t üstte ve s üstte ikinci sırada):

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

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

PHP, 63 bayt

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

girdiyi argüman listesi olarak alır; ile çıkışlar 1(hata) giriş, geçersizse 0(Tamam) geçerli ise.

İle koş -nr.

string argümanı olarak giriş, 65 bayt

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

PowerShell , 57 44 41 bayt

_{( 44'ü geçip hala normal 44 )}

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

Çevrimiçi deneyin!

(OP, bağımsız değişken olarak giriş almanın TAMAM olduğunu belirtti - 13 bayt kaydedildi ... ortadan kaldırarak başka bir 3 bayt kaydetti $b)

Her $argsseferinde giriş üzerinde bir basamak dolaşıyoruz . Her bir hane, bunu doğrulamak $last haneli -nyerine emevcut haneye Qual $_ve bu 7-$_-$l(truthy olan) sıfırdan başka bir sayıdır. Bu Boolean sonuçları parenler içinde kapsüllenir ve -notinkontrol edilerek operatörün sağ işlecine beslenir 0. Başka bir deyişle, Falsedöngünün herhangi bir yerinde herhangi bir değer varsa ,-notin olacaktır False. Bu Boolean boru hattında bırakıldı ve çıktı kapalı.

$Değişken isimleri gerekliliği ve Boolean komutlarının -ne -andPowerShell'de ayrıntılı olması nedeniyle uzun . Oh iyi.

İşlem, 93 92 90 bayt

Değişti || için | @ClaytonRamsey 1 bayt kaydedildi sayesinde:

Geri saymaya başladı: @IsmaelMiguel sayesinde 2 bayt kaydedildi

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

Girdiyi bir dizi dizisi olarak alır, çıktısını 1doğru veya0 yanlış olarak alır.

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 bayt

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

bir basamak hanesi alır (veya sonlandırılmış bir bayt dizisi)

açıklama

F(char*s){

standart intdönüş tipine göre ima edilir. (4 bayt kaydediliyor)

return koşulsuz geri dönüş, çünkü bu özyinelemeli bir işlevdir

kısayol değerlendirmesini kullanarak:

!s[1]||ikinci karakter nul ise true döndür

((*s^s[1])%7&& eğer ilk iki karakter yasal değilse

F(s+1)) dizinin geri kalanını aynı şekilde kontrol edin

kafa karıştırıcı ifade

*silk karakter s[1]ikinci

*s^s[1] hariç tutulursa - eğer aynıysalar, sonuç 7'ye eklenirse sonuç 0, sonuç 7 olur (eğer farklıysa ve 7'ye eklenmezse sonuç 1 ile 6 arasındadır)

bu nedenle (*s^s[1])%7hatalı giriş için sıfır, aksi halde sıfır değildir, bu nedenle bu 2 karakter hatalıysa yanlış, aksi takdirde doğru

Yorum: Bu işlev çağrısı yalnızca son özyinelemeyi kullandığı için (sadece son deyim özyinelemeli bir çağrıdır), bir iyimser özyinelemeyi bir döngüye çevirebilir; İstenen uzunlukta tellerin istifin bitmeden işlenmesini mümkün kılar.

Python, 71 bayt

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

Özyinelemeli bir yaklaşım kullanır.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Alternatif:

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

Çevrimiçi deneyin!

MATL , 9 bayt

dG2YCs7-h

Giriş, rakamları temsil eden bir sayılar dizisidir.

Çıktı tüm girişleri falsy aksi (daha falsy Matl en truthy için kriter ve hakkında okumak sıfır olmayan, ve eğer truthy olan boş olmayan bir dizidir burada ).

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

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 ile) 90 81 73 71 69 68 Bayt

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

Açıklama:

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

Input is an array of integers A with length L. Returns 1 for true and 0 for false. The input is checked from the end to the start using the input length L as the array index.

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