लगभग छह साल पहले, PPCG के सदस्य स्टेन्सलैग ने निम्नलिखित चुनौती पोस्ट की:

एक मानक पासा (मरो) में संख्याओं को व्यवस्थित किया जाता है ताकि विपरीत चेहरे सात में जुड़ जाएं। अपनी पसंदीदा भाषा में सबसे कम संभव प्रोग्राम लिखें जो एक यादृच्छिक थ्रो का अनुसरण करता है और उसके बाद 9 यादृच्छिक टिपिंग। टिपिंग पासा का एक चौथाई मोड़ है, उदाहरण के लिए यदि पासा 5 का सामना कर रहा है, तो सभी संभावित टिपिंग 1,3,4 और 6 हैं।

वांछित उत्पादन का उदाहरण:

1532131356

तो, अब जब हर कोई इसके बारे में पूरी तरह से भूल गया है और जीतने का जवाब लंबे समय से स्वीकार किया गया है, तो हम प्रस्तुत समाधान द्वारा उत्पन्न डाई टिपिंग अनुक्रमों को मान्य करने के लिए एक कार्यक्रम लिखेंगे। (यह समझ में आता है। बस यह दिखावा करता है।)

चुनौती

आपके प्रोग्राम या फंक्शन को एक सीक्वेंस दिया जाता है जैसे कि 1532131356। पुष्टि करें कि प्रत्येक लगातार अंक है:

पिछले अंक के बराबर नहीं
पिछले अंक के 7 शून्य के बराबर नहीं

(आपको पहले अंक को मान्य नहीं करना है।)

नियम

यदि इनपुट मान्य है और अन्यथा गलत मूल्य है तो आपके प्रोग्राम को एक सत्य मान वापस करना होगा ।
आप मान सकते हैं कि इनपुट में केवल अंक 1-6 हैं और कम से कम 1 वर्ण लंबा है। सीक्वेंसलैग की चुनौती में दृश्यों की निश्चित लंबाई नहीं होगी।
आप इनपुट को एक स्ट्रिंग ( "324324"), एक सरणी या सरणी-जैसे डेटास्ट्रक्चर ( [1,3,5]) या कई तर्कों ( yourFunction(1,2,4)) के रूप में ले सकते हैं।

_{मानक I / O और लूपहोले नियम लागू होते हैं।}

परीक्षण के मामलों

Truthy

1353531414
3132124215
4142124136
46
4264626313135414154
6
2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323
5414142

Falsey

बार-बार अंक

11
3132124225
6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245
553141454631
14265411

मरने का विरोध

16
42123523545426464236231321
61362462636351
62362462636361

code-golf sequence decision-problem

— user2428118
स्रोत

14

पायथन 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)

यह फ़ंक्शन @ ज़गरब के उत्तर से बिट-फ़्लकिंग तर्क के साथ मेरे कम बयान को जोड़ती है, दोनों के लिए संयोजन से।

दोनों जवाब निम्नलिखित उत्पादन:

0 यदि इनपुट वैध अनुक्रम नहीं है
यदि यह वैध है तो अनुक्रम का अंतिम अंक

— notjagan
स्रोत

4

PPCG में आपका स्वागत है, यह वास्तव में अच्छा पहला उत्तर है।

— गेहूं जादूगर

1

यह लगभग आधे झूठे मामलों के लिए काम नहीं करता है। जैसे 3132124225लौटता है 5।

— जेक कॉब

आप इसका उपयोग करके ठीक कर सकते हैं n and p*(7-p!=n!=p)।

— जेक कॉब

@JakeCobb यह अब सभी परीक्षण मामलों के साथ काम करना चाहिए। दुर्भाग्य से यह अब 2 बाइट्स लंबा है :(

— notjagan

कम करने का एक चतुर उपयोग, अगले चरण में प्रत्येक मूल्य को पास करना।

— xnor

9

पायथन, 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यदि और केवल यदि a == b। इसके अलावा, हमारे पास 7-a == 7^aकब 0 ≤ a ≤ 7, और इस प्रकार a^b == 7यदि और केवल यदि है a == 7^b == 7-b।

— Zgarb
स्रोत

7

05AB1E , 11 9 बाइट्स

एक उत्पाद का उपयोग करने के ओसेबल के स्मार्ट विचार के लिए -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.

तीसरा दृष्टिकोण 05AB1E का उपयोग करते हुए, जो युग्मक कमांड का उपयोग नहीं करता है:

0 यदि यह युक्तियों के गुणों का उल्लंघन करता है।
Not 0 अगर वहाँ कुछ भी नहीं था यह युक्तियों से रोका जा रहा है।

— जादू ऑक्टोपस Urn
स्रोत

1

@Emigna को नहीं लगा कि यह मायने रखता है लेकिन तय है!

— मैजिक ऑक्टोपस Urn

1

मैं डेल्टास के साथ एक उत्तर पोस्ट करना चाहता था, लेकिन मैंने इसके बारे में नहीं सोचा था Á। अच्छा!

— 18

1

आप सत्य / मिथ्या मूल्यों की परिभाषा का उपयोग करके 2 बाइट बचा सकते हैं ¥¹D7-Á+«P। यह 0 देता है जब सरणी में 0 या किसी अन्य मान में अन्यथा है।

— Osable

1

@ योग्य SMAART! मेगा स्मार्ट मैन, अच्छी नौकरी।

— मैजिक ऑक्टोपस Urn

6

आर, 39 37 32 31 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्टड से इनपुट लेता है। उपयोगdiffयह देखने के लिए है कि क्या कोई लगातार दो अंक समान हैं; फिर प्रत्येक अंक की तुलना 7 अंकों के पिछले अंक से करता है। लौटाता है TRUEया FALSE।

जार्को डबेलडैम के लिए 5 बाइट्स को बचाया, और जेसीई को एक और धन्यवाद।

— rturnbull
स्रोत

कुछ चर को सहेजने के बजाय कुछ चर में अंतर को सहेजना qऔर फिर परीक्षण 2*x+q-7करना c(0,x)!=c(7-x,0)। अगर है x1 + x2 = 7तो 2*x1 + diff(x1,x2) = 7। जाँच हो रही है 2*x+q - 7तो स्पष्ट रूप से परीक्षण !=0।

— JAD

@JarkoDubbeldam महान अवलोकन, धन्यवाद! मैंने समाधान अपडेट कर दिया है।

— rturnbull

1 बाइट बचाओ

— JayCe

@JayCe धन्यवाद, मैंने अब जवाब अपडेट कर दिया है।

— rturnbull

5

05AB1E , 10 बाइट्स

$ü+7Ê¹üÊ*P

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

1

अर्घ!, मैंने ऐसा क्यों नहीं सोचा Ê: पी नाइस!

— एमिग्ना

हम्म, तो 1*[] = []लेकिन product(1, []) = 1। यह जानकर अच्छा लगा।

— इमिग्ना

@Eigna वास्तव में, यह एक बग है। का उत्पाद []1. होना चाहिए

— अदनान

हाँ, मैंने चाहा है कि यह पहले की तरह कई बार काम करे। संचालन के आदेश भी यहां मायने रखते हैं। )1*, )1s*और )1Pसभी हैं []जबकि )1sP1. है

— एमिग्ना

1

@Emigna आह, ऐसा इसलिए है क्योंकि उत्पाद []एक त्रुटि देता है और खारिज कर दिया जाता है। इसलिए यह 1. देता है। जब मैं घर पहुंचता हूं तो इसे ठीक करने की कोशिश करता हूं।

— अदनान

5

आर, 49 44 बाइट्स

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

स्टड (स्पेस से अलग) और आउटपुट से इनपुट पढ़ता है TRUE/FALSE । यदि इनपुट एक की लंबाई का है, लेकिन फिर भी काम करता है, तो चेतावनी देगा।

संपादित करें: @rturnbull को धन्यवाद बाइट्स के एक जोड़े को बचाया

— Billywob
स्रोत

आप गठबंधन कर सकते हैं all(x)&all(y) में all(x,y)कुछ बाइट्स को बचाने के लिए। तुम भी बदल सकते हैं rle(x)$l==1करने के लिए rle(x)$l-1है, जो तब सभी का एक सेट वापस आ जाएगी FALSE, तो xवैध है; फिर बाद में स्विच !=एक करने के लिए ==और allकरने के लिए !any। यह पैदावार !any(rle(x<-scan())$l-1,ts(x)==7-lag(ts(x))), कुल 5 बाइट्स की बचत करता है । (पीएस, मैंने एक वैकल्पिक समाधान लिखा है जिसमें आपकी रुचि हो सकती है।)

— rturnbull

4

05AB1E , 15 बाइट्स

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

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

— Emigna
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 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'));

Expand snippet

— Arnauld
स्रोत

अफसोस की बात है कि रेटिना उत्तर का सरल बंदरगाह केवल 38 बाइट्स है।

— नील

@Neil मुझे लगता है कि यह वास्तव में 37 के साथ हैtest()

— Arnauld

क्षमा करें, मैंने गलती से बाइट काउंटर में एक नई लाइन चिपका दी थी।

— नील

4

पर्ल 6 , 22 बाइट्स

रेगेक्स का उपयोग करना:

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

इनपुट को एक स्ट्रिंग के रूप में लेता है। जीबी के रूबी जवाब से प्रेरित है ।
यह काम किस प्रकार करता है:

/ /: एक रेगेक्स।
(.): किसी भी चरित्र से मेल खाते हैं, और इसे कैप्चर करें $0 ।
<{ }>: डायनामिकली उस स्थिति में मिलान करने के लिए एक सब-रेगेक्स उत्पन्न करते हैं।
"$0|" ~ (7 - $0): हम जो उप-रेगेक्स उत्पन्न करते हैं, वह केवल पिछले अंक या 7 अंकों के पिछले अंक (जैसे 5|2) से मेल खाता है ।
इस प्रकार समग्र regex iff से मेल खाएगा, यह कहीं भी अंकों की एक अमान्य लगातार जोड़ी पाता है।
{! }: एक बूलियन के साथ सहसंबंधी होना (रेगेक्स के खिलाफ मिलान किया जाना $_), इसे नकारना, और पूरी चीज को एक लंबोदर (अंतर्निहित पैरामीटर के साथ $_) में बदल दें।

पर्ल 6 , 38 बाइट्स

सूची प्रसंस्करण का उपयोग करना:

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

इनपुट को पूर्णांक के एक सरणी के रूप में लेता है।
यह काम किस प्रकार करता है:

.[1..*] Z $_: लगातार सूची के 2-टुपल्स की सूची उत्पन्न करने के लिए, एक ऑफसेट-बाय-वन संस्करण के साथ इनपुट सूची को ज़िप करें।
[!=] 7 - .[1], |$_: उनमें से प्रत्येक के लिए, जांचें कि क्या (7 - b) != a != b।
all ( ): सभी लूप पुनरावृत्तियों सही है या नहीं इस पर निर्भर करते हुए एक सत्य या मिथ्या मूल्य लौटाएं।

— SMLS
स्रोत

4

पायथन, 38 बाइट्स

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

एक पुनरावर्ती कार्य जो तर्क की तरह लेता है f(1,2,3)।

यह पहले नंबर को hऔर बाकी को टपल में निकालने के लिए तर्क अनपैकिंग का उपयोग करता है t। यदि tरिक्त है, तो आउटपुट सही है। अन्यथा, यह जांचने के लिए ज़गरब की बिट चाल का उपयोग करें कि पहले दो डाई रोल असंगत नहीं हैं। फिर, जांच लें कि परिणाम पूंछ पर पुनरावर्ती कॉल पर भी है।

— XNOR
स्रोत

4

रूबी, 34 बाइट्स

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

— जीबी
स्रोत

2

आप #[]इसके बजाय स्ट्रिंग विधि का उपयोग करके दो बाइट्स दाढ़ी कर सकते हैं :->s{!s[/[16]{2}|[25]{2}|[34]{2}/]}

— एलेक्सिस एंडरसन

मुझे नहीं पता था कि आप इसे रेगेक्स के साथ उपयोग कर सकते हैं, धन्यवाद।

— जीबी

4

जावास्क्रिप्ट 61 43 बाइट्स

टिप्पणियों में उल्लेख किया गया है कि मैं सी # लाइनक फ़ंक्शंस का उपयोग किए बिना स्टेटमेंट का उपयोग नहीं कर सकता, इसलिए यहां मानक जेएस का उपयोग करके कम बाइट्स में सटीक है ...

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

सी #, 99 67 65 बाइट्स

एक अंतर सरणी के रूप में इनपुट लेता है 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)
}

— Erresen
स्रोत

मुझे लगता है कि यह जरूरत है एक समारोह में लिपटे हो सकता है, या हो सकता है एक लैम्ब्डा (करता है सी # उन है?) इसके अलावा, आप कुछ बाइट्स वापस लौट कर बचत हो सकती है 0या 1बजाय falseयाtrue

— DJMcMayhem

ओह, ठीक है - कोड गोल्फ पर पहली पोस्ट। मैं संपादित करता हूँ ...

— Erresen

कोई बात नहीं। BTW, साइट में आपका स्वागत है! :)

— DJMcMayhem

@DJMcMayhem मुझे ठीक करें अगर मैं गलत हूं, लेकिन चूंकि आउटपुट आवश्यकता सत्य / गलत है, तो आउटपुट विकल्प भाषा निर्भर tl हैं; डॉ 1 c सच नहीं हैं / c में गंदी / झूठी

— जस्टिन -

@Phaeze आप सही कह रहे हैं कि वे सत्यवादी / गलत नहीं हैं, लेकिन मानक IO नियम meta.codegolf.stackexchange.com/questions/2447/… reckon आप एक्जिट कोड का उपयोग करके आउटपुट कर सकते हैं और यह कार्य उसी तरह से आउटपुट कर सकते हैं कार्यक्रम। यदि आवश्यक हो तो मैं वापस बुलियन में बदल

— जाऊंगा

3

> <> (मछली) 47 बाइट्स

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

बहुत साधारण;

पंक्ति 1: यह देखने के लिए जांचें कि क्या कोई संख्या इनपुट की गई है, यदि कोई संख्या (ईओएफ) नहीं है तो हमारे पास एक और चेक प्रिंट करने के लिए एक सत्य है।

पंक्ति 2: प्रिंट परिणाम।

पंक्ति 3: इनपुट को संख्या में बदल दें (ASCII 0 - इनपुट से), फिर जांचें कि क्या यह पिछले इनपुट के बराबर है।

पंक्ति 4: जांचें कि क्या इनपुट मरने के विपरीत है।

— पेल पेलिकन
स्रोत

3

ब्रेन-फ्लैक 128 बाइट्स

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

फाल्सी के लिए आउटपुट 0, या सत्य के लिए -7।

इसे ऑनलाइन आज़माएं! (ट्रू)
इसे ऑनलाइन आज़माएं!(Flasey)

स्पष्टीकरण (टी शीर्ष के लिए है और एस शीर्ष से दूसरे के लिए खड़ा है):

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

— रिले
स्रोत

3

MATLAB, 30 बाइट्स

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

— rahnema1
स्रोत

3

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

— टाइटस
स्रोत

3

पॉवरशेल , 57 44 41 बाइट्स

_{( पार किया 44 अभी भी नियमित है 44 )}

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

इसे ऑनलाइन आज़माएं!

(ओपी ने स्पष्ट किया है कि अलग-अलग तर्कों के रूप में इनपुट लेना ठीक है - 13 बाइट्स बचाए गए ... एक और 3 बाइट्स को नष्ट करके बचाया $b )

We're looping through the input $args a digit at a time. Each digit, we verify that the $last digit is -notequal to the current digit $_, and that 7-$_-$l is some number other than zero (which is truthy). Those Boolean results are encapsulated in parens and fed into the right-hand operand of the -notin operator, checking against 0. In other words, if there is any False value anywhere in the loop, the -notin will also be False. That Boolean is left on the pipeline, and output is implicit.

Lengthy because of the $ requirement for variable names, and that Boolean commands -ne -and are verbose in PowerShell. Oh well.

— AdmBorkBork
स्रोत

3

Processing, 93 92 90 bytes

Changed || to | : 1 byte saved thanks to @ClaytonRamsey

Started counting backwards: 2 bytes saved thanks to @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;}

Takes input as an array of ints, output 1 for true or 0 for 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;
}

— Kritixi Lithos
स्रोत

Usually Java allows | instead of || if you want to save a byte.

— Clayton Ramsey

@ClaytonRamsey I don't know why I didn't think of it, thanks!

— Kritixi Lithos

I found another one. You could cut down on the use of returns with the tertiary operator

— Clayton Ramsey

@ClaytonRamsey The return 0 is inside the if-statement while return 1 is not. I don't see how that is possible unless you have some other idea

— Kritixi Lithos

2

Golfed it! Yipee! (nobody's going to read these summaries so why not have fun :) <-- I read it, while comparing what you have with what you had.

— Ismael Miguel

3

C 47 44 bytes

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

takes a string of digits (or a zero terminated array of bytes)

Explanation

F(char*s){

according to the standard int return type is implied. (saving 4 bytes)

return unconditional return because this is a recursive function

using shortcut evaluation:

!s[1]|| if the second character is nul return true

((*s^s[1])%7&& if the first two charcters aren't legal false

F(s+1)) check the rest of the string in the same way

that confusing expression

*s is the first character s[1] is the second

*s^s[1] exclusive-ors them together if they are the same the result is 0 if they add to 7 the result is 7 , (if they differ and don't add to 7 the result is between 1 and 6 inclusive)

so (*s^s[1])%7 is zero for bad input and non-zero otherwise, thus false if these 2 characters are bad, and true otherwise

comment: as this function call uses only end-recursion (only the last statement is a recursive call) an optimiser could translate the recursion into a loop, this is a happy conicidence and is obviously not worth any golf score, but in the real word makes it possible to process strings of any length without running out of stack.

— Jasen
स्रोत

1

About your !((*s^s[1])%7) I think you don't want the !. Zero values for bad input would be falsy, so you want to return the falsy when it's bad.

— nmjcman101

2

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:])

Uses a recursive approach.

Explanation:

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

— Loovjo
स्रोत

say that the input is a list of ints, and then you don't need the casts.

— Jasen

2

Retina, 28 bytes

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

Try it online!

Alternatively:

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

Try it online!

— Martin Ender
स्रोत

2

MATL, 9 bytes

dG2YCs7-h

The input is an array of numbers representing the digits.

The output is a non-empty array, which is truthy if all its entries are non-zero, and falsy otherwise (read more about MATL's criterion for truthy and falsy here).

Try it online! Or verify all test cases.

Explanation

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

— Luis Mendo
स्रोत

Is it possible/intended to add some new MATLAB functions to MATL?

— rahnema1

@rahnema1 Yes, there are some function names currently unused. However, I tend to be selective and add only those that I think will be used often. If you have any proposals we can discuss them in the MATL chatroom :-)

— Luis Mendo

@rahnema1 If you are thinking of movsum, there's already conv2 (which includes conv); see Y+ and Z+

— Luis Mendo

2

C# (with 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;

Explanation:

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

— JustinM - Reinstate Monica
स्रोत

2

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.

— user230118
स्रोत

int is optional at the start, you can save 4 bytes.

— Jasen

int s=1; can be declared outside the function as s=1; for another 4.

— nmjcman101

2

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.

— nimi
स्रोत

2

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.

— JackW
स्रोत

1

Groovy, 61 bytes

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

— Magic Octopus Urn
स्रोत

1

Python 2, 58 Bytes

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

— Noodle9
स्रोत

1

><>, 39 bytes

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

Try it online!

— Emigna
स्रोत

1

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

— Neil
स्रोत

वैध रैंडम डाई टिपर्स

चुनौती

नियम

परीक्षण के मामलों

Truthy

Falsey

पायथन 2, 43 45 बाइट्स

43 बाइट्स (@Zgarb से काफी प्रेरित)

पायथन, 44 बाइट्स

यह काम क्यों करता है

05AB1E , 11 9 बाइट्स

आर, 39 37 32 31 बाइट्स

05AB1E , 10 बाइट्स

आर, 49 44 बाइट्स

05AB1E , 15 बाइट्स

जावास्क्रिप्ट (ईएस 6), 43 40 बाइट्स

परीक्षण के मामलों

पर्ल 6 , 22 बाइट्स

पर्ल 6 , 38 बाइट्स

पायथन, 38 बाइट्स

रूबी, 34 बाइट्स

जावास्क्रिप्ट 61 43 बाइट्स

सी #, 99 67 65 बाइट्स

> <> (मछली) 47 बाइट्स

ब्रेन-फ्लैक 128 बाइट्स

MATLAB, 30 बाइट्स

PHP, 63 बाइट्स

पॉवरशेल , 57 44 41 बाइट्स

Processing, 93 92 90 bytes

Ungolfed

Python, 71 bytes

Retina, 28 bytes

MATL, 9 bytes

Explanation

C# (with Linq) 90 81 73 71 69 68 Bytes

Explanation:

Haskell, 37 bytes

JavaScript, 40 bytes

Groovy, 61 bytes

Python 2, 58 Bytes

><>, 39 bytes

Batch, 102 bytes