: 다수이므로 숫자의 각각 절반의 숫자의 합이 동일한 경우 균형 1423때문에 균형 1+4 = 2+3그렇다 : 42615때문에 4+2=1+5. 홀수의 자릿수가있는 경우 중간 자릿수는 양쪽에 포함되지 않습니다 (또는 양쪽에 포함됨).

도전:

양의 정수를 입력으로 사용하고, 균형이 맞으면 참 값을, 불균형이 아니면 거짓 값을 출력합니다.

테스트 사례 (true)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

테스트 사례 (false)

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

예를 들어 00032대신 0으로 시작하는 숫자는 없습니다 32. 최대 100 자리 숫자 이상을 지원해야합니다 (보다 큼 2^64-1). 항상 그렇듯이 선택적 입력 형식이므로 원하는 경우 숫자를 아포스트로피로 둘러 쌀 수 있습니다.

05AB1E , 14 7 바이트

€D2äO`Q

설명

사용하여 141을 예를 들어 :

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

온라인으로 사용해보십시오!

> <> , 31 29 바이트

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

온라인으로 사용해보십시오!

라인 1 : 표준 입력 루프

2 행 : 스택 상단에 -1을 버리고 2 개의 0을 밀고 1 번 스택 맨 아래로 회전합니다 (이는 길이가 <3 인 입력이 나중에 프로그램에서 스택을 소모하지 않도록합니다)

3 행 : 스택의 길이가 3보다 크면 스택의 맨 위 두 개와 맨 아래 두 개 요소를 함께 추가하십시오.

4 행 : 스택의 상단과 하단이 같으면 1을, 그렇지 않으면 0을 출력합니다.

편집 : 문자 12, 2 바이트를 저장할 필요가 없다는 것을 깨달았습니다.

하스켈, 64 63 바이트

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

nimi 덕분에 1 바이트 절약

Brachylog , 20 바이트

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

온라인으로 사용해보십시오!

설명

@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

자바, 85 바이트

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

참고 : StringJava없이 처리 할 수 ​​없으므로 입력이 제공됩니다 BigInteger( BigIntegers는 a ...을 사용하여 구성 String됩니다).

테스트 및 ungolfed :

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

매스 매 티카, 57 바이트

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

설명

나는이 접근법을 어떤 언어로 사용할 수 있기를 정말로 기대하고 있었고 Mathematica에서 상당히 잘하고있는 것처럼 보입니다. 아이디어는 목록을 역방향과 결합 하고 앞쪽 만 보고만하여 앞면과 뒷면을 모두 얻지 않아도됩니다 .

...&@*IntegerDigits

먼저 입력을 10 진수 목록으로 바꾸고 결과를 왼쪽의 명명되지 않은 함수로 전달합니다.

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

이제리스트 자체에서리스트의 반대를 빼십시오. 숫자가 숫자 이면 결과는입니다 .{a1,a2,...,an}{a1-an,a2-an-1,...,an-a1}

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

이 목록의 전반부를 추출합니다 (중간 숫자는 제외하지만 실제로는 중요하지 않습니다. 해당하는 차이가 0어쨌든 있기 때문 입니다).

Tr@...

그리고 우리는이 목록을 요약합니다. 그래서 그건:

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

재정렬 :

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

두 반쪽의 합계가 같으면 입력 균형이 조정됩니다. 따라서 입력이 균형을 이루면이 표현식은 0입니다. 이것이 우리가 확인하는 것입니다.

...==0

자바 스크립트 (ES6), 59 55 51 44 42 바이트

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

내가 잘못된 전략을 완전히 사용하고있는 것으로 나타났습니다. 이 버전은 전반의 합계에서 후반의 합계를 뺀 값을 재귀 적으로 찾은 다음 결과의 논리 NOT을 반환합니다.

만약 우리가 진실 대신 거짓을 반환한다면, 이것은 35 바이트 일 것입니다 :

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

테스트 스 니펫

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 바이트

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

입력 $a을 문자열로 취 합니다 ( 명령 행에서 >2^64-1매우 번거로운 [biginteger]캐스팅을 하지 않고 숫자를 지원해야 함 ).

설명을 위해의 입력을 가정 해 봅시다 '1423'. 그런 다음 새 문자열을 구성합니다. 두 배열 슬라이스 (분명 $a[...]), 그리고이 세 개의 추가 문자열에 의해 둘러싸여 (, 0)-(및 0)배열 수립, chars와 string들. 를 참고 ,배열 연결하지 문자열 연결을 적용 할 앞에.

즉, 전체 배열이되어 -join함께 에드 +같은 문자열의 결과로 (+1+4+0)-(+2+3+0), 당신은 볼 수 0의이 구문 오류를 방지하기 위해 필요하다. 수학 결과를 계산하는 |iex(의 줄임말 Invoke-Expression과 비슷한 eval) 피드에 들어갑니다 . 문자열이 균형 잡힌 0한 출력으로 얻을 수 있습니다. 출력으로, 우리는 parens로 캡슐화하고 Boolean-not을 가져 와서 !(...)출력 True합니다. 0이 아닌 정수이면을 출력 False합니다.

테스트 사례

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

펄, 29 바이트

에 +5 포함 -lpF

STDIN에 번호를 줘

balanced.pl <<< 1423

balanced.pl:

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

C #, 83 바이트

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

온라인으로 사용해보십시오!

테스트 케이스를 포함한 전체 소스 :

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

BigInteger 데이터 유형은 임의의 숫자 길이를 허용합니다. 숫자가 너무 크면 컴파일러에서 오류가 발생 하고 ( 오류 CS1021 : 정수가 너무 큼 ) BigInteger.Parse (String) 메소드가 대신 사용됩니다.

입력이 문자열이고 그에 따라 프로그램을 업데이트하면 솔루션을 실제로 72 바이트 로 줄일 수 있습니다 .

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

파이썬 (3), 107 (102) 76 바이트

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

@Rod에 의해 -26 바이트 !

루비, 63 바이트

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

참고 : arg s는 문자열이어야합니다.

테스트 (최소 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

하스켈, 55 바이트

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

재귀 함수 g는 머리를 반복적으로 가져간 다음 뒤집어서 숫자 문자열을 양쪽 끝에서 풉니 다. 헤드에서 재귀 결과를 빼면 +1과 -1의 교대 계수가 발생하며, +1은 전반과 -1이 후반에 적용됩니다.

   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

따라서 상반기의 합계에서 하반기의 합계를 뺍니다. 홀수 자릿수를 사용하면 가운데 순위가 왼쪽으로 바뀌지 만 주 함수는를 수정하여 (<*"xx")모든 문자를 두 배로 늘립니다. 즉 "12345"는 "1122334455"가됩니다. 이렇게하면 가운데 숫자가 양쪽에서 고르게 분리되어 취소됩니다.

레티 나, 64 44 바이트

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

온라인으로 사용해보십시오

존재하는 경우 첫 번째 단계는 중간 문자를 생략, 중간에 문자열을 분할 ( 에서 가져온 수정 여기 . 마틴 씨.) 그런 다음, 자신의 단항 표현과 함께 자리를 대체하고, 두 부분이 동일한 길이의 경우 일치합니다.

자바 스크립트 (ES6), 74 67 ... 59 50 바이트

두 자리 미만이 남을 때까지 첫 번째 숫자와 마지막 숫자의 차이를 재귀 적으로 합산합니다.

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 바이트

R은 매우 장황하다. 문자를 입력으로받습니다.

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

멋지게 포맷 :

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

설명

• y<-as.numeric(unlist(strsplit(x,""))) 입력 (string_)을 분할하고 목록 대신 벡터로 강제 변환 한 다음 다시 정수로 바꿉니다.
• sum(tail(y,: tail마지막 n 개의 요소를 가져옵니다 .
  • length(y)%/%2)), %/%정수 나누기, 길이가 홀수 인 몫의 천장을 가져옵니다.
• sum(head(y,length(y)%/%2)): 추천 tail, head제 얻어 n 개의 동일한 방식으로 발견 벡터의 요소.

편집

• Niam 덕분에 7 바이트 절약
• =대신로 전환하여 <-다른 2 바이트를 저장했습니다.

뇌 플랙 , 410 206 204 178 + 3 = 181 바이트

다음은 -a플래그 를 사용하는 178 바이트 버전입니다 .

DJMcMayhem에 의해 26 바이트 골프 오프

온라인으로 사용해보십시오

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

다음은 -a플래그를 사용하지 않는 더 긴 410 바이트 버전입니다 .

온라인으로 사용해보십시오

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

설명

더 짧은 해결책에 대한 설명은 다음과 같습니다.

시작하기 위해 숫자는 -a플래그에 의해 모든 ASCII 값으로 변환됩니다 .

스택 높이 (예 : 자릿수)를 밀고 2로 나눕니다.

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

우리가 방금 누른 숫자보다 작은 각 숫자에 대해 숫자를 다른 스택으로 옮깁니다.

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

스택의 높이가 다른 경우 현재 스택에서 맨 위 항목을 제거합니다

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

각 스택의 합계 간의 차이를 원합니다. 따라서 다음 알고리즘을 사용하여 각 스택을 합산합니다.

{{}}

이것은 어떤 숫자도 ASCII 값이 0이 아니라고 가정합니다. 이는 유효한 가정입니다.

우리는 두 스택 모두에서 이것을 실행하고 차이점을 취합니다 ( <(())>다음 부분에 필요합니다).

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

이제 합계를 무효화하고 싶습니다. 합계가 0이면 상단에서 튀어 나와서 이전에 누른 것을 표시합니다. 그렇지 않으면 숫자와 1을 모두 제거하고 상단에 0을 배치합니다.

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

실제로 17 16 바이트

이 답변은 ElPedro의 Python 2 답변 과 사용 아이디어에서 영감을 얻었습니다 [-b:]. 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

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

언 골핑

      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.

펄 6 ,  42 39  33 바이트

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

그것을 테스트

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

그것을 테스트

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

그것을 시험하십시오 ^{_{( Jo King에서 )}}

설명:

{ # 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
}

자바 스크립트, 73 바이트

좋은 ol 'ES5 루프

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

여기서 무슨 일이야?

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

파이썬 2, 73 바이트

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

테스트는 아이디어입니다

서명 된 int의 범위를 벗어날 수 있기 str()때문에``대신 사용해야 n합니다.

파이썬 2, 83 77 바이트

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

편집하다

@Rod의 도움으로 77로 줄었습니다.

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

예 :

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 바이트

음수 문자열 오프셋에 PHP 7.1이 필요합니다.

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

운영:

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

이전 버전

참고 : 우주선 연산자에는 PHP 7이 필요합니다.

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

다음과 같이 실행하십시오.

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

설명

숫자의 숫자를 반복합니다. 숫자의 색인을 입력과 비교 한 비교 길이 ()를 비교하여 숫자가 전반 또는 후반 (또는 중간 숫자)에 속하는지 확인합니다 2 * $x <=> $l - 1. 그런 다음 숫자와 곱하면 모든 숫자의 합을 가져옵니다. 균형이 맞으면 합은입니다 0.

입력 예 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

조정

• 숫자를로 설정하지 말고 $d입력 길이를 반복하십시오. 5 바이트를 절약했습니다.
• PHP가로 해석 null하기 int위해 문자열 오프셋을 캐스트 할 필요 는 없습니다 0. 1 바이트를 저장했습니다.
• 음수 문자열 오프셋을 사용하여 후반에서 숫자를 가져오고 문자열의 절반으로 반복합니다. 7 바이트 저장, PHP 7.1 필요
• 를 사용하여 3 바이트를 절약했습니다 $argn

클로저, 66 64 바이트

업데이트 : 기능 str에서 벗어났습니다 map int.

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

입력 형식이 더 융통성이 있다면 이것은 단축되었을 것입니다. 이제 정수를 ASCII 값 시퀀스에 먼저 매핑해야했습니다. 내부 map는 두 반쪽에서 값의 쌍별 차이를 계산하고 델타의 합이 0인지 확인합니다.

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

실제로 이것은 단지 내에서 매핑을 수행하는 것과 동일한 길이 let이며 단일 함수를 정의합니다.

sed (165 + 1 -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

출력 :
true의 경우
1, false의 경우 0

온라인으로 사용해보십시오!

파이썬 2.7, 102 92 바이트

For 루프가 더 잘 작동합니다 : /

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

같은 생각, 길이를 사용하면 다른 쪽을 얻을 수 있습니다. 홀수의 중심에는 절대 도달하지 않습니다.

이전 코드

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:])

가져옵니다 입력은
입력의 길이를 저장
문자열의 합이 얻을 재귀의 FUNC를
하반기 합계로 상반기의 합을 비교

100 미만으로 얻으려고하지만 어렵습니다.

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

이데온

라켓 204 바이트

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

자세한 버전 :

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

테스트 :

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

산출:

#t
#t
#f
#f

파이크, 20 바이트

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

여기 사용해보십시오!

매스 매 티카, 69

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