เกือบหกปีที่ผ่านมาสมาชิก PPCG steenslag โพสต์ความท้าทายต่อไปนี้:

ในลูกเต๋ามาตรฐาน (ตาย) ตัวเลขจะถูกจัดเรียงเพื่อให้ใบหน้าตรงข้ามเพิ่มเป็นเจ็ด เขียนโปรแกรมสั้นที่สุดเท่าที่จะเป็นไปได้ในภาษาที่คุณต้องการซึ่งจะให้ผลแบบสุ่มตามด้วยการสุ่ม 9 ครั้ง การให้ทิปคือการหมุนหนึ่งในสี่ของลูกเต๋าเช่นหากลูกเต๋าหันหน้าไปทาง 5 การเอียงที่เป็นไปได้ทั้งหมดคือ 1,3,4 และ 6

ตัวอย่างผลลัพธ์ที่ต้องการ:

1532131356

ดังนั้นตอนนี้ทุกคนลืมไปหมดแล้วและคำตอบที่ชนะนั้นได้รับการยอมรับมานานเราจะทำการเขียนโปรแกรมเพื่อตรวจสอบลำดับการตายของทิปที่สร้างขึ้นโดยโซลูชันที่ส่งมา (มันสมเหตุสมผลแล้วเพียงแค่แกล้งทำ)

ท้าทาย

คุณโปรแกรมหรือฟังก์ชั่น1532131356จะได้รับลำดับเช่น ตรวจสอบว่าแต่ละหลักที่ต่อเนื่องกันคือ:

• ไม่เท่ากับตัวเลขก่อนหน้า
• ไม่เท่ากับ7ลบตัวเลขก่อนหน้า

(คุณไม่จำเป็นต้องตรวจสอบหลักแรก)

กฎระเบียบ

• โปรแกรมของคุณจะต้องกลับมาเป็นค่า truthy ถ้าใส่ถูกต้องและค่า falseyมิฉะนั้น
• คุณสามารถสันนิษฐานว่าอินพุตประกอบด้วยตัวเลขเพียง 1-6 หลักและมีความยาวอย่างน้อย 1 ตัวอักษร ลำดับจะไม่มีความยาวคงที่เหมือนในการท้าทายของ steenslag
• คุณสามารถรับอินพุตเป็นสตริง ( "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
  

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

ฟังก์ชันนี้รวมคำสั่งลดของฉันกับตรรกะบิตสะบัดจากคำตอบของ @ Zgarb สำหรับชุดค่าผสมที่สั้นกว่าทั้งสอง

คำตอบทั้งคู่แสดงผลลัพธ์ต่อไปนี้:

• 0 ถ้าอินพุตไม่ใช่ลำดับที่ถูกต้อง
• ตัวเลขหลักสุดท้ายของลำดับหากถูกต้อง

Python ขนาด 44 ไบต์

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

มายากล Bitwise! นี่เป็นฟังก์ชั่นนิรนามที่รับรายการจำนวนเต็มและตรวจสอบว่าแฮคเกอร์ขององค์ประกอบสองตัวที่ต่อเนื่องกันอยู่ระหว่าง 1 ถึง 6

ทำไมมันถึงได้ผล

อันดับแรก XOR อยู่เสมอระหว่าง 0 และ 7 รวมตั้งแต่ 7 อยู่111ในฐาน 2 และตัวเลขของเรามีเลขฐานสองไม่เกิน 3 หลัก สำหรับความเสมอภาคและถ้าหากa^b == 0 a == bนอกจากนี้เรายังมี7-a == 7^aเมื่อ0 ≤ a ≤ 7และทำให้ถ้าหากa^b == 7a == 7^b == 7-b

05AB1E , 11 9 ไบต์

-2 ไบต์สำหรับแนวคิดที่ชาญฉลาดของ Osable ในการใช้ผลิตภัณฑ์

¥¹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 ซึ่งไม่ได้ใช้คำสั่ง pairwise:

• 0 ถ้ามันละเมิดคุณสมบัติที่ไม่พึงประสงค์
• Not 0 หากไม่มีอะไรป้องกันไม่ให้มันเมา

R, 39 37 32 31 ไบต์

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

ลองออนไลน์!

รับอินพุตจาก stdin ใช้diffเพื่อดูว่าตัวเลขสองหลักใดต่อเนื่องกันเหมือนกันหรือไม่ จากนั้นเปรียบเทียบแต่ละหลักเพื่อ 7 ลบด้วยตัวเลขก่อนหน้า ผลตอบแทนหรือTRUEFALSE

บันทึก 5 ไบต์ขอบคุณ Jarko Dubbeldam และขอขอบคุณ JayCe อีกคน

05AB1E , 10 ไบต์

$ü+7ʹüÊ*P

ใช้การเข้ารหัสCP-1252 ลองออนไลน์!

R, 49 44 ไบต์

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

อ่านข้อมูลจาก stdin (คั่นด้วยช่องว่าง) TRUE/FALSEและเอาท์พุท จะให้คำเตือนหากอินพุตมีความยาวหนึ่งตัว แต่ยังใช้งานได้

แก้ไข: บันทึกสองไบต์ด้วย @rturnbull

05AB1E , 15 ไบต์

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

ลองออนไลน์! หรือเป็นชุดทดสอบ

JavaScript (ES6), 43 40 ไบต์

ผลตอบแทน/0true

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

Perl 6 , 22 ไบต์

ใช้ regex:

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

รับอินพุตเป็นสตริง แรงบันดาลใจจากGB คำตอบของทับทิม
มันทำงานอย่างไร:

• / /: regex
• (.): ตรงกับตัวอักษรใด ๆ $0และจับเป็น
• <{ }>: สร้าง sub-regex แบบไดนามิกเพื่อจับคู่ที่ตำแหน่งนั้น
• "$0|" ~ (7 - $0): sub-regex ที่เราสร้างขึ้นเป็นเลขที่ตรงกับหลักก่อนหน้านี้หรือ 7 ลบด้วยตัวเลขก่อนหน้า (เช่น5|2)
  ดังนั้น regex โดยรวมจะจับคู่ถ้าพบว่ามีคู่ของตัวเลขติดต่อกันไม่ถูกต้องทุกที่
• {! }: บีบบังคับให้บูลีน (ทำให้ regex จับคู่กับ$_), ลบล้างมัน, และเปลี่ยนสิ่งทั้งหมดให้เป็นแลมบ์ดา (ด้วยพารามิเตอร์โดยปริยาย$_)

Perl 6 , 38 ไบต์

ใช้การประมวลผลรายการ:

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

รับอินพุตเป็นอาร์เรย์ของจำนวนเต็ม
มันทำงานอย่างไร:

• .[1..*] Z $_: ซิปรายการอินพุตด้วยเวอร์ชันออฟเซ็ตโดยหนึ่งของตัวเองเพื่อสร้างรายการ 2-tuples ของตัวเลขติดกัน
• [!=] 7 - .[1], |$_: (7 - b) != a != bสำหรับแต่ละคนให้ตรวจสอบว่า
• all ( ): ส่งคืนค่าความจริงหรือค่าเท็จขึ้นอยู่กับว่าการวนซ้ำทั้งหมดส่งคืน True หรือไม่

Python ขนาด 38 ไบต์

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

f(1,2,3)ฟังก์ชั่นที่ใช้เวลาเวียนเกิดข้อโต้แย้งเช่น

นี้จะทำให้การใช้งานของการโต้แย้งการเปิดออกเพื่อแยกหมายเลขแรกเข้าhและส่วนที่เหลือลงใน ttuple ถ้าtไม่มีข้อมูลเอาท์พุท True มิฉะนั้นให้ใช้เคล็ดลับบิตของ Zgarbเพื่อตรวจสอบว่าสองม้วนแรกไม่เข้ากัน จากนั้นตรวจสอบว่าผลลัพธ์ยังคงอยู่ที่การเรียกซ้ำบนหาง

Ruby, 34 ไบต์

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

JavaScript 61 43 ไบต์

ความคิดเห็นได้กล่าวถึงฉันไม่สามารถใช้ฟังก์ชัน C # linq โดยไม่รวมคำสั่ง using ดังนั้นนี่เป็นจำนวนไบต์ที่น้อยกว่าโดยใช้ JS มาตรฐาน ...

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

C #, 99 67 65 ไบต์

รับอินพุตเป็น 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;}

คำอธิบาย:

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

> <> (ปลา) 47 ไบต์

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

ค่อนข้างง่าย

บรรทัดที่ 1: ตรวจสอบเพื่อดูว่าใส่ตัวเลขหรือไม่หากไม่มีตัวเลข (EOF) เรามีความจริงที่จะพิมพ์เช็คอื่น

บรรทัดที่ 2: ผลการพิมพ์

บรรทัดที่ 3: เปลี่ยนอินพุตเป็นตัวเลข (ASCII 0 - จากอินพุต) จากนั้นตรวจสอบว่าเท่ากับอินพุตก่อนหน้าหรือไม่

บรรทัดที่ 4: ตรวจสอบว่าอินพุตอยู่ฝั่งตรงข้ามของแม่พิมพ์หรือไม่

Brain-Flak 128 Bytes

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

เอาต์พุต 0 สำหรับ falsey หรือ -7 สำหรับความจริง

ลองออนไลน์! (ความจริง)
ลองออนไลน์! (Flasey)

คำอธิบาย (t หมายถึง top และ s หมายถึงวินาทีจากด้านบน):

(())                # 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 ไบต์

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

PHP, 63 ไบต์

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

รับอินพุตเป็นรายการของอาร์กิวเมนต์คำสั่ง ออกด้วย1(ข้อผิดพลาด) หากอินพุตไม่ถูกต้อง0(ok) หากถูกต้อง

-nrทำงานด้วย

อินพุตเป็นอาร์กิวเมนต์สตริง 65 ไบต์

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

PowerShell , 57 44 41 ไบต์

_{( ข้ามออก 44 ยังคงเป็นปกติ 44 )}

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

ลองออนไลน์!

(OP ได้ชี้แจงว่าการป้อนข้อมูลเป็นอาร์กิวเมนต์ที่แยกต่างหากก็โอเค - บันทึก 13 ไบต์ ... บันทึกอีก 3 ไบต์โดยการกำจัด$b)

เรากำลังวนเข้าที$argsละครั้ง แต่ละหลักเราตรวจสอบว่า$lAST หลักคือ-nOT equal กับหลักในปัจจุบัน$_และที่7-$_-$lเป็นจำนวนอื่นที่ไม่ใช่ศูนย์บาง (ซึ่งเป็น truthy) บรรดาผลการบูลีนได้รับการห่อหุ้มใน parens และป้อนเข้าตัวถูกดำเนินการทางด้านขวามือของผู้ประกอบการตรวจสอบกับ-notin 0ในคำอื่น ๆ หากมีใด ๆFalseได้ทุกที่คุ้มค่าในวงที่ยังจะ-notin Falseบูลีนนั้นถูกทิ้งไว้บนไพพ์ไลน์และเอาท์พุทก็เป็นนัย

ความยาวเนื่องจาก$ความต้องการชื่อตัวแปรและคำสั่งบูลีน-ne -andนั้นละเอียดใน PowerShell โอ้ดี

กำลังประมวลผล93 92 90 ไบต์

เปลี่ยน || เป็น | : 1 ไบต์บันทึกขอบคุณ @ClaytonRamsey

เริ่มนับถอยหลัง: บันทึกได้ 2 ไบต์ด้วย @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;}

รับอินพุตเป็นอาร์เรย์ของ ints เอาต์พุต1สำหรับจริงหรือ0เท็จ

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 ไบต์

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

ใช้สตริงของตัวเลข (หรืออาเรย์ที่ถูกยกเลิกเป็นศูนย์ไบต์)

คำอธิบาย

F(char*s){

ตามintประเภทผลตอบแทนมาตรฐานโดยนัย (บันทึก 4 ไบต์)

return ส่งคืนแบบไม่มีเงื่อนไขเนื่องจากนี่เป็นฟังก์ชันแบบเรียกซ้ำ

ใช้การประเมินทางลัด:

!s[1]||ถ้าตัวละครที่สองคือNULกลับจริง

((*s^s[1])%7&& ถ้าคนสองคนแรกไม่ได้ผิดกฎหมาย

F(s+1)) ตรวจสอบส่วนที่เหลือของสตริงด้วยวิธีเดียวกัน

การแสดงออกที่ทำให้เกิดความสับสน

*sเป็นตัวอักษรตัวแรกs[1]คือตัวที่สอง

*s^s[1] เอกสิทธิ์ - ors พวกเขาร่วมกันหากพวกเขาเป็นเหมือนกันผลลัพธ์คือ 0 ถ้าพวกเขาเพิ่มถึง 7 ผลที่ได้คือ 7, (ถ้าพวกเขาแตกต่างกันและไม่เพิ่มถึง 7 ผลคือระหว่าง 1 และ 6 รวม)

เพื่อให้(*s^s[1])%7เป็นศูนย์สำหรับการป้อนข้อมูลที่ไม่ดีและไม่เป็นศูนย์มิฉะนั้นเท็จดังนั้นหากทั้ง 2 ตัวละครที่ไม่ดีและเป็นความจริงเป็นอย่างอื่น

หมายเหตุ: เนื่องจากการเรียกฟังก์ชั่นนี้ใช้เฉพาะการเรียกซ้ำครั้งสุดท้าย (เฉพาะคำสั่งสุดท้ายคือการเรียกซ้ำ) ผู้เพิ่มประสิทธิภาพสามารถแปลการสอบถามซ้ำเป็นลูปนี่คือความคิดที่มีความสุขและเห็นได้ชัดว่าไม่คุ้มกับคะแนนกอล์ฟใด ๆ ทำให้เป็นไปได้ในการประมวลผลสตริงที่มีความยาวไม่มีสแต็คหมด

Python ขนาด 71 ไบต์

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

ใช้วิธีเรียกซ้ำ

คำอธิบาย:

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

เรติน่า 28 ไบต์

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

ลองออนไลน์!

อีกวิธีหนึ่งคือ:

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

ลองออนไลน์!

MATL , 9 ไบต์

dG2YCs7-h

อินพุตเป็นอาร์เรย์ของตัวเลขที่แทนตัวเลข

ผลลัพธ์เป็นอาร์เรย์ที่ไม่ว่างเปล่าซึ่งเป็นความจริงหากรายการทั้งหมดไม่เป็นศูนย์และเป็นอย่างอื่น (อ่านเพิ่มเติมเกี่ยวกับเกณฑ์ของ MATL สำหรับความจริงและเท็จที่นี่ )

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

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

คำอธิบาย:

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 ไบต์เท่ากับ 85 ไบต์

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

อินพุตคืออาร์เรย์ของจำนวนเต็ม A ที่มีความยาว L ส่งคืน 1 สำหรับจริงและ 0 สำหรับเท็จ อินพุตถูกตรวจสอบจากจุดสิ้นสุดไปยังจุดเริ่มต้นโดยใช้ความยาวอินพุต L เป็นดัชนีอาร์เรย์

Haskell, 37 ไบต์

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

ตัวอย่างการใช้งาน: ->f [1,5,2]False

เรียกซ้ำง่าย ๆ กรณีฐาน: Trueรายการองค์ประกอบเดียวซึ่งผลตอบแทน กรณีเรียกซ้ำ: อนุญาตaและbเป็นสององค์ประกอบแรกของรายการอินพุตและcส่วนที่เหลือ ทุกเงื่อนไขต่อไปนี้ต้องถือ: a+b/=7, a/=bและโทร recursive กับaลดลง

JavaScript ขนาด 40 ไบต์

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

ใช้ประโยชน์จากคุณสมบัติ JavaScript ที่&&จะส่งคืนค่าสุดท้ายที่แยกวิเคราะห์ (ทั้งคำที่ผิดพลาดหรือคำสุดท้าย) 0ถูกส่งไปพร้อมกันหากไม่เป็นไปตามเงื่อนไขและคำก่อนหน้านี้ถูกส่งไปเป็นอย่างอื่น 9 ทำให้แน่ใจว่ามันเริ่มต้นด้วยค่าความจริง

Groovy, 61 ไบต์

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

Python 2, 58 ไบต์

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

> <> , 39 ไบต์

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

ลองออนไลน์!

แบตช์ 102 ไบต์

@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