ลักษณะ

เราพิจารณาจำนวนเต็มอย่างน้อย 3 หลักที่มีความสมดุลสามเท่าหากเมื่อแบ่งออกเป็นสามส่วนตัวเลขในทุกส่วนจะรวมกันเป็นจำนวนเดียวกัน เราแบ่งตัวเลขดังนี้:

abcdefghi - Standard case: the number of digits is divisable through 3:
abc def ghi

abcdefgh - Number % 3 == 2: The outer groups are both assigned another digit
abc de fgh (the inner group will have one digit less than both outer groups)

abcdefghij - Number % 3 == 1: The inner group is assigned the extra digit
abc defg hij (the inner group will have one digit more than the outer groups)

ท้าทาย

งานของคุณคือการเขียนโปรแกรมที่ให้เลขจำนวนเต็มอย่างน้อย 3 หลักเป็นตัวกำหนดว่าจำนวนที่กำหนดนั้นมีความสมดุลสามเท่าและส่งออกค่าจริงหรือเท็จตามผลลัพธ์ของมัน

กรณีทดสอบ

333 -> True
343 -> False
3123 -> True
34725 -> True
456456 -> False
123222321 -> True

นี่คือcode-golfดังนั้นช่องโหว่มาตรฐานจึงมีผลบังคับใช้และอาจเป็นคำตอบที่สั้นที่สุดในหน่วยไบต์!

Python 2 , 93 88 86 ไบต์

-4 ไบต์ขอบคุณ @LeakyNun
-2 ไบต์ขอบคุณ @ Mr.Xcoder

def g(i):l=-~len(i)/3;print f(i[:l])==f(i[l:-l])==f(i[-l:])
f=lambda a:sum(map(int,a))

ลองออนไลน์!

เยลลี่ 23 ไบต์

DµL‘:3‘Ṭ©œṗ⁸U®œṗЀS€€FE

ลองออนไลน์!

จะต้องมีวิธีที่สั้นกว่าที่จะบินไปบนหัวของฉัน

เรติน่า , 89 ไบต์

^|$
¶
{`¶(.)(.*)(.)¶
$1¶$2¶$3
}`^((.)*.)(.)¶((?<-2>.)*)¶(.)
$1¶$3$4$5¶
\d
$*
^(1+)¶\1¶\1$

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

Mathematica, 142 ไบต์

(s=IntegerDigits@#;c=Floor;If[Mod[t=Length@s,3]==2,a=-1;c=Ceiling,a=Mod[t,3]];Length@Union[Tr/@FoldPairList[TakeDrop,s,{z=c[t/3],z+a,z}]]==1)&

เยลลี่ , 20 ไบต์

DµL‘:3x2jSạ¥¥LRṁ@ḅ1E

ลองออนไลน์!

มันทำงานอย่างไร

DµL‘:3x2jSạ¥¥LRṁ@ḅ1E  Main link. Argument: n

D                     Decimal; convert n to base 10, yielding a digits array A.
 µ                    Begin a new chain with argument A.
  L                   Compute the length of A.
   ‘                  Increment; add 1 to the length.
    :3                Divide the result by 3.
                      This yields the lengths of the outer chunks.
      x2              Repeat the result twice, creating an array C.
             L        Compute l, the length of A.
            ¥         Combine the two links to the left into a dyadic chain.
                      This chain will be called with arguments C and l. 
           ¥              Combine the two links to the left into a dyadic chain.
         S                    Take the sum of C.
          ạ                   Compute the absolute difference of the sum and l.
        j                 Join C, using the result to the right as separator.
                      We now have an array of the lengths of all three chunks the
                      digits of n have to be split in.
              R       Range; map each chunk length k to [1, ..., k].
               ṁ@     Mold swapped; takes the elements of A and give them the shape
                      of the array to the right, splitting A into chunks of the
                      computed lengths.
                 ḅ1   Convert each chunk from unary to integer, computing the sum
                      of its elements.
                   E  Test if the resulting sums are all equal.

MATL , 26 ไบต์

3:jnZ^!S!tgtYswG48-*Z?da~a

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

Javascript, 178 ไบต์

(a)=>{b=a.split(/(\d)/).filter((v)=>v);s=Math.round(b.length/3);f=(m,v)=>m+parseInt(v);y=b.slice(s,-s).reduce(f,0);return b.slice(0,s).reduce(f,0)==y&&y==b.slice(-s).reduce(f,0)}

Java 8, 149 ไบต์

q->{int l=q.length,s=(l+1)/3,a=0,b=0,c=0,i=0;for(;i<s;a+=q[i++]);for(i=s,s=l/3*2+(l%3<1?0:1);i<s;b+=q[i++]);for(i=s;i<l;c+=q[i++]);return a==b&b==c;}

int[]จะเข้าเป็น

คำอธิบาย:

ลองที่นี่

q->{                 // Method with int-array parameter and boolean return-type
  int l=q.length,    //  Length of the input-array
      s=(l+1)/3,     //  (Length + 1) divided by 3
      a=0,b=0,c=0,   //  Three sums starting at 0
      i=0;           //  Index-integer
  for(;i<s;          //  Loop (1) from 0 to `s1` (exclusive)
    a+=q[i++]        //   And increase `a` with the next digit
  );                 //  End of loop (1)
  for(i=s,s=l/3*2+(l%3<1?0:1);i<s;
                     //  Loop (2) from `s1` to `s2` (exclusive)
    b+=q[i++]        //   And increase `b` with the next digit
  );                 //  End of loop (2)
  for(i=s;i<l;       //  Loop (3) from `s2` to `l` (exclusive)
    c+=q[i++]        //   And increase `c` with the next digit
  );                 //  End of loop (3)
  return a==b&b==c;  //  Return if `a`, `b` and `c` are equal
}                    // End of method

นี่คือภาพรวมของชิ้นส่วน 0 ที่จัดทำดัชนี (พิเศษ) สำหรับแต่ละความยาว:

Length:  Parts:    0-indexed (exclusive) parts:

 3       1,1,1     0,1 & 1,2 & 2,3
 4       1,2,1     0,1 & 1,3 & 3,4
 5       2,1,2     0,2 & 2,3 & 3,5
 6       2,2,2     0,2 & 2,4 & 4,6
 7       2,3,2     0,2 & 2,5 & 5,7
 8       3,2,3     0,3 & 3,5 & 5,8
 9       3,3,3     0,3 & 3,6 & 6,9
10       3,4,3     0,3 & 3,7 & 7,10
...

• สำหรับaเราวนซ้ำจาก0ถึง(length + 1) / 3)(ตอนนี้ค่านี้ถูกเก็บไว้ในs);
• สำหรับbเราวนรอบจากsถึงlength / 3 * 2 +( 0หากความยาว modulo-3 เป็น 0; 1ถ้าความยาว modulo-3 เป็น 1 หรือ 2) (ตอนนี้ค่านี้เก็บในs)
• สำหรับcวงเราจากไปslength

(ทั้งสามลูปเป็นดัชนีเฉพาะ 0)

โรดา , 82 ไบต์

f s{n=((#s+1)//3)[s[:n],s[n:#s-n],s[#s-n:]]|[chars(_)|[ord(_)-48]|sum]|[_=_,_=_1]}

ลองออนไลน์!

คำอธิบาย:

f s{ /* function declaration */
    n=((#s+1)//3)
    [s[:n],s[n:#s-n],s[#s-n:]]| /* split the string */
    [ /* for each of the three strings: */
        chars(_)|    /* push characters to the stream */
        [ord(_)-48]| /* convert characters to integers */
        sum          /* sum the integers, push the result to the stream */
    ]|
    [_=_,_=_1] /* take three values from the stream and compare equality */
}

JavaScript, 129 , 104 ไบต์

([...n],l=n.length/3+.5|0,r=(b,e=b*-4,z=0)=>n.slice(b,e).map(x=>z-=x)&&z)=>r(0,l)==r(-l)&&r(l,-l)==r(-l)

ฟังก์ชั่น r แบ่งสตริงตามพารามิเตอร์ b และ e จากนั้นผลรวมตัวเลขและส่งกลับค่า

เพื่อแบ่งขนาดที่ถูกต้องเราแบ่งความยาวเป็น 3 แล้วปัดผลลัพธ์ การเรียกส่วน (0 ผลลัพธ์) ให้บล็อกแรกกับเราชิ้น (ผลลัพธ์ - ผลลัพธ์) ให้อันดับที่สองและชิ้น (ผลลัพธ์) ให้เราเป็นครั้งสุดท้าย เนื่องจากวิธีการที่ฉันเรียกชิ้นฉันใช้ชิ้น (ผลลัพธ์ผล 4 *) แทนที่จะเป็นชิ้นสุดท้าย แต่ให้ผลเหมือนกัน

ในที่สุดฉันเปรียบเทียบผลลัพธ์ที่แสดงว่าค่าเท่ากัน

แก้ไข: หลักการเดียวกันการเล่นกอล์ฟที่ดีขึ้น