จำนวนจะมีความสมดุลถ้าผลรวมของตัวเลขในครึ่งหนึ่งของจำนวนในแต่ละที่เท่ากันดังนั้น: 1423จะมีความสมดุลเพราะ1+4 = 2+3เพื่อให้เป็น: เพราะ42615 4+2=1+5โปรดทราบว่าตัวเลขกลางไม่ได้รวมอยู่ในด้านใดด้านหนึ่ง (หรือมีทั้งสองด้าน) หากมีจำนวนหลักคี่

ท้าทาย:

ใช้จำนวนเต็มบวกเป็นอินพุทและเอาท์พุทค่าความจริงถ้ามันมีความสมดุลและเป็นค่าเท็จถ้ามันไม่สมดุล

กรณีทดสอบ (จริง)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

กรณีทดสอบ (เท็จ)

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

จะไม่มีตัวเลขเริ่มต้นด้วยการเป็นศูนย์ตัวอย่างแทน00032 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 ที่ด้านบนของสแต็กกดสอง 0 แล้วหมุนหนึ่งไปที่ด้านล่างของสแต็ก (เพื่อให้แน่ใจว่าอินพุตที่มีความยาว <3 ไม่หมดสแต็กในโปรแกรม)

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

บรรทัดที่ 4: หากด้านบนและด้านล่างของสแต็กเท่ากันเอาต์พุต 1, 0

แก้ไข: ตระหนักว่าไม่จำเป็นต้องใช้อักขระดัดแปลง 12, 2 ไบต์ที่บันทึกไว้

Haskell, 64 63 ไบต์

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

One Byte บันทึกแล้วขอบคุณ nimi

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

Java, 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 ถูกสร้างขึ้นโดยใช้ ... 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);
    }
  }
}

Mathematica, 57 ไบต์

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

คำอธิบาย

ฉันหวังว่าฉันจะสามารถใช้วิธีนี้ในบางภาษาและดูเหมือนว่าจะทำได้ค่อนข้างดีใน Mathematica ความคิดที่จะหลีกเลี่ยงที่จะได้รับทั้งด้านหน้าและครึ่งหลังโดยการรวมรายการที่มีการย้อนกลับและมองเฉพาะในช่วงครึ่งปีหน้า

...&@*IntegerDigits

ก่อนอื่นเราจะแปลงค่าให้เป็นรายการเลขทศนิยมและส่งผลลัพธ์ไปยังฟังก์ชันที่ไม่มีชื่อทางด้านซ้าย

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

JavaScript (ES6), 59 55 51 44 42 ไบต์

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

ปรากฎว่าฉันใช้กลยุทธ์ผิดทั้งหมด รุ่นนี้จะค้นหาผลรวมของครึ่งแรกด้วยการลบผลรวมของครึ่งหลังซ้ำแล้วส่งกลับค่าตรรกะของผลลัพธ์

หากเราสามารถคืนความเท็จแทนความจริงและในทางกลับกันก็จะเป็น 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]การร่ายของclunky มากในบรรทัดคำสั่ง)

'1423'สำหรับคำอธิบายที่สมมติใส่ของ เรากำลังสร้างสตริงใหม่ ทั้งสองชิ้นอาร์เรย์ที่เห็นได้ชัด ( $a[...]) และที่ล้อมรอบไปด้วยสามสตริงเพิ่มเติม(, 0)-(และ0)การสร้างสูตรอาร์เรย์ของcharและstrings โปรดสังเกต,ที่ด้านหน้าเพื่อบังคับใช้การต่อข้อมูลอาร์เรย์ไม่ใช่การต่อสตริง

อาเรย์ทั้งหมดนั้นถูก-joinรวมเข้าด้วยกัน+ส่งผลให้เกิดสตริงเหมือน(+1+4+0)-(+2+3+0)และคุณจะเห็นว่า0จำเป็นสำหรับการป้องกันข้อผิดพลาดทางไวยากรณ์ ที่ป้อนเข้า|iex(ย่อมาInvoke-Expressionและคล้ายกับeval) ซึ่งจะคำนวณผลลัพธ์ทางคณิตศาสตร์ ตราบใดที่สายจะมีความสมดุลคุณจะได้รับ0ในฐานะผู้ส่งออกซึ่งเราแค็ปซูลใน parens และใช้บูลีนไม่ดังกล่าวเพื่อการส่งออก!(...) ถ้าเป็นจำนวนเต็มไม่ใช่ศูนย์ก็จะเอาท์พุทTrueFalse

กรณีทดสอบ

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

รวมถึง +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;};

Python 3, 107 102 76 ไบต์

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

-26 ไบต์โดย@Rod !

ทับทิม, 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

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

ดังนั้นมันต้องใช้ผลรวมของครึ่งแรกลบด้วยผลรวมของครึ่งหลัง นี่เป็นปัญหาที่มีตัวเลขคี่เป็นจุดศูนย์กลาง tiebreaks ทางด้านซ้าย แต่ฟังก์ชันหลักจะแก้ไขโดย(<*"xx")ที่เพิ่มเป็นสองเท่าของอักขระทั้งหมดเช่น "12345" กลายเป็น "1122334455" ด้วยวิธีนี้ตัวเลขกลางจะแยกทั้งสองด้านเท่า ๆ กันและยกเลิกไป

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

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

ลองออนไลน์

ขั้นตอนแรกแยกสตริงกลางถนัดตัวอักษรกลางถ้ามีคน ( ถ่ายและการแก้ไขจากที่นี่ .มารยาทของมาร์ติน.) จากนั้นให้เปลี่ยนตัวเลขด้วยการเป็นตัวแทนเอกของพวกเขาและตรงกับถ้าทั้งสองส่วนมีความยาวเท่ากัน

JavaScript (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 เป็น verbose มาก รับอินพุตเป็นอักขระ

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,""))) แยกการป้อนข้อมูล (a string_, และบีบบังคับให้มันเป็นเวกเตอร์แทนรายการแล้วเปลี่ยนกลับเป็นจำนวนเต็ม
• sum(tail(y,: tailใช้องค์ประกอบnสุดท้ายที่พบโดย:
  • length(y)%/%2))ที่ซึ่ง%/%เป็นส่วนจำนวนเต็มเพื่อให้ได้เพดานของความฉลาดโดยที่ความยาวเป็นเลขคี่
• sum(head(y,length(y)%/%2)): เช่นtail, headเตะคนแรกที่nองค์ประกอบของเวกเตอร์ที่พบในทางเดียวกัน

การแก้ไข

• บันทึกเจ็ดไบต์ขอบคุณที่ niam
• เปลี่ยนเป็น=แทนที่จะ<-บันทึกอีกสองไบต์

Brain-Flak , 410 206 204 178 + 3 = 181 ไบต์

นี่คือรุ่น 178 ไบต์ที่ใช้-aแฟล็ก

26 ไบต์ตีกอล์ฟโดย DJMcMayhem

ลองออนไลน์

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

นี่คือ 410 ไบต์เวอร์ชันที่ยาวกว่าซึ่งไม่ได้ใช้-aแฟล็ก

ลองออนไลน์

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

คำอธิบาย

นี่คือคำอธิบายของวิธีแก้ปัญหาที่สั้นกว่า

ในการเริ่มต้นตัวเลขจะถูกแปลงเป็นค่า ASCII ทั้งหมดโดย-aแฟล็ก

เราเพิ่มความสูงของสแต็ก (เช่นจำนวนหลัก) และหารด้วยสอง

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

สำหรับแต่ละหมายเลขที่น้อยกว่าจำนวนที่เราเพิ่งผลักเราย้ายตัวเลขไปยังสแต็กอื่น

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

หากสแต็คมีความสูงต่างกันเราจะลบไอเท็มอันดับต้น ๆ ออกจากสแต็กปัจจุบัน

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

เราต้องการความแตกต่างระหว่างผลรวมของแต่ละสแต็ก ดังนั้นเราจึงใช้อัลกอริทึมต่อไปนี้เพื่อหาผลรวมของแต่ละสแต็ก

{{}}

สิ่งนี้ถือว่าไม่มีตัวเลขมีค่า ASCII เป็นศูนย์ซึ่งเป็นสมมติฐานที่ถูกต้อง

เราเรียกใช้สิ่งนี้สำหรับทั้งสแต็คและรับความแตกต่าง ( <(())>สิ่งที่จำเป็นสำหรับส่วนต่อไป

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

ตอนนี้เราต้องการที่จะลบล้างผลรวม หากผลรวมเป็นศูนย์มันจะปรากฏขึ้นด้านบนออกเผยให้เห็นหนึ่งที่เราผลักก่อนหน้านี้มิฉะนั้นมันจะลบทั้งจำนวนและหนึ่งและวางศูนย์บน

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

ที่จริงแล้ว17 16 ไบต์

คำตอบนี้เป็นแรงบันดาลใจElPedro ของงูหลาม 2 คำตอบ[-b:]และความคิดของพวกเขากับการใช้งาน ยินดีต้อนรับคำแนะนำการเล่นกอล์ฟ ลองออนไลน์!

$♂≈;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 ไบต์

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

ทดสอบมัน

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

ทดสอบมัน

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

ทดสอบ ^{_{(จากโจคิง )}}

คำอธิบาย:

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

ES5 olops ดี

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

Python 2, 73 ไบต์

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

การทดสอบอยู่ที่ideone

เราต้องใช้str()มากกว่า `` เนื่องจากnอาจอยู่นอกช่วงของการลงนาม int

Python 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

แก้ไข

ลดเหลือ 77 ด้วยความช่วยเหลือจาก @Rod

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 ไบต์
• String ชดเชยnullไม่ได้จะต้องมีการโยนไปintสำหรับ PHP 0ในการตีความว่ามันเป็น บันทึก 1 ไบต์
• การใช้สตริงเชิงลบชดเชยเพื่อรับตัวเลขจากครึ่งหลังและวนซ้ำเป็นครึ่งหนึ่งของสตริง บันทึกแล้ว 7 ไบต์ แต่ต้องใช้ PHP 7.1
• บันทึก 3 ไบต์โดยใช้ $argn

Clojure 66 66ไบต์

อัปเดต: นำstrออกจากmap intฟังก์ชั่น

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

สิ่งนี้จะสั้นลงถ้ารูปแบบการป้อนข้อมูลมีความยืดหยุ่นมากขึ้นตอนนี้ฉันต้องแมปจำนวนเต็มเป็นลำดับของค่า ASCII Inner จะmapคำนวณความแตกต่างของคู่ที่ชาญฉลาดจากสองครึ่งและตรวจสอบว่าผลรวมของ deltas เป็นศูนย์หรือไม่

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

เอาต์พุต:
1 สำหรับจริง
0 สำหรับเท็จ

ลองออนไลน์!

Python 2.7, 102 92 ไบต์

สำหรับวงทำงานได้ดีขึ้น: /

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

แนวคิดเดียวกันใช้ความยาว - i เพื่อให้ได้ด้านอื่น ๆ มันจะไม่ถึงจุดศูนย์กลางของจำนวนคี่

รหัสเก่า

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

Ideone

แร็กเก็ต 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

Pyke ขนาด 20 ไบต์

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

ลองที่นี่!

Mathematica, 69

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