38

একটি সংখ্যার ভারসাম্য হয় যদি সংখ্যার প্রতিটি অর্ধের উপরের সংখ্যার যোগফল সমান হয়, সুতরাং: 1423সুষম কারণ কারণ 1+4 = 2+3, তাই: 42615কারণ 4+2=1+5। মনে রাখবেন যে মাঝারি সংখ্যাটি কোনও একক সংখ্যাতে (বা এটি উভয় পক্ষের অন্তর্ভুক্ত) এর সাথে অন্তর্ভুক্ত নয় if

চ্যালেঞ্জ:

ইনপুট হিসাবে ইতিবাচক পূর্ণসংখ্যার নিন এবং ভারসাম্যহীন হলে সত্যবাদী মান এবং যদি ভারসাম্যহীন হয় তবে মিথ্যা মান নির্ধারণ করুন।

পরীক্ষার কেস (সত্য)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

পরীক্ষার কেস (মিথ্যা)

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

শূন্য দিয়ে আরম্ভের সংখ্যা থাকবে না, উদাহরণস্বরূপ 00032পরিবর্তে 32। আপনার অবশ্যই কমপক্ষে 100 টি সংখ্যা পর্যন্ত সংখ্যাকে সমর্থন করতে হবে (এর চেয়ে বড় 2^64-1)। সর্বদা হিসাবে, inputচ্ছিক ইনপুট ফর্ম্যাট, যাতে আপনি ইচ্ছা থাকলে অ্যাডাস্ট্রোফসের সাহায্যে নম্বরটি ঘিরে রাখতে পারেন।

code-golf number

— স্টিও গ্রিফিন
সূত্র

12

05 এ বি 1 ই , 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)

এটি অনলাইন চেষ্টা করুন!

— Emigna
সূত্র

আপনি কি Ëপরিবর্তে ব্যবহার করতে পারবেন না `Q?

— এরিক আউটগল্ফার

@ এরিকথ আউটগল্ফার: Ëযখন এই চ্যালেঞ্জটি হয়েছিল তখন এটি আলাদা কমান্ড ছিল, তাই দুর্ভাগ্যক্রমে নয়।

— Emigna

10

> <> , 31 29 বাইট

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

এটি অনলাইন চেষ্টা করুন!

লাইন 1: স্ট্যান্ডার্ড ইনপুট লুপ

লাইন 2: স্ট্যাকের শীর্ষে -1 বাতিল করুন, দুটি 0 টি চাপুন এবং একটিটিকে স্ট্যাকের নীচে ঘোরান (এটি নিশ্চিত করে যে দৈর্ঘ্যের ইনপুটগুলি <3 প্রোগ্রামের পরে স্ট্যাকটি নিঃশেষ করবেন না)

লাইন 3: স্ট্যাকের দৈর্ঘ্য> 3 হলে, স্ট্যাকের উপরের দুটি এবং নীচে দুটি উপাদান যুক্ত করুন।

লাইন 4: স্ট্যাকের উপরের এবং নীচে সমান হলে অন্যথায় আউটপুট 1, 0।

সম্পাদনা: বুঝতে পেরেছি যে মোড 12, 2 বাইট সংরক্ষণ করা দরকার নেই

— সোক
সূত্র

7

Haskell,, 64 63 বাইট

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

এক বাইট সংরক্ষিত নিমিকে ধন্যবাদ

— ডেমিয়েন
সূত্র

স্নিপেটগুলির প্রথম বন্ধনী দরকার নেই?

— মাইকেল ক্লেইন

@ মাইকেল-ক্লেইন না, নামহীন ফাংশন অনুমোদিত। meta.codegolf.stackexchange.com/a/7615/20260

— ড্যামিয়েন

1

একটি বাইট সংরক্ষণ করুন:b(a:t@(r:s))=a-last t+b(init t);b _=0

— নিমি

@ নিমি ধন্যবাদ ...

— ড্যামিয়েন

5

ব্র্যাচল্যাগ , 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

— Fatalize
সূত্র

5

জাভা, 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;}

দ্রষ্টব্য: ইনপুটটি দেওয়া হয়েছে Stringযেমন জাভা হ্যান্ডেল করতে পারে না BigInteger(এবং এটি BigIntegerব্যবহার করে তৈরি করা হয় ...। String)

পরীক্ষা এবং নিরবচ্ছিন্ন:

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

— অলিভিয়ার গ্রাগোয়ার
সূত্র

চমৎকার উত্তর. আপনার জন্য-লুপ খালি করে 2 বাইট বাঁচাতে পারে: for (; i < l / 2;s += n.charAt(i) - n.charAt(l - ++i));।

— টডিল

@ টডিয়োল গল্ফড কোডটি দেখুন, অবলম্বনকারী কোডটি নয়। আমি মনে করি আপনার পরামর্শ এবং আমার গল্ফ উত্তরগুলি একই পরিমাণ বাইট ব্যবহার করে

— অলিভিয়ার

ওপস! এখন আমি দেখি.

— টডিল

5

গণিত, 57 বাইট

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

ব্যাখ্যা

আমি সত্যিই আশা করছিলাম যে আমি কিছুটা ভাষায় এই পদ্ধতির ব্যবহার করতে পারি, এবং এটি ম্যাথমেটিকায় মোটামুটি ভাল করছে বলে মনে হচ্ছে। ধারণাটি হ'ল তালিকার বিপরীতগুলির সাথে একত্রিত হয়ে এবং সামনের অর্ধেকটি কেবল তাকিয়ে সামনের এবং পিছনের অর্ধ উভয়টিই অর্জন করা এড়ানো to

...&@*IntegerDigits

প্রথমত, আমরা ইনপুটটিকে দশমিক অঙ্কের তালিকায় পরিণত করি এবং ফলাফলটি বামে নামহীন ফাংশনে পাস করি।

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

এখন আমরা তালিকাটি উল্টো থেকে তালিকা থেকে বিয়োগ করি। অঙ্কগুলি হয় তবে ফলাফল হবে ।{a₁,a₂,...,a_n}{a₁-a_n,a₂-a_n-1,...,a_n-a₁}

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

আমরা এই তালিকার প্রথম অর্ধেকটি বের করি (মাঝারি অঙ্কটি বাদ দিয়ে যদিও তা আসলে কিছু যায় আসে না, কারণ সংশ্লিষ্ট পার্থক্য 0যাইহোক হবে)।

Tr@...

এবং তারপর আমরা এই তালিকা যোগফল। তাই যে:

a₁ - a_n + a₂ - a_n-1 + ... + a_⌊n/2⌋ - a_⌈n/2⌉+1

পুনরায় সজ্জিত করা:

a₁ + a₂ + ... + a_⌊n/2⌋ - (a_⌈n/2⌉+1 + ... + a_n-1 + a_n)

দুটি অংশের সমান পরিমাণ থাকলে ইনপুটটি ভারসাম্যপূর্ণ। সুতরাং, ইনপুটটি ভারসাম্যপূর্ণ হলে এই অভিব্যক্তিটি শূন্য। সুতরাং আমরা যা যা পরীক্ষা করি:

...==0

— মার্টিন ইন্ডার
সূত্র

5

জাভাস্ক্রিপ্ট (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>

স্নিপেট প্রসারিত করুন

— ETHproductions
সূত্র

আমি সত্যিই এই পছন্দ n[i*2]! সুন্দর.

— আর্নল্ড

@ আর্নাউল্ড ধন্যবাদ :-) আমি এখন সম্পূর্ণ ভিন্ন পদ্ধতির সন্ধান পেয়েছি যা এর প্রয়োজন হয় না ...

— ETH প্রোডাকশনস

এখন, উজ্জ্বল!

— আর্নল্ড

আপনি ব্যবহার করতে পারবেন না f=([x,...a])=>!(a[0]?x-a.pop()+f(a):0)?

— mbomb007

@ mbomb007 নাহ; এটি একটি সংখ্যার পরিবর্তে প্রতিটি পুনরাবৃত্তির পরে একটি বুলিয়ান (0 বা 1 তে জোর করে) ফিরিয়ে দেবে।

— ETH প্রোডাকশনগুলি

4

পাওয়ারশেল ভি 2+, 85 বাইট

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

$aস্ট্রিং হিসাবে ইনপুট নেয় ( কমান্ড লাইনে >2^64-1চূড়ান্তভাবে castালাই না করে সংখ্যাগুলি সমর্থন করার জন্য প্রয়োজনীয় [biginteger])।

ব্যাখ্যার জন্য, এর ইনপুট ধরে নেওয়া যাক '1423'। তারপরে আমরা একটি নতুন স্ট্রিং তৈরি করছি। দুই অ্যারে টুকরা সুস্পষ্ট (হয় $a[...]), এবং তিনটি অতিরিক্ত স্ট্রিং দ্বারা বেষ্টিত এর (, 0)-(এবং 0), একটি অ্যারের প্রণয়ন chars এবং stringগুলি। ,অ্যারে কনটেনটেশন প্রয়োগের জন্য সামনের অংশটি নোট করুন , স্ট্রিং কনটেনটেশন নয়।

সেই পুরো অ্যারেটি -joinএকসাথে সম্পাদিত হয় +যার ফলস্বরূপ একটি স্ট্রিং হয় (+1+4+0)-(+2+3+0)এবং আপনি দেখতে পারেন যে 0বাক্য গঠন ত্রুটিগুলি রোধ করার জন্য প্রয়োজন। এটি খাওয়ানো হয়েছে |iex(এর সংক্ষিপ্ত Invoke-Expressionএবং অনুরূপ eval), যা গাণিতিক ফলাফলের গণনা করবে। তাই দীর্ঘ স্ট্রিং সুষম হয়, আপনি পাবেন 0একটি আউটপুট, যা আমরা ডান বন্ধনী মধ্যে encapsulate এবং তার বুলিয়ান-না নিতে হিসাবে !(...)আউটপুট, True। যদি এটি কোনও শূণ্য পূর্ণসংখ্যার হয় তবে তা আউটপুট দেয় 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
---

— AdmBorkBork
সূত্র

4

পার্ল, 29 বাইট

জন্য +5 অন্তর্ভুক্ত -lpF

STDIN এ নম্বর দিন

balanced.pl <<< 1423

balanced.pl:

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

— টন হসপেল
সূত্র

4

সি #, 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: ইন্টিগ্রাল ধ্রুবকটি খুব বড় ), সুতরাং বিগইন্টেজার . পার্স (স্ট্রিং) পদ্ধতিটি পরিবর্তে ব্যবহৃত হয়।

সমাধানটি আসলে ইনপুটটিকে স্ট্রিং হিসাবে বিবেচনা করে 72 বাইটে হ্রাস করা যেতে পারে (এবং সেই অনুযায়ী প্রোগ্রামটি আপডেট করা):

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

— adrianmp
সূত্র

1

অবাক হওয়ার মতো বিষয় নয়, আমার সি উত্তরটি এইটির সাথে মোটামুটি অনুরূপ দেখায়। আপনি কি এর t[l-++i]পরিবর্তে t[l-1-i++]এবং return !rপরিবর্তে করতে পারেন return r==0?

— ডিজিটাল ট্রমা

ইনক্রিমেন্ট অপারেটরের উপস্থাপনের কৌশলটি করা উচিত এবং 2 বাইট সংরক্ষণ করা উচিত, তবে সি # এ রিটার্ন মান অবশ্যই বুলিয়ান হতে হবে, সুতরাং এটি আর কাটবে না। ধন্যবাদ, আমি আমার উত্তরটি যত তাড়াতাড়ি সম্ভব আপডেট করব।

— এড্রিয়ান্প

4

পাইথন 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 বাইট @ রড !

— Yytsi
সূত্র

2

আপনি প্রতিস্থাপন করতে পারেন floor(l/2)সঙ্গে l//2এবং ceil(l/2)সঙ্গে l//2+l%27 বাইট সংরক্ষণ করতে, এবং তারপর গণিত আমদানি সরাতে, সংরক্ষণ আরো 18

— ডান্ডা

1

এছাড়াও আপনি প্রয়োজন হবে না 0উপর n[0:l//2]এবং n[l//2+l%2:]মাত্র হতে পারে n[-(l//2):]। অথবা আপনি সরাতে পারে //2থেকে l=len(n)//2এবং ব্যবহার n[:l]এবংn[-l:]

— ডান্ডা

5

আপনার আমদানি শীর্ষে না থাকলে এটিকেও সত্যই অদ্ভুত লাগে।

— mbomb007

@ রড আমি এখানে প্রথম মন্তব্যে উল্লিখিত সমস্ত জিনিস পরিবর্তন করতে এসেছি, কিন্তু দ্বিতীয়টি দেখে অবাক হয়েছি, অনেক ধন্যবাদ! :)

— ইয়াতসি

@ রড আপনার দ্বিতীয় মন্তব্যে আপনার শেষ টিপটি ব্যবহার করে, একক অঙ্কের টেস্টকেসগুলি মিথ্যা মানগুলি প্রত্যাবর্তন করে :(

— ইয়াতসি

4

রুবি, 63 বাইট

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

দ্রষ্টব্য: আরগ 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

— cia_rana
সূত্র

4

হাস্কেল, 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" হয়ে যায়। এইভাবে মাঝারি অঙ্কটি উভয় পক্ষের সমানভাবে বিভক্ত হয়ে যায় এবং বাতিল হয়ে যায়।

— xnor
সূত্র

3

রেটিনা, 64 44 বাইট

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

এটি অনলাইনে চেষ্টা করুন

প্রথম পর্যায়ের মাঝখানে স্ট্রিং splits, মধ্যম চরিত্র বাদ যদি কেউ থাকে ( ~~তোলা থেকে পরিবর্তিত এখানে ।~~ মার্টিন সৌজন্যে।) তারপর, তাদের ইউনারী উপস্থাপনা সঙ্গে ডিজিটের প্রতিস্থাপন, এবং ম্যাচ যদি দুটি অর্ধেক সমান দৈর্ঘ্যের হয়।

— mbomb007
সূত্র

আপনি কেন একটি কোড গল্ফে নন-ক্যাপচারিং গ্রুপ ব্যবহার করবেন? ;) নির্বিশেষে, .NET এ ভারসাম্য গ্রুপগুলির সাথে স্ট্রিং বিভক্ত করা অনেক ছোট: retina.tryitonline.net/… (আমি একাধিক পর্যায়ের চেষ্টাও করেছি তবে এটি কিছুটা দীর্ঘ retina.tryitonline.net/… ) সমাপ্ত হয় ।

— মার্টিন এেন্ডার

@ মার্টিন ইন্দ্রা হ্যাঁ, আমি জানতাম এটি হবে তবে আমি সত্যিই ধারণাটি কখনই ধরতে পারি নি। এবং আমি মনে করি আমি ক্যাপচারকারী দলটিকে উপেক্ষা করেছি।

— mbomb007

1

এটি এক্ষেত্রে সত্যই সহজ: আমরা অক্ষরগুলি গণনা করি (.)*?(প্রতিটি পুনরাবৃত্তি স্ট্যাক 2-তে একটি ক্যাপচার ঠেলে দেয়)। তারপরে আমরা স্ট্যাক থেকে আবার পপিংয়ের মাধ্যমে শেষ পর্যন্ত পৌঁছানোর চেষ্টা করি (?<-2>.)*$(middleচ্ছিক মাঝারি অঙ্কের পরে)। প্রথমবারের মতো এটি সম্ভব যখন আমরা ঠিক ২ টি গ্রুপে অর্ধেক অঙ্ক (গোল করে) ক্যাপচার করেছি

— মার্টিন এন্ডার

3

জাভাস্ক্রিপ্ট (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"));

স্নিপেট প্রসারিত করুন

— Arnauld
সূত্র

1

চমৎকার কৌশল। আমি মনে করি আপনি করতে পারেন (s-=i<0?v:-v)।

— ETH প্রোডাকশনগুলি

@ ইথ প্রডাকশনস - পদ্ধতিগুলি কীভাবে ঘনিষ্ঠ হয় এবং কী তা Math.sign()ঘুরে দেখা যায় না তা দেখার জন্য আকর্ষণীয়।

— আর্নাউল্ড

ডার্ন, আপনি আমাকে ভাল মারতে পারেন ... চমৎকার :)

— ETH প্রোডাকশনগুলি

আমি ভুল ছিল ;-)

— ETH প্রোডাকশনগুলি

3

আর, 105 96 বাইট

দেখা যাচ্ছে আর খুব ভার্জোজ। চরিত্র হিসাবে ইনপুট নেয়।

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,""))) ইনপুটটি বিভক্ত করুন (একটি স্ট্রিং_, এবং এটি কোনও তালিকার পরিবর্তে কোনও ভেক্টরে জোর করে এবং তারপরে এটিকে পূর্ণসংখ্যায় পরিণত করুন।
sum(tail(y,: tailসর্বশেষ এন উপাদান গ্রহণ করে , এটি দ্বারা পাওয়া:
- length(y)%/%2))যেখানে %/%পূর্ণসংখ্যা বিভাজন হয়, ভাগফল, যেখানে দৈর্ঘ্য বিজোড় হয় সিলিং জন্য।
sum(head(y,length(y)%/%2)): যেমন tail, ভেক্টরের headপ্রথম এন উপাদানগুলি গ্রহণ করে, একইভাবে পাওয়া যায়।

সম্পাদনাগুলি

সাতটি বাইট সংরক্ষণ করেছেন নিমকে ধন্যবাদ
এর =পরিবর্তে স্যুইচ করা হয়েছে <-, আরও দুটি বাইট সংরক্ষণ করা হয়েছে।

— আজোর আহাই
সূত্র

আপনি আবদ্ধ করতে পারেন length(y)%/%2একটি পরিবর্তনশীল এবং ব্যবহার যে কল মধ্যে থেকে একরকম tailএবং head?

— নিমি

@ নিমি ওহ হ্যাঁ, ভাল কথা।

— আজোর অহাই

85 বাইট tio.run/...

— Sumner18

প্রথম অঙ্কে y এবং l একত্রিত করে as.numeric হিসাবে as.double (), তালিকাভুক্ত () থেকে এল () এ পরিবর্তন করতে হবে। এটি আমাকে এক লাইনে এটি করার অনুমতি দিয়েছিল, বন্ধনীগুলি সরিয়ে, এবং পিআর :: f কোড থেকে আনুষ্ঠানিক / ভেরিয়েবল অনুমান করে

— Sumner18

3

ব্রেন-ফ্লাক , 410 206 204 178 + 3 = 181 বাইট

এখানে একটি 178 বাইট সংস্করণ রয়েছে যা -aপতাকা ব্যবহার করে ।

ডিজেএমসিএমহেইম দ্বারা গল্ফড 26 বাইট

এটি অনলাইনে চেষ্টা করুন

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

এখানে 410 বাইট সংস্করণ রয়েছে যা -aপতাকা ব্যবহার করে না ।

এটি অনলাইনে চেষ্টা করুন

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

ব্যাখ্যা

সংক্ষিপ্ত সমাধানটির ব্যাখ্যা এখানে দেওয়া হল

নম্বরটি শুরু করতে -aপতাকা দ্বারা তার সমস্ত ASCII মানগুলিতে রূপান্তরিত হয় ।

আমরা স্ট্যাকের উচ্চতা (অর্থাত্ অঙ্কের সংখ্যা) এবং অন্য দুটি দিয়ে বিভক্ত করি।

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

আমরা কেবল ধাক্কা দিয়েছি এমন সংখ্যার চেয়ে কম প্রতিটি সংখ্যার জন্য আমরা অন্য স্ট্যাকে একটি অঙ্ক সরিয়ে নিয়েছি

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

যদি স্ট্যাকগুলির আলাদা উচ্চতা থাকে তবে আমরা বর্তমান স্ট্যাক থেকে শীর্ষ আইটেমটি সরিয়ে ফেলি

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

আমরা প্রতিটি স্ট্যাকের অঙ্কের মধ্যে পার্থক্য চাই। সুতরাং আমরা প্রতিটি স্ট্যাকের যোগফলের জন্য নিম্নলিখিত অ্যালগরিদম ব্যবহার করি।

{{}}

এটি ধরে নিয়েছে যে কোনও সংখ্যার শূন্যের একটি ASCII মান নেই, যা একটি বৈধ অনুমান।

আমরা এটি উভয় স্ট্যাকের জন্য চালিত করি এবং পার্থক্যটি গ্রহণ করি ( <(())>পরবর্তী অংশের জন্য এটি প্রয়োজনীয়।

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

আমরা এখন যোগফলটিকে অবহেলা করতে চাই। যোগফল যদি শূন্য হয় তবে এটি পূর্বে যেটি ধাক্কা দিয়েছিল তা প্রকাশ করে শীর্ষে পপ হবে অন্যথায় এটি সংখ্যা এবং একটিকে উভয়ই সরিয়ে ফেলবে এবং উপরে একটি শূন্য রাখবে।

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

— গম উইজার্ড
সূত্র

কেন ([]){[{}]{}([])}{}প্রতিটি স্ট্যাক যোগফল? ({{}})ঠিক কাজ করা উচিত, এবং যেহেতু আপনি ASCII ইনপুট নিচ্ছেন, আপনার 0 এর লুপটি নষ্ট করার বিষয়ে চিন্তা করতে হবে না।

— ডিজেএমসিএমহেম

@ ডিজেএমসিমেহেম ভাল পয়েন্ট আমি ভুলে গিয়েছিলাম স্ট্যাকের কোনও শূন্য থাকতে পারে না

— Wheat উইজার্ড

3

আসলে, 17 16 বাইট

এই উত্তরটি এলপেড্রোর পাইথন 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.

— Sherlock9
সূত্র

3

পার্ল 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
}

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র

এটি আর কাজ করবে বলে মনে হচ্ছে না (আমি ..অ-পূর্ণসংখ্যাগুলি কীভাবে পরিচালনা করে তার একটি পরিবর্তন সন্দেহ করি )। পরিবর্তে প্রায় 33 বাইট কীভাবে

— জো কিং

2

জাভাস্ক্রিপ্ট, 73 বাইট

ভাল ওল 'ইএস 5 লুপস

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

পাইথন 2, 73 বাইট

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

পরীক্ষাগুলি আদর্শে

আমাদের str()`than এর পরিবর্তে ব্যবহার nকরতে হবে যেহেতু স্বাক্ষরিত ইন্টের পরিসীমাটির বাইরে থাকতে পারে।

— জোনাথন অ্যালান
সূত্র

আহ্, এ কারণেই আমি এলটি পেয়েছিলাম। +1

— এলপেড্রো

2

পাইথন 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 এ কমিয়েছেন

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

— ElPedro
সূত্র

আপনি তার map(int,input())পরিবর্তে ব্যবহার করতে পারেন [int(h)for h in raw_input()], len(g)/2সর্বদা ইনট থাকবে, রূপান্তর করার দরকার নেই, এবং or b==0সত্যই প্রয়োজনীয় নয়

— রড

আসলে b==0প্রয়োজনের জন্য len=1, তবে আপনি এটি সংক্ষিপ্ত করতে পারেনb<1

— রড

2

পিএইচপি, 73 67 60 57 বাইট

নেতিবাচক স্ট্রিং অফসেটের জন্য পিএইচপি 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

পূর্ববর্তী সংস্করণ

দ্রষ্টব্য: স্পেসশিপ অপারেটরের জন্য পিএইচপি 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 বাইট সংরক্ষণ করা হয়েছে।
স্ট্রিং অফসেটটি পিএইচপি হিসাবে এটি ব্যাখ্যা nullকরার intজন্য কাস্ট করতে হবে না 0। 1 বাইট সংরক্ষণ করা হয়েছে।
দ্বিতীয়ার্ধ থেকে অঙ্কগুলি পেতে এবং স্ট্রিংয়ের অর্ধেক পর্যন্ত পুনরাবৃত্তি করতে নেতিবাচক স্ট্রিং অফসেট ব্যবহার করে। 7 বাইট সংরক্ষণ করা হয়েছে, তবে পিএইচপি 7.1 প্রয়োজন
ব্যবহার করে 3 বাইট সংরক্ষণ করা হয়েছে $argn

— aross
সূত্র

2

ক্লোজার, 66 64 বাইট

আপডেট: ফাংশন strথেকে নেওয়া map int।

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

ইনপুট ফর্ম্যাটটি আরও নমনীয় হলে এটি সংক্ষিপ্ত হত, এখন আমাকে প্রথমে ASCII মানগুলির ক্রমতে পূর্ণসংখ্যার মানচিত্র করতে হবে। অভ্যন্তরীণ mapদুটি অর্ধের মানগুলির জোড়-ভিত্তিক পার্থক্য গণনা করে এবং ডেল্টাসের যোগফল শূন্য হয় কিনা তা পরীক্ষা করে।

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

আসলে এটি কেবলমাত্র ম্যাপিংয়ের মধ্যে একটির মধ্যে ঠিক একই দৈর্ঘ্য হিসাবে শেষ হয় letএবং কেবল একটি একক ফাংশন সংজ্ঞায়িত করে।

— NikoNyrh
সূত্র

1

সেড (165 + 1--র জন্য) 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

আউটপুট: মিথ্যা
জন্য সত্য
0 এর জন্য 1

এটি অনলাইন চেষ্টা করুন!

— রিলে
সূত্র

1

পাইথন 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

একই ধারণা, কেবল দৈর্ঘ্যটি ব্যবহার করুন - আমি অন্য দিকটি পেতে। এটি কখনই বিজোড় সংখ্যার কেন্দ্রে পৌঁছাবে না।

পুরাতন কোড

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

ইনপুট পান
ইনপুটটির দৈর্ঘ্য
সাশ্রয় করে স্ট্রিংয়ের যোগফল পেতে পুনরাবৃত্ত ফানক
প্রথম অর্ধের যোগফলকে দ্বিতীয় অর্ধের যোগফলের সাথে তুলনা করুন

এটি 100 এর নিচে পাওয়ার চেষ্টা করছে তবে এটি শক্ত: /

— greyShift
সূত্র

1

সি ফাংশন, 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।

— ডিজিটাল ট্রমা
সূত্র

আপনি যোগ না করে স্ট্রেন ব্যবহার করতে পারবেন না #include"string.h"\n, যা আপনার স্কোরটিতে 19 যোগ করে।

— নোসিয়েটবেল্টস

1

@ নোসিয়েটবেল্টস হ্যাঁ আপনি পারবেন - আইডিয়োন লিঙ্কটি চেষ্টা করে দেখুন। সংকলকটি সম্ভবত আপনাকে একাধিক সতর্কবার্তা দেবে, তবে যেকোন উপায়ে একটি কার্যনির্বাহী কার্যকর করুন (কমপক্ষে জিসিসি এবং কলং কর)। আপনি কোন সংকলক ব্যবহার করছেন? এই সম্পর্কে একটি কোড গল্ফ টিপ আছে ।

— ডিজিটাল ট্রমা

1

স্থানটির দরকার নেইchar *n

— সাইয়েস

স্পেস l;i;t;f(char*n){..return!t;}-2 বাইটগুলি সরিয়ে ফেলুন

— খালেদ.কে।

1

রেকেট 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

— rnso
সূত্র

1

পাইকে, 20 বাইট

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

এখানে চেষ্টা করুন!

— নীল
সূত্র

@ ওয়েইংআইফ ফার্স্ট আপনি ঠিক বলেছেন - আমি ভুলে গিয়েছিলাম not [0]0 টি 1 নয়

— নীল

1

গণিত, 69

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

— shrx
সূত্র

2

...;;]]&@*IntegerDigits

— শেষটি

@ মার্টিনইন্ডার ধন্যবাদ, তবে এটি কীভাবে কাজ করে?

— shx

@*জন্য সংক্ষিপ্ত Composition। f@*gহয় f[g[##]]&।

— মার্টিন এন্ডার

এটি কি ভারসাম্যযুক্ত সংখ্যা?

05 এ বি 1 ই , 14 7 বাইট

> <> , 31 29 বাইট

Haskell,, 64 63 বাইট

ব্র্যাচল্যাগ , 20 বাইট

ব্যাখ্যা

জাভা, 85 বাইট

পরীক্ষা এবং নিরবচ্ছিন্ন:

গণিত, 57 বাইট

ব্যাখ্যা

জাভাস্ক্রিপ্ট (ES6), 59 55 51 44 42 বাইট

পরীক্ষার স্নিপেট

পাওয়ারশেল ভি 2+, 85 বাইট

পরীক্ষার মামলা

পার্ল, 29 বাইট

সি #, 83 বাইট

পাইথন 3, 107 102 76 বাইট

রুবি, 63 বাইট

পরীক্ষা করা (সর্বনিম্ন 5+ প্রয়োজন):

হাস্কেল, 55 বাইট

রেটিনা, 64 44 বাইট

জাভাস্ক্রিপ্ট (ES6), 74 67 ... 59 50 বাইট

আর, 105 96 বাইট

সম্পাদনাগুলি

ব্রেন-ফ্লাক , 410 206 204 178 + 3 = 181 বাইট

ব্যাখ্যা

আসলে, 17 16 বাইট

পার্ল 6 , 42 39 33 বাইট

ব্যাখ্যা:

জাভাস্ক্রিপ্ট, 73 বাইট

পাইথন 2, 73 বাইট

পাইথন 2, 83 77 বাইট

পিএইচপি, 73 67 60 57 বাইট

পূর্ববর্তী সংস্করণ

ব্যাখ্যা

বদলান

ক্লোজার, 66 64 বাইট

সেড (165 + 1--র জন্য) 166

পাইথন 2.7, 102 92 বাইট

সি ফাংশন, 74

রেকেট 204 বাইট

পাইকে, 20 বাইট

গণিত, 69