38

एक संख्या संतुलित है यदि संख्या के प्रत्येक आधे पर अंकों का योग बराबर है, इसलिए: 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)। हमेशा की तरह, वैकल्पिक इनपुट प्रारूप, ताकि आप वांछित होने पर एपोस्ट्रोफ के साथ संख्या को घेर सकें।

code-golf number

— स्टीवी ग्रिफिन
स्रोत

12

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)

इसे ऑनलाइन आज़माएं!

— Emigna
स्रोत

के Ëबजाय आप का उपयोग नहीं कर सकते `Q?

— एरिक आउटगोलर

@EriktheOutgolfer: Ëजब यह चुनौती दी गई थी, तब एक अलग कमान थी, इसलिए दुर्भाग्य से नहीं।

— इमिग्ना जूल

10

> <> , 31 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पंक्ति 1: मानक इनपुट लूप

पंक्ति 2: स्टैक के शीर्ष पर -1 को छोड़ें, दो 0 को धक्का दें और स्टैक के निचले भाग में एक को घुमाएं (यह सुनिश्चित करता है कि लंबाई के इनपुट <3 कार्यक्रम में स्टैक को बाद में समाप्त न करें)

पंक्ति 3: यदि स्टैक की लंबाई> 3 है, तो स्टैक के शीर्ष दो और निचले दो तत्वों को एक साथ जोड़ें।

पंक्ति 4: यदि स्टैक के ऊपर और नीचे बराबर हैं, तो आउटपुट 1, 0 अन्यथा।

संपादित करें: एहसास हुआ कि पात्रों को लेने की कोई आवश्यकता नहीं है mod 12, 2 बाइट्स सहेजे गए हैं

— सोक
स्रोत

7

हास्केल, 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

— nimi

@ नमि थैंक्स ...

— डेमियन

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));:।

— ताड़ी

@todeale गोल्फ वाले कोड को देखें, न कि किसी अनगढ़ को। मुझे लगता है कि आपका सुझाव और मेरा गोल्फ का जवाब बाइट्स की समान राशि का उपयोग करता है

— ओलिवियर

ओह! अब मैं देखता हूॅं।

— 9

5

गणितज्ञ, 57 बाइट्स

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

व्याख्या

मैं वास्तव में उम्मीद कर रहा था कि मैं कुछ भाषा में इस दृष्टिकोण का उपयोग कर सकता हूं, और लगता है कि यह गणितज्ञ में काफी अच्छा कर रहा है। यह विचार है कि सूची को इसके विपरीत के साथ जोड़कर सामने और पीछे दोनों को प्राप्त करने से बचें और केवल सामने के आधे हिस्से को देखें।

...&@*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

जावास्क्रिप्ट (ईएस 6), 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]! अच्छा है।

— अरनुलद

@Arnauld धन्यवाद :-) मुझे अब पूरी तरह से एक अलग दृष्टिकोण मिल गया है जिसकी आवश्यकता नहीं है ...

— ETHproductions

अब, यह शानदार है!

— अरनौलद

क्या आप उपयोग नहीं कर सकते f=([x,...a])=>!(a[0]?x-a.pop()+f(a):0)?

— mbomb007

@ mbomb007 नोप; वह एक राशि के बजाय एक बूलियन (0 या 1 के लिए मजबूर) वापस करेगा।

— 21

4

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), की एक सरणी तैयार करने charऔर stringरों। ,सरणी समवर्ती को लागू करने के लिए सामने की ओर ध्यान दें , न कि स्ट्रिंग संघनन।

यह संपूर्ण सरणी -joinएक साथ संपादित की जाती है +, जिसके परिणामस्वरूप एक स्ट्रिंग होती है (+1+4+0)-(+2+3+0), और आप देख सकते हैं कि 0वाक्यविन्यास त्रुटियों को रोकने के लिए s की आवश्यकता है। वह |iex(कम Invoke-Expressionऔर इसके समान eval) में खिलाया जाता है , जो गणितीय परिणाम की गणना करेगा। जब तक स्ट्रिंग संतुलित है, तब तक आप 0एक आउटपुट के रूप में प्राप्त करेंगे, जिसे हम पैरेन्स में एन्कैप्सुलेट करते हैं और बूलियन-उसके !(...)लिए नहीं , आउटपुट पर ले जाते हैं 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: अभिन्न निरंतर बहुत बड़ी है ), इसलिए इसके बजाय BigInteger.Parse (स्ट्रिंग) विधि का उपयोग किया जाता है।

समाधान वास्तव में 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 बाइट्स को बचाना चाहिए, लेकिन C # में रिटर्न वैल्यू एक बूलियन होनी चाहिए, इसलिए r इसे नहीं काटेगा। धन्यवाद, मैं जल्द से जल्द अपना जवाब अपडेट करूंगा।

— 18

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 बाइट्स @Rod द्वारा !

— 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

@Rod मैं पहली टिप्पणी पर आपके द्वारा बताई गई सभी चीजों को बदलने के लिए यहां आया था, लेकिन दूसरे से हैरान था, बहुत बहुत धन्यवाद! :)

— यति

@Rod अपनी दूसरी टिपण्णी पर अपने अंतिम टिप का उपयोग करते हुए, एकल अंक टेस्टेसिस गलत मान लौटाता है :(

— यति

4

रूबी, 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

— cia_rana
स्रोत

4

हास्केल, 55 बाइट्स

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

पुनरावर्ती फ़ंक्शन gसिर को बार-बार लेने से दोनों सिरों से एक नंबर स्ट्रिंग को उजागर करता है, फिर उलटा करता है। यह सिर से पुनरावर्ती परिणाम को घटाता है, जो इसे +1 के -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$

इसे ऑनलाइन आज़माएं

पहले चरण बीच में स्ट्रिंग विभाजन, मध्यम चरित्र को छोड़ते हुए अगर वहाँ एक है ( ~~लिया और से संशोधित यहाँ ।~~ मार्टिन के सौजन्य।) फिर, अपने एकल प्रतिनिधित्व के साथ अंक की जगह है, और मेल खाते हैं, तो दो हिस्सों समान लंबाई के हैं।

— mbomb007
स्रोत

आप एक कोड-गोल्फ में गैर-कैप्चरिंग समूह का उपयोग क्यों करेंगे? ;) भले ही। .NET में, बैलेंसिंग समूहों के साथ स्ट्रिंग को विभाजित करने के लिए यह बहुत छोटा है: retina.tryitonline.net/… (मैंने कई चरणों की कोशिश भी की लेकिन यह थोड़ा अधिक लंबा होता है retina.tryitonline.net/… )।

— मार्टिन एंडर

@MartinEnder हाँ, मुझे पता था कि यह होगा, लेकिन मैंने कभी भी इस अवधारणा को नहीं समझा। और मुझे लगता है कि मैंने गैर-कैप्चरिंग समूह को अनदेखा कर दिया।

— mbomb007

1

यह इस मामले में वास्तव में सरल है: हम वर्णों को गिनते हैं (.)*?(प्रत्येक पुनरावृत्ति स्टैक 2 पर एक कैप्चर को धक्का देती है)। फिर हम स्टैक से फिर से (?<-2>.)*$(एक वैकल्पिक मध्य अंक के बाद) पॉपिंग करके अंत तक पहुंचने की कोशिश करते हैं । यह पहली बार संभव है जब हमने समूह 2 में बिल्कुल आधे अंकों (गोल नीचे) पर कब्जा कर लिया है

— मार्टिन एंडर

3

जावास्क्रिप्ट (ईएस 6), 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)।

— ETHproductions

@ETHproductions - यह देखने के लिए दिलचस्प है कि तरीकों को कैसे बंद करें और इसके बिना Math.sign()चालू करें।

— अरनुलद

डार, तुमने मुझे अच्छे के लिए पीटा हो सकता है ... अच्छा एक :)

— ETHproductions

मैं गलत था ;-)

— ETHproductions

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,""))) इनपुट को विभाजित करें (एक string_, और इसे एक सूची के बजाय एक सदिश में ले जाएं और फिर इसे पूर्णांकों में बदल दें।
sum(tail(y,: द्वारा पाया गया tailअंतिम n तत्व लेता है:
- length(y)%/%2)), जहां %/%पूर्णांक विभाजन है, भागफल की छत प्राप्त करने के लिए, जहां लंबाई विषम है।
sum(head(y,length(y)%/%2)): जैसे tail, सदिश headके पहले n तत्वों को लेता है , उसी तरह से पाया जाता है।

संपादित करता

सात बाइट्स के लिए धन्यवाद niam को बचाया
पर स्विच किया =बजाय <-, एक और दो बाइट्स बचा लिया।

— अज़ोर अहै
स्रोत

आप बाध्य कर सकते हैं length(y)%/%2एक चर और उपयोग के कॉल के अंतर्गत करने के लिए किसी भी तरह tailऔर head?

— nimi

@ नमि ओह, हाँ, अच्छी बात है।

— अज़ोर अहई

85 बाइट्स tio.run/…

— सुमेर

पहले योग में y और l को समेकित करके as.numeric को as.double (), अनलिस्ट () से el () में बदलकर। इसने मुझे यह सब एक पंक्ति में करने की अनुमति दी, कोष्ठक को हटा दिया और pryr :: f कोड से

— सूत्र

3

ब्रेन-फ्लैक , 410 206 204 178 + 3 = 181 बाइट्स

यहाँ एक 178 बाइट संस्करण है जो -aध्वज का उपयोग करता है ।

26 बाइट्स DJMcMayhem द्वारा बंद कर दी गईं

इसे ऑनलाइन आज़माएं

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

यहां एक लंबा 410 बाइट संस्करण है जो -aध्वज का उपयोग नहीं करता है ।

इसे ऑनलाइन आज़माएं

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

व्याख्या

यहाँ छोटे समाधान की व्याख्या है

संख्या को शुरू करने के लिए -aध्वज द्वारा अपने सभी ASCII मूल्यों में परिवर्तित किया जाता है ।

हम स्टैक ऊंचाई (यानी अंकों की संख्या) को धक्का देते हैं और दो से विभाजित करते हैं।

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

संख्या से कम प्रत्येक संख्या के लिए हमने केवल एक अंक को दूसरे स्टैक पर ले जाया

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

यदि स्टैक में अलग-अलग ऊंचाइयां हैं, तो हम शीर्ष आइटम को वर्तमान स्टैक से हटा देते हैं

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

हम प्रत्येक स्टैक के योगों के बीच अंतर चाहते हैं। इसलिए हम प्रत्येक स्टैक को योग करने के लिए निम्न एल्गोरिथम का उपयोग करते हैं।

{{}}

यह मानता है कि कोई अंक शून्य का ASCII मान नहीं है, जो एक मान्य धारणा है।

हम इसे दोनों स्टैक के लिए चलाते हैं और अंतर लेते हैं ( <(())>अगले भाग के लिए आवश्यक है।

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

हम अब राशि को नकारना चाहते हैं। यदि राशि शून्य है, तो यह शीर्ष को पॉप अप करेगा जिसे हमने पहले धक्का दिया था अन्यथा यह संख्या और एक दोनों को हटा देगा और शीर्ष पर एक शून्य को रखेगा।

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

— गेहूं का जादूगर
स्रोत

([]){[{}]{}([])}{}प्रत्येक स्टैक का योग करने के लिए उपयोग क्यों करें ? ({{}})बस ठीक काम करना चाहिए, और जब से आप ASCII इनपुट ले रहे हैं, तो आपको 0 को बर्बाद करने के बारे में चिंता करने की ज़रूरत नहीं है।

— DJMcMayhem

@DJMcMayhem अच्छी बात है। मैं भूल गया कि स्टैक पर एक शून्य नहीं हो सकता है

— गेहूं जादूगर

3

दरअसल, 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.

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

— ब्रैड गिल्बर्ट b2gills
स्रोत

यह अब काम नहीं करता है (मुझे लगता है कि ..गैर-पूर्णांकों को कैसे संभालता है इसमें बदलाव पर संदेह है )। इसके बजाय 33 बाइट्स के बारे में

— जो किंग

2

जावास्क्रिप्ट, 73 बाइट्स

अच्छा राजभाषा '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

पायथन 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()`` के बजाय उपयोग करना है क्योंकि 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

संपादित करें

@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

— ElPedro
स्रोत

आप map(int,input())इसके बजाय का उपयोग कर सकते हैं [int(h)for h in raw_input()], len(g)/2हमेशा int, कोई ज़रूरत नहीं है कन्वर्ट करने के लिए, और or b==0वास्तव में आवश्यक नहीं होगा

— रॉड

वास्तव में b==0जरूरत है len=1, लेकिन आप इसे छोटा कर सकते हैंb<1

— रॉड

2

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 बाइट्स।
स्ट्रिंग ऑफ़सेट nullको intPHP के रूप में इसे व्याख्या करने के लिए डालने की ज़रूरत नहीं है 0। बचा 1 बाइट।
दूसरी छमाही से अंकों को प्राप्त करने और स्ट्रिंग के आधे भाग तक पहुंचने के लिए नकारात्मक स्ट्रिंग ऑफसेट का उपयोग करना। 7 बाइट्स सहेजे गए, लेकिन इसके लिए PHP 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

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

इसे ऑनलाइन आज़माएं!

— रिले
स्रोत

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 जोड़ देता है।

— NoSeatbelts

1

@NoSeatbelts हाँ, आप कर सकते हैं - Ideone लिंक को आज़माएँ। संकलक सबसे अधिक संभावना आपको चेतावनी का एक गुच्छा देगा, लेकिन वैसे भी एक कार्य निष्पादन योग्य संकलित करें (कम से कम जीसीसी और क्लैंग डू)। आप कौन से कंपाइलर का उपयोग कर रहे हैं? इस बारे में एक कोड-गोल्फ टिप भी है ।

— डिजिटल ट्रामा

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!

यहाँ कोशिश करो!

— नीला
स्रोत

@WeeingIfFirst आप सही थे - मैं भूल गया not [0]था 0 नहीं 1

— ब्लू

1

गणितज्ञ, ६ ९

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

— shrx
स्रोत

2

आप अंत को बदलकर बाइट्स के एक जोड़े को बचा सकते हैं...;;]]&@*IntegerDigits

— मार्टिन एंडर

@MartinEnder धन्यवाद, लेकिन यह कैसे काम करता है?

— shrx

@*के लिए छोटा है Composition। f@*gहै f[g[##]]&।

— मार्टिन एंडर

क्या यह एक संतुलित संख्या है?

05AB1E , 14 7 बाइट्स

> <> , 31 29 बाइट्स

हास्केल, 64 63 बाइट्स

ब्रेकीलॉग , 20 बाइट्स

व्याख्या

जावा, 85 बाइट्स

परीक्षण और अपुष्ट:

गणितज्ञ, 57 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 59 55 51 44 42 बाइट्स

टेस्ट स्निपेट

PowerShell v2 +, 85 बाइट्स

परीक्षण के मामलों

पर्ल, 29 बाइट्स

सी #, 83 बाइट्स

पायथन 3, 107 102 76 बाइट्स

रूबी, 63 बाइट्स

परीक्षण (न्यूनतम 5+ आवश्यक):

हास्केल, 55 बाइट्स

रेटिना, 64 44 बाइट्स

जावास्क्रिप्ट (ईएस 6), 74 67 ... 59 50 बाइट्स

आर, 105 96 बाइट्स

संपादित करता

ब्रेन-फ्लैक , 410 206 204 178 + 3 = 181 बाइट्स

व्याख्या

दरअसल, 17 16 बाइट्स

पर्ल 6 , 42 39 33 बाइट्स

स्पष्टीकरण:

जावास्क्रिप्ट, 73 बाइट्स

पायथन 2, 73 बाइट्स

पायथन 2, 83 77 बाइट्स

PHP, 73 67 60 57 बाइट्स

पुराना वर्जन

व्याख्या

बदलाव

क्लोजर, 66 64 बाइट्स

sed (165 + 1 for -r) 166

पायथन 2.7, 102 92 बाइट्स

सी फ़ंक्शन, 74

रैकेट 204 बाइट्स

पाइके, 20 बाइट्स

गणितज्ञ, ६ ९