বৈধ র্যান্ডম ডাই টিপস

Question

প্রায় ছয় বছর আগে, সহকর্মী পিপিসি সদস্য স্টেনস্লাগ নিম্নলিখিত চ্যালেঞ্জ পোস্ট করেছেন:

স্ট্যান্ডার্ড ডাইসে (ডাই) সংখ্যাগুলি এমনভাবে সাজানো হয় যাতে বিপরীত মুখগুলি সাতটিতে যুক্ত হয়। আপনার পছন্দের ভাষায় সংক্ষিপ্ততম প্রোগ্রামটি লিখুন যা 9 টি এলোমেলো টিপিংসের পরে একটি এলোমেলো নিক্ষেপ দেয়। একটি টিপিংটি পাশার এক চতুর্থাংশের পালা, যেমন যদি পাশাটি 5 এর মুখোমুখি হয় তবে সমস্ত সম্ভাব্য টিপিংস 1,3,4 এবং 6 হয়।

পছন্দসই আউটপুট উদাহরণ:

1532131356

সুতরাং, এখন যেহেতু প্রত্যেকে এটি সম্পর্কে সম্পূর্ণরূপে ভুলে গেছে এবং বিজয়ী উত্তরটি দীর্ঘকাল ধরে গৃহীত হয়েছে, তাই আমরা জমা দেওয়া সমাধানগুলি দ্বারা উত্পন্ন ডাই টিপিংয়ের ক্রমগুলি বৈধ করার জন্য একটি প্রোগ্রাম লিখব। (এটি বোধগম্য হয় Just

চ্যালেঞ্জ

আপনার প্রোগ্রাম বা ফাংশন যেমন একটি ক্রম দেওয়া হয় 1532131356। প্রতিটি পর পরের সংখ্যাটি যাচাই করুন:

• আগের অঙ্কের সমান নয়
• আগের অঙ্কটি 7 বিয়োগের সমান নয়

(আপনাকে প্রথম সংখ্যাটি যাচাই করতে হবে না))

বিধি

• যদি আপনার ইনপুটটি বৈধ হয় এবং অন্যথায় একটি মিথ্যা মান থাকে তবে অবশ্যই আপনার প্রোগ্রামটিকে সত্যবাদী মানটি দিতে হবে।
• আপনি ধরে নিতে পারেন যে ইনপুটটিতে কেবল 1-6 অঙ্ক থাকে এবং কমপক্ষে 1 টি অক্ষর দীর্ঘ। স্টেনস্লাগের চ্যালেঞ্জের মতো সিকোয়েন্সগুলির নির্দিষ্ট দৈর্ঘ্য থাকবে না।
• আপনি "324324"ইনপুটটিকে স্ট্রিং ( ), একটি অ্যারে বা অ্যারের মতো ডেটাস্ট্রাকচার ( [1,3,5]) বা একাধিক যুক্তি ( yourFunction(1,2,4)) হিসাবে নিতে পারেন।

_{স্ট্যান্ডার্ড আই / ও এবং লুফোলের বিধিগুলি প্রযোজ্য।}

পরীক্ষার মামলা

Truthy

1353531414
3132124215
4142124136
46
4264626313135414154
6
2642156451212623232354621262412315654626212421451351563264123656353126413154124151545145146535351323
5414142

Falsey

• পুনরাবৃত্তি সংখ্যা

  11
  3132124225
  6423126354214136312144245354241324231415135454535141512135141323542451231236354513265426114231536245
  553141454631
  14265411
  

• বিপক্ষে মরার পক্ষে

  16
  42123523545426464236231321
  61362462636351
  62362462636361
  

Answer 1

পাইথন 2, 43 45 বাইট

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

43 বাইট (@ জাগারব দ্বারা ভারী অনুপ্রাণিত)

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

উভয়ের চেয়ে সংক্ষিপ্ত সংমিশ্রণের জন্য এই ফাংশনটি @ জাগারবের উত্তর থেকে বিট-ফ্লিকিং যুক্তির সাথে আমার হ্রাস বিবৃতিটিকে একত্রিত করে।

উভয় উত্তর নিম্নলিখিত ফলাফল:

• 0 যদি ইনপুটটি বৈধ অনুক্রম না হয়
• ক্রমের শেষ সংখ্যাটি যদি এটি বৈধ হয়

Comments

পিপিসিজিতে আপনাকে স্বাগতম, এটি একটি দুর্দান্ত প্রথম উত্তর।

— গম উইজার্ড

এটি প্রায় অর্ধেক মিথ্যা মামলার জন্য কাজ করে না। যেমন 3132124225ফেরত দেয় 5।

— জ্যাক কোব

আপনি এটি ব্যবহার করে এটি ঠিক করতে পারেন n and p*(7-p!=n!=p)।

— জেক কোব

@ জ্যাককবব এখন সমস্ত পরীক্ষার ক্ষেত্রে এটির কাজ করা উচিত। দুর্ভাগ্যবশত এটা এখন আর বাইট এখন 2 :(

— notjagan

প্রতিটি ধাপে পরবর্তী ধাপে পাস করে হ্রাস করার কী চতুর ব্যবহার।

— xnor

Answer 2

পাইথন, 44 বাইট

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

বিটওয়াইজ ম্যাজিক! এটি একটি বেনাম ফাংশন যা পূর্ণসংখ্যার একটি তালিকা গ্রহণ করে এবং এটি পরীক্ষা করে থাকে যে প্রতি দুটি টানা উপাদানগুলির এক্সওআর 1 এবং 6 এর মধ্যে অন্তর্ভুক্ত।

কেন এটি কাজ করে

প্রথমত, এক্সওআর সর্বদা 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।

Answer 3

05 এ বি 1 ই , 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 টিপসিস হওয়া থেকে বাধা দেওয়ার কিছু যদি না থাকে।

Comments

@ এমিগনা এটি বিবেচ্য নয় তবে স্থির করেছেন!

— যাদু অক্টোপাস উরন

আমি ডেল্টাস সহ একটি উত্তর পোস্ট করতে চেয়েছিলাম, তবে আমি এটি নিয়ে ভাবি না Á। নিস!

— ব্যবহারযোগ্য

আপনি এর সাথে সত্যবাদী / মিথ্যা মানগুলির সংজ্ঞা ব্যবহার করে 2 বাইট সংরক্ষণ করতে পারেন ¥¹D7-Á+«P। অ্যারেতে 0 বা অন্যথায় অন্য কোনও মান থাকলে এটি 0 দেয়।

— অযোগ্য

@ সম্ভাব্য স্মার্ট! মেগা স্মার্ট ম্যান, ভাল কাজ।

— ম্যাজিক অক্টোপাস উরন

Answer 4

আর, 39 37 32 31 বাইট

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

এটি অনলাইন চেষ্টা করুন!

স্টিডিন থেকে ইনপুট নেয়। diffকোনও দুটি টানা অঙ্ক একই কিনা তা দেখতে ব্যবহার করে; তারপরে প্রতিটি অঙ্ককে পূর্বের অঙ্কের সাথে 7 বিয়োগের সাথে তুলনা করুন। রিটার্ন TRUEবাFALSE ।

জারকো ডাবডেলডামকে 5 বাইট সংরক্ষণ করা এবং জ্যাকিকে আরও একটি ধন্যবাদ সংরক্ষণ করা।

Comments

কিছু পরিবর্তনশীল মধ্যে পার্থক্য সংরক্ষণ 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।

— জেএডি

@ জারকো ডাবল্ডাম দুর্দান্ত পর্যবেক্ষণ, ধন্যবাদ! আমি সমাধান আপডেট করেছি।

— rturnbull

1 বাইট সংরক্ষণ করুন

— জেসি

@ জাসি ধন্যবাদ, আমি এখনই উত্তরটি আপডেট করেছি।

— rturnbull

Answer 5

05 এ বি 1 ই , 10 বাইট

$ü+7ʹüÊ*P

সিপি -1222 এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন!

Comments

আরগ !, কেন আমি ভেবে দেখিনি Ê: পি চমৎকার!

— এমিগিনা

হুম, তাই 1*[] = []কিন্তু product(1, []) = 1। এটা জানা ভাল.

— এমিগিনা

@ এমিগনা আসলে এটি একটি বাগ। এর পণ্যটি 1 []হওয়া উচিত

— আদনান

হ্যাঁ, আমি চেয়েছিলাম যে এটি এর আগে বেশ কয়েকবার এর মতো কাজ করেছিল। ক্রিয়াকলাপের আদেশ এখানেও গুরুত্বপূর্ণ। )1*, )1s*এবং )1Pসবাই []যখন )1sP1.

— Emigna

@ এমিগনা আহ, কারণ এর পণ্যটি []একটি ত্রুটি দেয় এবং তা বাতিল করা হয়। এই কারণেই এটি 1 দেয় I'll আমি বাড়ি এলে এটি ঠিক করার চেষ্টা করব।

— আদনান

Answer 6

আর, 49 44 বাইট

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

স্টিডিন (স্থান দ্বারা পৃথক) এবং আউটপুট থেকে ইনপুট পড়ে TRUE/FALSE। যদি ইনপুট এক দৈর্ঘ্যের হয় তবে এখনও কাজ করে তবে সতর্কতা দেবে।

সম্পাদনা: @ আর্টারনবুলকে ধন্যবাদ জানিয়ে কয়েকটা বাইট সংরক্ষণ করা হয়েছে

Comments

আপনি একত্রিত করতে পারেন 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

Answer 7

05 এ বি 1 ই , 15 বাইট

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

এটি অনলাইন চেষ্টা করুন! বা টেস্ট স্যুট হিসাবে

Answer 8

জাভাস্ক্রিপ্ট (ES6), 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'));

Comments

দুঃখের বিষয় হল রেটিনা উত্তরের সরল বন্দরটি কেবলমাত্র 38 বাইট।

— নিল

@ নিল আমি মনে করি এটি আসলে 37 সহtest()

— আর্নল্ড

দুঃখিত, আমি দুর্ঘটনাক্রমে বাইট কাউন্টারে একটি নতুন লাইন পেস্ট করেছি।

— নিল

Answer 9

পার্ল 6 , 22 বাইট

একটি রেজেক্স ব্যবহার করে:

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

স্ট্রিং হিসাবে ইনপুট নেয়। জিবি এর রুবি উত্তর দ্বারা অনুপ্রাণিত ।
কিভাবে এটা কাজ করে:

• / /: একটি রেজেক্স।
• (.): যে কোনও চরিত্রের সাথে মেলে, এবং এটি ক্যাপচার করুন $0।
• <{ }>: স্থিতিশীলভাবে সেই অবস্থানে মেলে একটি উপ-রেজেক্স তৈরি করুন।
• "$0|" ~ (7 - $0): আমরা যে উপ-রেজেক্স উত্পন্ন করি তা হ'ল এটি কেবল পূর্বের অঙ্কের সাথে মেলে বা পূর্ববর্তী অঙ্কের সাথে 7 বিয়োগফল (যেমন 5|2)।
  সুতরাং যদি এটি কোথাও একটি অবৈধ টানা জোড়া সংখ্যার সন্ধান করে তবে সামগ্রিক রেজেক্স মিলবে।
• {! }: একটি বুলিয়ানকে বাধ্য করুন (যার ফলে রেজেক্সের সাথে মিল রয়েছে $_), এটিকে উপেক্ষা করুন এবং পুরো জিনিসটিকে ল্যাম্বডায় পরিণত করুন (অন্তর্নিহিত প্যারামিটার সহ $_)।

পার্ল 6 , 38 বাইট

তালিকা প্রক্রিয়াজাতকরণ ব্যবহার:

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

পূর্ণসংখ্যার অ্যারের হিসাবে ইনপুট নেয়।
কিভাবে এটা কাজ করে:

• .[1..*] Z $_: একটানা সংখ্যার 2 টি-টিপলগুলির একটি তালিকা তৈরি করতে নিজের একটি অফসেট বাই এক সংস্করণ দিয়ে ইনপুট তালিকাটি জিপ করুন।
• [!=] 7 - .[1], |$_: তাদের প্রত্যেকের জন্য, কিনা তা পরীক্ষা করে দেখুন (7 - b) != a != b।
• all ( ): সমস্ত লুপ পুনরাবৃত্তি সত্য হয়েছে কিনা তার উপর নির্ভর করে সত্যবাদী বা মিথ্যা মানটি ফেরত দিন।

Answer 10

পাইথন, 38 বাইট

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

একটি পুনরাবৃত্তি ফাংশন যা যুক্তিগুলি গ্রহণ করে f(1,2,3)।

এটি প্রথম সংখ্যাটি বের করতে এবং বাকীটিকে টিপলে আনপ্যাকিংয়ের সাহায্যে যুক্তি ব্যবহার hকরে t। যদি tখালি থাকে, আউটপুট সত্য। অন্যথায়, প্রথম দুটি ডাই রোলগুলি বেমানান নয় কিনা তা পরীক্ষা করতে Zgarb এর বিট কৌশলটি ব্যবহার করুন । তারপরে, ফলাফলটি লেজটিতে পুনরাবৃত্ত কলকে ধরে রাখে তাও পরীক্ষা করে দেখুন।

Answer 11

রুবি, 34 বাইট

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

Comments

you could shave off two bytes by using the string #[] method instead: ->s{!s[/[16]{2}|[25]{2}|[34]{2}/]}

— Alexis Andersen

I didn't know you can use it with regex, thanks.

— G B

Answer 12

JavaScript 61 43 bytes

Comments have mentioned I can't use C# linq functions without including the using statement, so here's the exact same in less bytes using standard JS...

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

C#, 99 67 65 bytes

Takes input as an 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;}

Explanation:

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

Comments

I think this needs to be wrapped in a function, or maybe a lambda (does C# have those?) Also, you could save a few bytes by returning 0 or 1 instead of false or true

— DJMcMayhem

oh, ok - first post on code golf. I'll edit...

— Erresen

No problem. BTW, welcome to the site! :)

— DJMcMayhem

@DJMcMayhem Correct me if I'm wrong but since the output requirement is truthy/falsey then the output options are language dependent tl;dr 1/0 are not truthy/falsey in c#

— JustinM - Reinstate Monica

@Phaeze You're correct that they're not truthy/falsey, but the standard IO rules meta.codegolf.stackexchange.com/questions/2447/… reckon you can output using exit codes and that functions can output in the same way as programs. I'll change back to booleans if required, but it'll cost me a few bites

— Erresen

Answer 13

><> (Fish) 47 bytes

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

Pretty simple;

Line 1: check to see if inputted a number, if no number (EOF) then we have a truthy to print else checks.

Line 2: print outcome.

Line 3: turn input into number (ASCII 0 - from input), then check if it's equal to previous input.

Line 4: check if input is opposite side of die.

Answer 14

Brain-Flak 128 Bytes

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

Outputs 0 for falsey, or -7 for truthy.

Try it Online! (Truthy)
Try it Online! (Flasey)

Explanation (t stands for top and s stands for 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)

Answer 15

MATLAB, 30 bytes

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

Answer 16

PHP, 63 bytes

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

takes input as list of command arguments; exits with 1 (error) if input is invalid, 0 (ok) if valid.

Run with -nr.

input as string argument, 65 bytes

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

Answer 17

PowerShell, 57 44 41 bytes

_{(Crossed out 44 is still regular 44)}

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

Try it online!

(OP has clarified that taking input as separate arguments is OK - saved 13 bytes ... saved another 3 bytes by eliminating $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.

Answer 18

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

Comments

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

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

Answer 19

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.

Comments

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

Answer 20

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

Comments

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

— Jasen

Answer 21

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!

Answer 22

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

Comments

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

Answer 23

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

Answer 24

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.

Comments

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

Answer 25

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.

Answer 26

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.

Answer 27

Groovy, 61 bytes

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

Answer 28

Python 2, 58 Bytes

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

Answer 29

><>, 39 bytes

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

Try it online!

Answer 30

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