Một số được cân bằng nếu tổng các chữ số trên mỗi nửa của số đó bằng nhau, vì vậy: 1423được cân bằng bởi vì 1+4 = 2+3, vì vậy là: 42615bởi vì 4+2=1+5. Lưu ý rằng chữ số ở giữa không được bao gồm ở hai bên (hoặc nó được bao gồm ở cả hai bên) nếu có một số chữ số lẻ.

Thử thách:

Lấy một số nguyên dương làm đầu vào và xuất giá trị trung thực nếu nó cân bằng và giá trị giả nếu nó không cân bằng.

Các trường hợp thử nghiệm (đúng)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

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

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

Chẳng hạn, sẽ không có số bắt đầu bằng 0 00032thay vì 32. Bạn phải hỗ trợ các số có ít nhất 100 chữ số (lớn hơn 2^64-1). Như mọi khi, định dạng đầu vào tùy chọn, do đó bạn có thể bao quanh số có dấu nháy đơn nếu muốn.

05AB1E , 14 7 byte

€D2äO`Q

Giải trình

Sử dụng 141 làm ví dụ:

€D       # duplicate each (turns the number into a list of digits)
         # STACK: ['1','1','4','4','1','1']
  2ä     # split list in 2 (as we duplicated each element, 
         # the middle element will exist on both sides for an odd length input
         # STACK: [['1','1','4'],['4','1','1']]
    O    # sum each sublist
         # STACK: [6,6]
     `   # flatten
         # STACK: 6, 6
      Q  # compare for equality
         # STACK: 1 (true)

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

> <> , 31 29 byte

i:0(?v
~00}v>
v+r+>l4(?
>{=n;

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

Dòng 1: Vòng lặp đầu vào tiêu chuẩn

Dòng 2: Loại bỏ -1 trên đỉnh của ngăn xếp, đẩy hai 0 và xoay một xuống dưới cùng của ngăn xếp (điều này đảm bảo rằng các đầu vào có độ dài <3 không làm cạn kiệt ngăn xếp sau trong chương trình)

Dòng 3: Nếu chiều dài của ngăn xếp> 3, hãy thêm hai phần tử trên cùng và hai phần dưới cùng của ngăn xếp lại với nhau.

Dòng 4: Nếu trên cùng và dưới cùng của ngăn xếp bằng nhau, đầu ra 1, 0 nếu không.

Chỉnh sửa: nhận ra rằng không cần phải lấy các ký tự mod 12, lưu 2 byte

Haskell, 64 63 byte

b(a:t@(r:s))=a-last t+b(init t);b _=0
(==0).b.map fromEnum.show

Một Byte được lưu nhờ vào nimi

Brachylog , 20 byte

@eL@2tM,Lr@2t:M:+a#=

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

Giải trình

@eL                    Get the list of digits L of the input
  L@2tM,               Get the second half M of L
        Lr@2t          Get the second half of the reverse of L
             :M        The list [L, M]
               :+a#=   The sum of elements of L and the sum of elements of M must be equal

Java, 85 byte

n->{int s=0,i=0,l=n.length();for(;i<l/2;)s+=n.charAt(i)-n.charAt(l-++i);return s==0;}

Lưu ý: đầu vào được đưa ra dưới Stringdạng Java không thể xử lý mà không có BigInteger(và BigIntegers được xây dựng bằng cách sử dụng .... String)

Kiểm tra và không được phép:

import java.util.function.Predicate;

public class Main {

  public static void main(String[] args) {
    Predicate<String> f = n -> {
      int s = 0, i = 0, l = n.length();
      for (; i < l / 2;) {
        s += n.charAt(i) - n.charAt(l - ++i);
      }
      return s == 0;
    };

    String[] truthies = {"1",
      "6",
      "11",
      "141",
      "23281453796004414",
      "523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088"};
    for (String s : truthies) {
      boolean result = f.test(s);
      System.out.println(result);
    }
    String[] falsies = {"10",
      "12",
      "110",
      "15421",
      "5234095123508321",
      "6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454"};
    for (String s : falsies) {
      boolean result = f.test(s);
      System.out.println(result);
    }
  }
}

Toán học, 57 byte

Tr@(#-Reverse@#)[[;;⌊Length@#/2⌋]]==0&@*IntegerDigits

Giải trình

Tôi đã thực sự hy vọng tôi có thể sử dụng phương pháp này trong một số ngôn ngữ và dường như nó đang hoạt động khá tốt trong Mathicala. Ý tưởng là để tránh phải có được cả nửa trước và nửa sau bằng cách kết hợp danh sách với mặt sau của nó và chỉ nhìn vào nửa trước.

...&@*IntegerDigits

Đầu tiên, chúng ta biến đầu vào thành một danh sách các chữ số thập phân và chuyển kết quả cho hàm không tên ở bên trái.

...(#-Reverse@#)...

Bây giờ chúng tôi trừ đi sự đảo ngược của danh sách từ chính danh sách. Nếu các chữ số là kết quả sẽ được .{a1,a2,...,an}{a1-an,a2-an-1,...,an-a1}

...[[;;⌊Length@#/2⌋]]

Chúng tôi trích xuất nửa đầu của danh sách này (không bao gồm chữ số ở giữa mặc dù điều đó không thực sự quan trọng, bởi vì sự khác biệt tương ứng sẽ là 0dù sao).

Tr@...

Và sau đó chúng tôi tổng hợp danh sách này. Vậy đó là:

a1 - an + a2 - an-1 + ... + a⌊n/2⌋ - a⌈n/2⌉+1

Sắp xếp lại:

a1 + a2 + ... + a⌊n/2⌋ - (a⌈n/2⌉+1 + ... + an-1 + an)

Đầu vào được cân bằng nếu hai nửa có cùng một tổng. Do đó, biểu thức này bằng không nếu đầu vào được cân bằng. Vì vậy, đó là những gì chúng tôi kiểm tra:

...==0

JavaScript (ES6), 59 55 51 44 42 byte

f=([x,...a],n=0)=>a[0]?f(a,x-a.pop()+n):!n

Hóa ra tôi đã sử dụng chiến lược sai hoàn toàn. Phiên bản này đệ quy tìm tổng của nửa đầu trừ đi tổng của nửa sau, sau đó trả về logic KHÔNG của kết quả.

Nếu chúng ta có thể trả lại sai lệch thay cho sự thật và ngược lại, đây sẽ là 35 byte:

f=([x,...a])=>a[0]?x-a.pop()+f(a):0

Kiểm tra đoạn

f=([x,...a],n=0)=>a[0]?f(a,x-a.pop()+n):!n

<input id=I value="23281453796004414"><br>
<button onclick="console.log(`Result of f(${I.value}): `+f(I.value))">Run</button>

PowerShell v2 +, 85 byte

param($a)!((,'('+$a[0..(($b=$a.length)/2-1)]+'0)-('+$a[($b/2)..$b]+'0)')-join'+'|iex)

Lấy đầu vào $adưới dạng một chuỗi (cần thiết để hỗ trợ các số >2^64-1mà không cần phải nhập vào cực kỳ khó hiểu [biginteger]trên dòng lệnh).

Để giải thích, hãy giả sử đầu vào của '1423'. Chúng tôi đang xây dựng một chuỗi mới. Hai mảng lát là hiển nhiên ( $a[...]), và được bao quanh bởi ba chuỗi thêm (, 0)-(và 0)xây dựng một loạt các chars và strings. Lưu ý ,ở phía trước để thực thi nối mảng, không nối chuỗi.

Toàn bộ mảng đó được -joinbiên cùng với +, dẫn đến một chuỗi như (+1+4+0)-(+2+3+0)và bạn có thể thấy rằng các 0s là cần thiết để ngăn ngừa lỗi cú pháp. Điều đó được đưa vào |iex(viết tắt Invoke-Expressionvà tương tự eval), sẽ tính kết quả toán học. Miễn là chuỗi được cân bằng, bạn sẽ nhận được 0như một đầu ra, mà chúng ta gói gọn trong các parens và lấy Boolean - không phải chuỗi đó !(...), để đầu ra True. Nếu đó là bất kỳ số nguyên khác không, nó sẽ xuất ra False.

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

PS C:\Tools\Scripts\golfing> '1','6','11','141','23281453796004414','523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088'|%{$_;.\is-it-a-balanced-number.ps1 $_;'---'}
1
True
---
6
True
---
11
True
---
141
True
---
23281453796004414
True
---
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088
True
---

PS C:\Tools\Scripts\golfing> '10','110','15421','5234095123508321','6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454'|%{$_;.\is-it-a-balanced-number.ps1 $_;'---'}
10
False
---
110
False
---
15421
False
---
5234095123508321
False
---
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454
False
---

Perl, 29 byte

Bao gồm +5 cho -lpF

Cho số trên STDIN

balanced.pl <<< 1423

balanced.pl:

#!/usr/bin/perl -lpF
$;+=$_-pop@F for@F;$_=!$

C #, 83 byte

n=>{var t=n+"";int l=t.Length,i=0,r=0;for(;i<l/2;)r+=t[i]-t[l-1-i++];return r==0;};

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

Nguồn đầy đủ, bao gồm cả trường hợp thử nghiệm:

using System;
using System.Numerics;

namespace BalancedNumber
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<BigInteger,bool>s= n=>{var t=n+"";int l=t.Length,i=0,r=0;for(;i<l/2;)r+=t[i]-t[l-1-i++];return r==0;};

            Console.WriteLine(s(1));    //true
            Console.WriteLine(s(6));    //true
            Console.WriteLine(s(11));   //true
            Console.WriteLine(s(141));  //true
            Console.WriteLine(s(23281453796004414));    //true
            BigInteger bi = BigInteger.Parse("523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088");
            Console.WriteLine(s(bi));   //true
            Console.WriteLine(s(10));   //false
            Console.WriteLine(s(12));   //false
            Console.WriteLine(s(110));  //false
            Console.WriteLine(s(15421));    //false
            Console.WriteLine(s(5234095123508321)); //false
            bi = BigInteger.Parse("6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454");
            Console.WriteLine(s(bi));   //false
        }
    }
}

Kiểu dữ liệu BigInteger cho phép bất kỳ độ dài số. Nếu số lượng quá lớn, trình biên dịch sẽ phàn nàn ( lỗi CS1021: Hằng số tích phân quá lớn ), vì vậy phương thức BigInteger.Pude (String) được sử dụng thay thế.

Giải pháp thực sự có thể được giảm xuống 72 byte khi xem đầu vào là một chuỗi (và cập nhật chương trình tương ứng):

t=>{int l=t.Length,i=0,r=0;for(;i<l/2;)r+=t[i]-t[l-1-i++];return r==0;};

Python 3, 107 102 76 byte

n=input()
l=len(n)
print(sum(map(int,n[:l//2]))==sum(map(int,n[l//2+l%2:])))

-26 byte bởi @Rod !

Ruby, 63 byte

->s{e=s.chars*?+
l=s.size
e[l-1-r=l%2,2*r+1]="=="
l<2||eval(e)}

Lưu ý: arg sphải là chuỗi.

Kiểm tra (yêu cầu tối thiểu 5+):

require 'minitest/autorun'

class TestRunner < Minitest::Test
  def setup
    @truthy_nums = %w(1 6 11 141 23281453796004414 523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088)
    @falsy_nums = %w(10 110 15421 5234095123508321 6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454)

@f=->s{e=s.chars*?+
l=s.size
e[l-1-r=l%2,2*r+1]="=="
l<2||eval(e)}

  end
  def test_true
    @truthy_nums.each do |e|
      assert @f[e], e
    end
  end
  def test_false
    @falsy_nums.each do |e|
      assert !@f[e], e
    end
  end
end

Haskell, 55 byte

g(h:t)=read[h]-g(reverse t)
g _=0
(==0).g.(<*"xx").show

Hàm đệ quy gmở ra một chuỗi số từ cả hai đầu bằng cách liên tục lấy đầu, sau đó đảo ngược. Nó trừ kết quả đệ quy từ phần đầu, điều này khiến cho các hệ số thay thế của +1 và -1, với +1 được áp dụng cho nửa đầu và -1 cho nửa sau.

   g "12345" 
== 1 - g "5432"
== 1 - (5 - g "432")
== 1 - (5 - (4 - g "32"))
== 1 - (5 - (4 - (3 - g "2"))
== 1 - (5 - (4 - (3 - 2))
== 1 + 2 + 3 - 4 - 5

Vì vậy, nó lấy tổng của nửa đầu trừ đi tổng của nửa sau. Điều này có một vấn đề là với một số chữ số lẻ, trung tâm bẻ sang trái, nhưng chức năng chính khắc phục điều đó bằng cách nhân (<*"xx")đôi mọi ký tự, tức là "12345" trở thành "1122334455". Bằng cách đó, chữ số ở giữa chia đều cho cả hai bên và hủy bỏ.

Võng mạc, 64 44 byte

^((.)*?).?(?=(?<-2>.)*$)
$1 
\d
$*
^(1+) \1$

Dùng thử trực tuyến

Giai đoạn đầu tiên phân tách chuỗi ở giữa, bỏ qua ký tự ở giữa nếu có một ( được lấy và sửa đổi từ đây . Phép lịch sự của Martin.) Sau đó, thay thế các chữ số bằng biểu diễn đơn nhất của chúng và khớp nếu hai nửa có độ dài bằng nhau.

JavaScript (ES6), 74 67 ... 59 50 byte

Tổng hợp đệ quy sự khác biệt của các chữ số đầu tiên và cuối cùng cho đến khi chỉ còn ít hơn hai chữ số:

let f =

n=>!(F=n=>n[1]?(n.pop()-n.shift()+F(n)):0)([...n])

// some truthy examples
console.log(f("11"));
console.log(f("141"));
console.log(f("523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088"));

// some falsy examples
console.log(f("12"));
console.log(f("110"));
console.log(f("6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454"));

R, 105 96 byte

Hóa ra R rất dài dòng. Lấy đầu vào là một ký tự.

function(x){y<-as.numeric(unlist(strsplit(x,"")));l<-length(y)%/%2;sum(tail(y,l))==sum(head(y,l))}

Định dạng độc đáo:

function(x){
    y=as.numeric(unlist(strsplit(x,"")))
    l=length(y)%/%2
    sum(tail(y,l))==sum(head(y,l))
}

Giải trình

• y<-as.numeric(unlist(strsplit(x,""))) Tách đầu vào (một chuỗi_ và ép nó thành một vectơ thay vì danh sách, sau đó biến nó trở lại thành số nguyên.
• sum(tail(y,: taillấy n phần tử cuối cùng , được tìm thấy bởi:
  • length(y)%/%2)), trong đó %/%là phép chia số nguyên, để lấy trần của thương số, trong đó độ dài là số lẻ.
• sum(head(y,length(y)%/%2)): like tail, headlấy n phần tử đầu tiên của vectơ, được tìm thấy theo cùng một cách.

Chỉnh sửa

• Đã lưu bảy byte nhờ niam
• Chuyển sang =thay vì <-, lưu hai byte khác.

Brain-Flak , 410 206 204 178 + 3 = 181 byte

Đây là một phiên bản 178 byte sử dụng -acờ.

26 byte được chơi bởi DJMcMayhem

Dùng thử trực tuyến

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

Đây là phiên bản 410 byte dài hơn không sử dụng -acờ.

Dùng thử trực tuyến

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

Giải trình

Dưới đây là một lời giải thích về giải pháp ngắn hơn

Để bắt đầu, số được chuyển đổi thành tất cả các giá trị ASCII của nó bằng -acờ.

Chúng tôi đẩy chiều cao ngăn xếp (tức là số chữ số) và chia cho hai.

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

Đối với mỗi số nhỏ hơn số chúng ta vừa đẩy, chúng ta di chuyển một chữ số sang ngăn xếp khác

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

Nếu ngăn xếp có chiều cao khác nhau, chúng tôi sẽ xóa mục trên cùng khỏi ngăn xếp hiện tại

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

Chúng tôi muốn sự khác biệt giữa các khoản tiền của mỗi ngăn xếp. Vì vậy, chúng tôi sử dụng thuật toán sau để tổng hợp từng ngăn xếp.

{{}}

Giả định này không có chữ số nào có giá trị ASCII bằng 0, đây là giả định hợp lệ.

Chúng tôi chạy cái này cho cả hai ngăn xếp và lấy sự khác biệt (Điều <(())>cần thiết cho phần tiếp theo.

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

Bây giờ chúng tôi muốn phủ nhận số tiền. Nếu tổng bằng 0, nó sẽ bật lên trên cùng để lộ cái mà chúng ta đã đẩy trước đó nếu không nó sẽ xóa cả số và số và đặt số 0 lên trên cùng.

{{}{}((<>))}{}

Trên thực tế, 17 16 byte

Câu trả lời này được lấy cảm hứng từ câu trả lời Python 2 của ElPedro và ý tưởng của họ để sử dụng [-b:]. Gợi ý chơi golf chào mừng. Hãy thử trực tuyến!

$♂≈;l½L│±aHΣ)tΣ=

Ungolfing

      Implicit input n.
$♂≈   list(str(n)). This converts n to a list of n's digits.
;l    Duplicate the list of digits and get its length. Call it len.
½L    Push len//2.
│     This duplicates the stack.
        Stack: len//2, digit_list, len//2, digit_list
±     Negate the len//2 at TOS for later.
a     Invert the stack.
        Stack: digit_list, len//2, digit_list, -(len//2)
HΣ    Push digit_list[:len//2], then push its sum.
)     Rotate this first sum to BOS.
tΣ    Push digit_list[-(len//2):], then push its sum.
=     Check if those sums are equal.
      Implicit return.

Perl 6 ,  42 39  33 byte

{[==] .comb[{^($_/2),Int($_/2)..*}]>>.sum}

Kiểm tra nó

{[==] .comb[^(*/2),(*/2).Int..*]>>.sum}

Kiểm tra nó

{[==] .comb[^*/2,^*/2+*/2]>>.sum}

Kiểm tra nó ^{_{(từ Jo King )}}

Giải trình:

{ # lambda with implicit parameter ｢$_｣

  [==]                   # reduce the following using &infix:«==»

    .comb\               # split input into individual characters
    [                    # index into that using:

      # first half of the values (includes middle value)
      # ｢(0/2) ..^ (*/2)｣
      ^ * / 2,     

      # last half of the values (includes middle value)
      ^ * / 2            # same number of values as first half
        + * / 2          # shifted up by half

    ]\
    >>.sum               # sum each of the two halves separately
}

Javascript, 73 byte

Các vòng lặp ES5 tốt

for(a=c=0,b=(l=(s=prompt()).length)-1;a<~-l/2;c-=s[a++]-s[b--]);alert(!c)

Chuyện gì đang xảy ra ở đây vậy?

for(
    a=c=0,               // a = left digits of the number
                         // c = the result
    b=                   // b = right digits of number
        (l=              // l = length of number - 1
            (s=prompt()) // s = the number as input from user
        .length)-1; 

    a<~-l/2;             // while a < length of number / 2, rounded down (~-)

    c-=
        s[a++]           // c -= left digit
        -
        s[b--]           // c += right digit (because - and - == +)
 );
                         // for balanced numbers c should be 0
 alert(!c)               // 0 equals false in javascript, so output the opposite of c

Python 2, 73 byte

def f(n):x=map(int,str(n));d=len(x)/2;print sum(x[:d])==sum(x[-d:])or d<1

Các bài kiểm tra đang ở trạng thái bình thường

Chúng ta phải sử dụng str()chứ không phải là `` vì ncó thể nằm ngoài phạm vi của int đã ký.

Python 2, 83 77 byte

g=[int(h)for h in raw_input()];b=int(len(g)/2);print sum(g[:b])==sum(g[-b:])or b==0

CHỈNH SỬA

giảm xuống 77 với sự giúp đỡ từ @Rod

g=[int(h)for h in raw_input()];b=len(g)/2;print sum(g[:b])==sum(g[-b:])or b<1

Ví dụ:

D:\>bal.py
1
True

D:\>bal.py
6
True

D:\>bal.py
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088
True

D:\>bal.py
10
False

D:\>bal.py
110
False

D:\>bal.py
 6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454
False

PHP, 73 67 60 57 byte

Yêu cầu PHP 7.1 cho các chuỗi bù âm:

for(;2*$x<strlen($a=$argn);)$s+=$a[$x++]-$a[-$x];echo!$s;

Chạy:

echo 15324 | php -nR 'for(;2*$x<strlen($a=$argn);)$s+=$a[$x++]-$a[-$x];echo!$s;';echo

Phiên bản trước

Lưu ý: yêu cầu PHP 7 cho toán tử tàu vũ trụ.

for(;$x<$l=strlen($a=$argv[1]);)$s+=(2*$x<=>$l-1)*$a[$x++];echo!$s;

Chạy như thế này:

php -d error_reporting=30709 -r 'for(;$x<$l=strlen($a=$argv[1]);)$s+=(2*$x<=>$l-1)*$a[$x++];echo!$s;' -- 15324;echo

Giải trình

Lặp lại các chữ số trong số. Kiểm tra xem chữ số thuộc về nửa đầu hay nửa sau (hoặc là chữ số giữa) bằng cách so sánh chỉ số của chữ số với độ dài của đầu vào với so sánh kết hợp ( 2 * $x <=> $l - 1). Sau đó nhân số đó với chữ số, lấy tổng của tất cả các chữ số. Nếu đó là một số cân bằng, tổng sẽ là 0.

Ví dụ với đầu vào 15324:

  index     0  1  2  3  4 
  digit     1  5  3  2  4

  2*index   0  2  4  6  8
  length-1  4  4  4  4  4
  factor    1  1  0 -1 -1  # Result of the spaceship operator

  result    1  5  0 -2 -4
           --------------
  sum                   0

Tinh chỉnh

• Đừng đặt chữ số thành $d, chỉ lặp lại độ dài của đầu vào. Đã lưu 5 byte.
• Chuỗi offset nullkhông cần phải được sử dụng để intPHP diễn giải nó thành 0. Đã lưu 1 byte.
• Sử dụng offset chuỗi âm để lấy các chữ số từ nửa sau và lặp lại đến một nửa chuỗi. Đã lưu 7 byte, nhưng yêu cầu PHP 7.1
• Đã lưu 3 byte bằng cách sử dụng $argn

Clojure, 66 64 byte

Cập nhật: Lấy strra từ map intchức năng.

(comp #(=(apply +(map -(drop(/(count %)2)%)%))0)#(map int %)str)

Điều này sẽ được rút ngắn nếu định dạng đầu vào linh hoạt hơn, bây giờ trước tiên tôi phải ánh xạ số nguyên thành một chuỗi các giá trị ASCII. Giá trị bên trong maptính toán sự khác biệt theo cặp của các giá trị từ hai nửa và kiểm tra xem tổng của deltas có bằng không.

((comp f g h) x y z)= (f (g (h x y z)).

Trên thực tế, điều này cuối cùng có cùng độ dài với việc thực hiện ánh xạ trong một letvà chỉ xác định một hàm duy nhất.

sed (165 + 1 cho -r) 166

/^.$/c1
:l;s,^([^!])([^!]*)([^!])!?([^=]*)=?(.*),\2!\4\1=\5\3,;tl;:
s,.?!|0,,;s,2,11,;s,3,21,;s,4,31,;s,5,41,;s,6,51,;s,7,61,
s,8,71,;s,9,81,;t;s,1=1,=,;t;/^=$/c1
c0

Đầu ra:
1 cho đúng
0 cho sai

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

Python 2.7, 102 92 byte

Đối với vòng lặp hoạt động tốt hơn: /

s=`input()`
a,b,l=0,0,len(s)
for i in range(l/2):a=a+int(s[i]);b=b+int(s[l-i-1])
print a==b

Cùng một ý tưởng, chỉ cần sử dụng chiều dài - i để có được mặt khác. Nó sẽ không bao giờ đạt đến trung tâm của một số lẻ.

Mã cũ

s=input()
l=len(s)
def n(i):return 0if not i else int(i[0])+n(i[1:])
print n(s[:l/2])==n(s[l/2+l%2:])

Nhận đầu vào
Lưu độ dài của đầu vào
Func đệ quy để lấy tổng chuỗi
So sánh nửa đầu tiên với tổng nửa sau

Đang cố gắng để có được nó dưới 100, nhưng thật khó: /

Hàm C, 74

l;i;t;f(char *n){l=strlen(n);for(t=i=0;i<l/2;)t+=n[i]-n[l-++i];return !t;}

Ideone.

Vợt 204 byte

(define(f n)(let*((s(number->string n))(g(λ(x y)(apply +(map(λ(x)(string->number(string x)))
(string->list(substring s x y))))))(l(string-length s))(h(/ l 2)))(if(=(g 0(floor h))(g(ceiling h)l))#t #f)))

Phiên bản chi tiết:

(define (f1 n)
(let* (  (s (number->string n))
         (g(λ(x y)
              (apply + (map
                        (λ(x)
                          (string->number
                           (string x)))
                        (string->list
                         (substring s x y))))))
         (l (string-length s))
         (h (/ l 2)))
    (if(= (g 0 (floor h)) (g (ceiling h) l)) 
       #t #f  ) ) ) 

Kiểm tra:

(f 23281453796004414)
(f 523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088)
(f 15421)
(f 5234095123508321)

Đầu ra:

#t
#t
#f
#f

Pyke, 20 byte

[QleQ`)>[R<]mmbms$X!

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

Toán học, 69

Tr@#[[;;⌊l=Length@#/2⌋]]==Tr@#[[⌈l⌉+1;;]]&@*IntegerDigits