Sự miêu tả

Chúng tôi xem xét một số nguyên có ít nhất 3 chữ số được cân bằng ba nếu, khi chia thành ba phần, các chữ số trong mỗi phần tổng hợp thành cùng một số. Chúng tôi chia số như sau:

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)

Thử thách

Nhiệm vụ của bạn là viết một chương trình, với một số nguyên có ít nhất 3 chữ số, xác định xem số đã cho có cân bằng ba hay không và đưa ra giá trị trung thực hoặc sai dựa trên kết quả của nó.

Các trường hợp thử nghiệm

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

Đây là môn đánh gôn , vì vậy các sơ hở tiêu chuẩn được áp dụng và có thể câu trả lời ngắn nhất bằng byte sẽ thắng!

Python 2 , 93 88 86 byte

-4 byte nhờ @LeakyNun
-2 byte nhờ @ 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))

Hãy thử trực tuyến!

Thạch , 23 byte

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

Hãy thử trực tuyến!

Phải có một cách ngắn hơn bằng cách nào đó bay qua đầu tôi ...

Võng mạc , 89 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải thích: Giai đoạn đầu tiên thêm các dòng mới ở đầu và cuối của đầu vào. Giai đoạn thứ hai sau đó cố gắng di chuyển các chữ số trên các dòng mới theo cặp, tuy nhiên nếu không còn đủ các chữ số ở giữa thì giai đoạn thứ ba có thể di chuyển chúng trở lại, khiến vòng lặp dừng lại. Giai đoạn thứ tư sau đó chuyển đổi từng chữ số riêng biệt thành unary do đó tổng hợp chúng, trong khi giai đoạn cuối chỉ đơn giản kiểm tra các khoản tiền bằng nhau.

Toán học, 142 byte

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

Thạch , 20 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Javascript, 178 byte

(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 byte

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

Lấy đầu vào là một int[].

Giải trình:

Hãy thử nó ở đây.

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

Dưới đây là tổng quan về các bộ phận được lập chỉ mục 0 (độc quyền) cho mỗi chiều dài:

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

• Đối với achúng tôi lặp từ 0đến (length + 1) / 3)(giá trị này hiện được lưu trữ trong s);
• Đối với bchúng tôi lặp từ sđến length / 3 * 2 +( 0nếu độ dài modulo-3 là 0; 1nếu độ dài modulo-3 là 1 hoặc 2) (giá trị này hiện được lưu trữ trong s);
• Đối với cchúng tôi vòng lặp từ sđến length.

(cả ba vòng đều độc quyền 0 chỉ mục)

Röda , 82 byte

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

Hãy thử trực tuyến!

Giải trình:

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 byte

([...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)

Hàm r cắt chuỗi dựa trên tham số b và e, sau đó tính tổng các chữ số và trả về giá trị.

Để cắt theo kích thước chính xác, chúng tôi chia chiều dài cho 3 và làm tròn kết quả. Gọi lát cắt (0, kết quả) cung cấp cho chúng tôi khối đầu tiên, lát cắt (kết quả, -result) cung cấp cho chúng tôi khối thứ hai và lát cắt (kết quả) cung cấp cho chúng tôi khối cuối cùng. Do cách tôi gọi lát cắt, tôi đã sử dụng lát cắt (kết quả, kết quả 4 *) thay vì lát cuối cùng nhưng nó cho kết quả tương tự.

Cuối cùng, tôi so sánh kết quả cho thấy các giá trị bằng nhau.

Chỉnh sửa: cùng nguyên tắc, chơi golf tốt hơn