¿Es un número balanceado?

38

Un número está equilibrado si la suma de los dígitos en cada mitad del número es igual, entonces: 1423está equilibrado porque 1+4 = 2+3, así es: 42615porque 4+2=1+5. Tenga en cuenta que el dígito del medio no se incluye en ninguno de los lados (o se incluye en ambos lados) si hay un número impar de dígitos.

Reto:

Tome un entero positivo como entrada y genere un valor verdadero si está equilibrado y un valor falso si no está equilibrado.

Casos de prueba (verdadero)

1
6
11
141
1221
23281453796004414
523428121656666655655556655656502809745249552466339089702361716477983610754966885128041975406005088

Casos de prueba (falso)

10
12
110
15421
5234095123508321
6240911314399072459493765661191058613491863144152352262897351988250431140546660035648795316740212454

No habrá números que comiencen con cero, por ejemplo, en 00032lugar de 32. Debe admitir números de hasta al menos 100 dígitos (tan grande como 2^64-1). Como siempre, formato de entrada opcional, por lo que puede rodear el número con apóstrofos si lo desea.

Stewie Griffin
fuente

Respuestas:

12

05AB1E , 14 7 bytes

€D2äO`Q

Explicación

Usando 141 como ejemplo:

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

Pruébalo en línea!

Emigna
fuente
¿No puedes usar en Ëlugar de `Q?
Erik the Outgolfer
@EriktheOutgolfer: Ëera un comando diferente cuando se hizo este desafío, así que desafortunadamente no.
Emigna
10

> <> , 31 29 bytes

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

Pruébalo en línea!

Línea 1: bucle de entrada estándar

Línea 2: deseche el -1 en la parte superior de la pila, presione dos ceros y gire uno hacia la parte inferior de la pila (esto asegura que las entradas de longitud <3 no agoten la pila más adelante en el programa)

Línea 3: si la longitud de la pila es> 3, agregue los dos elementos superiores e inferiores de la pila juntos.

Línea 4: Si la parte superior e inferior de la pila son iguales, salida 1, 0 de lo contrario.

Editar: me di cuenta de que no es necesario tomar los caracteres mod 12, 2 bytes guardados

Sok
fuente
7

Haskell, 64 63 bytes

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

Un byte guardado gracias a nimi

Damien
fuente
¿Los fragmentos no necesitan paréntesis?
Michael Klein
@ michael-klein No, se permiten funciones sin nombre. meta.codegolf.stackexchange.com/a/7615/20260
Damien el
1
Un byte para guardar:b(a:t@(r:s))=a-last t+b(init t);b _=0
nimi
@nimi Gracias ...
Damien
5

Brachylog , 20 bytes

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

Pruébalo en línea!

Explicación

@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
Fatalizar
fuente
5

Java, 85 bytes

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

Nota: la entrada se da como StringJava no puede manejar sin BigInteger(y BigIntegers se construyen usando un ... String)

Pruebas y sin golf:

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);
    }
  }
}
Olivier Grégoire
fuente
Buena respuesta. Usted podría ahorrar 2 bytes, haciendo que el bucle de vacío: for (; i < l / 2;s += n.charAt(i) - n.charAt(l - ++i));.
todeale
@todeale Mira el código golfizado, no el no golfista. Creo que su sugerencia y mi respuesta de golf usan la misma cantidad de bytes
Olivier Grégoire
Ooops! Ahora veo.
todeale
5

Mathematica, 57 bytes

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

Explicación

Realmente esperaba poder usar este enfoque en algún idioma, y ​​parece estar funcionando bastante bien en Mathematica. La idea es evitar tener que obtener tanto la mitad frontal como la posterior combinando la lista con su reverso y mirando solo la mitad frontal.

...&@*IntegerDigits

Primero, convertimos la entrada en una lista de dígitos decimales y pasamos el resultado a la función sin nombre a la izquierda.

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

Ahora restamos el reverso de la lista de la lista misma. Si los dígitos son entonces el resultado será .{a1,a2,...,an}{a1-an,a2-an-1,...,an-a1}

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

Extraemos la primera mitad de esta lista (excluyendo el dígito del medio, aunque eso en realidad no importa, porque la diferencia correspondiente será de 0todos modos).

Tr@...

Y luego sumamos esta lista. Así que eso es:

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

Reorganizando:

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

La entrada se equilibra si las dos mitades tienen la misma suma. Por lo tanto, esta expresión es cero si la entrada está equilibrada. Entonces eso es lo que verificamos:

...==0
Martin Ender
fuente
5

JavaScript (ES6), 59 55 51 44 42 bytes

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

Resulta que estaba usando la estrategia equivocada por completo. Esta versión encuentra recursivamente la suma de la primera mitad menos la suma de la segunda mitad, luego devuelve el NOT lógico del resultado.

Si pudiéramos devolver falsedad en lugar de verdad y viceversa, esto sería 35 bytes:

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

Fragmento de prueba

ETHproducciones
fuente
Realmente me gusta esto n[i*2]! Buena esa.
Arnauld
@Arnauld Gracias :-) He encontrado un enfoque completamente diferente ahora que no necesita eso en absoluto ...
ETHproductions
Ahora, eso es genial!
Arnauld
¿No puedes usar f=([x,...a])=>!(a[0]?x-a.pop()+f(a):0)?
mbomb007
@ mbomb007 No; eso devolvería un valor booleano (forzado a 0 o 1) después de cada recursión, en lugar de una suma.
ETHproductions
4

PowerShell v2 +, 85 bytes

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

Toma la entrada $acomo una cadena (necesaria para admitir números >2^64-1sin entrar extremadamente torpe[biginteger] conversión en la línea de comando).

Para la explicación, supongamos la entrada de '1423' . Entonces estamos construyendo una nueva cadena. Las dos rebanadas de matriz son obvias ( $a[...]), y que está rodeado por tres cadenas adicionales (, 0)-(y 0), la formulación de una matriz de chars y strings. Tenga ,en cuenta el frente para aplicar la concatenación de matriz, no la concatenación de cadenas.

Esa matriz completa se -joinedita junto con +, dando como resultado una cadena como (+1+4+0)-(+2+3+0), y puede ver que los 0s son necesarios para evitar errores de sintaxis. Eso se introduce en |iex(abreviatura Invoke-Expressiony similar a eval), que calculará el resultado matemático. Mientras la cadena esté equilibrada, obtendrá 0como salida, que encapsulamos en parens y tomamos el booleano, no del mismo !(...), para generarTrue . Si se trata de un número entero distinto de cero, se generará False.

Casos de prueba

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

Perl, 29 bytes

Incluye +5 para -lpF

Dar número en STDIN

balanced.pl <<< 1423

balanced.pl:

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

C #, 83 bytes

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

Pruébalo en línea!

Fuente completa, incluido el caso de prueba:

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

El tipo de datos BigInteger permite cualquier longitud de número. Si el número es demasiado grande, el compilador se queja ( error CS1021: la constante integral es demasiado grande ), entonces BigInteger.Parse (String) se utiliza el método .

La solución en realidad se puede reducir a 72 bytes considerando que la entrada es una cadena (y actualizando el programa en consecuencia):

t=>{int l=t.Length,i=0,r=0;for(;i<l/2;)r+=t[i]-t[l-1-i++];return r==0;};
adrianmp
fuente
1
No es sorprendente que mi respuesta c terminara pareciéndose bastante a esta. ¿Se puede hacer en t[l-++i]lugar de t[l-1-i++]y en return !rlugar de return r==0?
Trauma digital
Prefijar el operador de incremento debe hacer el truco y guardar 2 bytes, pero en C # el valor de retorno debe ser un valor booleano, por lo que! R no lo cortará. Gracias, actualizaré mi respuesta lo antes posible.
adrianmp
4

Python 3, 107 102 76 bytes

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

-26 bytes por @Rod !

Yytsi
fuente
2
puede reemplazar floor(l/2)con l//2y ceil(l/2)con l//2+l%2para guardar 7 bytes, y luego eliminar la importación matemática, ahorrando más 18
Rod
1
Además, no necesita el 0encendido n[0:l//2]y n[l//2+l%2:]podría ser n[-(l//2):]. O se podría mover el //2a l=len(n)//2, y utilizar n[:l], yn[-l:]
Varilla
55
También se ve realmente extraño cuando su importación no está en la parte superior.
mbomb007
@ Rod. Vine aquí para cambiar todas las cosas que mencionaste en el primer comentario, pero el segundo me sorprendió, ¡muchas gracias! :)
Yytsi
@ Rod Al usar su último consejo en su segundo comentario, los casos de prueba de un solo dígito devuelven valores de falsey :(
Yytsi
4

Ruby, 63 bytes

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

Nota: arg s debe ser una cadena.

Prueba (se requiere minitest 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
fuente
4

Haskell, 55 bytes

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

La función recursiva gdesenvuelve una cadena de números de ambos extremos tomando repetidamente la cabeza y luego invirtiendo. Resta el resultado recursivo de la cabeza, lo que provoca coeficientes alternos de +1 y -1, con +1 aplicado a la primera mitad y -1 a la segunda mitad.

   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

Entonces, toma la suma de la primera mitad menos la suma de la segunda mitad. Esto tiene el problema de que con un número impar de dígitos, el centro se rompe a la izquierda, pero la función principal lo corrige (<*"xx"), lo que duplica cada carácter, es decir, "12345" se convierte en "1122334455". De esa manera, el dígito del medio se divide de manera uniforme en ambos lados y se cancela.

xnor
fuente
3

Retina, 64 44 bytes

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

Pruébalo en línea

La primera etapa divide la cadena en el medio, omitiendo el carácter del medio si hay uno ( tomado y modificado a partir de aquí . Cortesía de Martin). Luego, reemplace los dígitos con su representación unaria y haga coincidir si las dos mitades son de igual longitud.

mbomb007
fuente
¿Por qué usarías un grupo que no captura en un código de golf? ;) Independientemente, en .NET es mucho más corto dividir la cadena con grupos de equilibrio: retina.tryitonline.net/… (También probé varias etapas pero eso termina siendo un poco más largo retina.tryitonline.net/… ).
Martin Ender
@ MartinEnder Sí, sabía que lo sería, pero nunca entendí realmente el concepto. Y supongo que pasé por alto al grupo que no captura.
mbomb007
1
Es realmente simple en este caso: contamos los caracteres con (.)*?(cada iteración empuja una captura en la pila 2). Luego tratamos de llegar al final volviendo a aparecer desde la pila con (?<-2>.)*$(después de un dígito medio opcional). La primera vez que esto es posible es cuando hemos capturado exactamente la mitad de los dígitos (redondeados hacia abajo) en el grupo 2.
Martin Ender
3

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

Suma recursivamente la diferencia del primer y último dígito hasta que queden menos de dos dígitos:

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
fuente
1
Buena técnica Creo que puedes hacer (s-=i<0?v:-v).
ETHproductions
@ETHproductions: es interesante ver cuán cercanos son los métodos con y sin ellos Math.sign().
Arnauld
Maldición, es posible que me hayas derrotado para siempre ... agradable :)
ETHproductions
Me equivoqué ;-)
ETHproductions
3

R 105 96 bytes

Resulta que R es muy detallado. Toma la entrada como un personaje.

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

Formateado muy bien:

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

Explicación

  • y<-as.numeric(unlist(strsplit(x,""))) Divida la entrada (una cadena_, y conviértala en un vector en lugar de una lista, y luego vuelva a convertirla en enteros.
  • sum(tail(y,: tailtoma los últimos n elementos, encontrados por:
    • length(y)%/%2)), donde %/%está la división de enteros, para obtener el techo del cociente, donde la longitud es impar.
  • sum(head(y,length(y)%/%2)): como tail, headtoma los primeros n elementos del vector, encontrados de la misma manera.

Ediciones

  • Guardado siete bytes gracias a niam
  • Cambiado a en =lugar de <-, guardado otros dos bytes.
Azor Ahai
fuente
¿Se puede vincular de length(y)%/%2alguna manera a una variable y usar eso dentro de las llamadas de taily head?
nimi
@nimi Oh, sí, buen punto.
Azor Ahai
85 bytes tio.run/…
Sumner18
consolidando y y l en la primera suma, cambiando as.numeric a as.double (), unlist () a el (). Esto me permitió hacerlo todo en una línea, eliminando corchetes, y pryr :: f adivina los formales / variables del código
Sumner18
3

Cerebro-Flak , 410 206 204 178 + 3 = 181 bytes

Aquí hay una versión de 178 bytes que usa la -abandera.

26 bytes de golf de DJMcMayhem

Pruébalo en línea

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

Aquí hay una versión más larga de 410 bytes que no usa la -abandera.

Pruébalo en línea

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

Explicación

Aquí hay una explicación de la solución más corta.

Para comenzar, el número se convierte a todos sus valores ASCII mediante la -abandera.

Empujamos la altura de la pila (es decir, el número de dígitos) y la dividimos por dos.

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

Por cada número menor que el número que acabamos de presionar, movemos un dígito a la otra pila

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

Si las pilas tienen diferentes alturas, eliminamos el elemento superior de la pila actual

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

Queremos la diferencia entre las sumas de cada pila. Entonces usamos el siguiente algoritmo para sumar cada pila.

{{}}

Esto supone que ningún dígito tiene un valor ASCII de cero, que es una suposición válida.

Ejecutamos esto para ambas pilas y tomamos la diferencia (El <(())> es necesario para la siguiente parte.

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

Ahora queremos negar la suma. Si la suma es cero, se abrirá la parte superior revelando la que presionamos anteriormente; de ​​lo contrario, eliminará tanto el número como el uno y colocará un cero en la parte superior.

{{}{}((<>))}{}
Asistente de trigo
fuente
¿Por qué usar ([]){[{}]{}([])}{}para sumar cada pila? ({{}})debería funcionar bien, y dado que está tomando la entrada ASCII, no tiene que preocuparse de que los 0 arruinen el ciclo.
DJMcMayhem
@DJMcMayhem Buen punto. Olvidé que no podía haber un cero en la pila
Wheat Wizard
3

En realidad, 17 16 bytes

Esta respuesta está inspirada en la respuesta de Python 2 de ElPedro y su idea de usar [-b:]. Sugerencias de golf bienvenidas. Pruébalo en línea!

$♂≈;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
fuente
3

Perl 6 ,  42 39  33 bytes

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

Pruébalo

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

Pruébalo

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

Pruébalo (de Jo King )

Explicación:

{ # 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
}
Brad Gilbert b2gills
fuente
Esto ya no parece funcionar (sospecho un cambio en la forma en que ..maneja los no enteros). ¿Qué tal 33 bytes en su lugar
Jo King
2

Javascript, 73 bytes

Buenos viejos bucles ES5

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

¿Que esta pasando aqui?

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
Bassdrop Cumberwubwubwub
fuente
2

Python 2, 73 bytes

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

Las pruebas están en ideone

Tenemos que usar en str()lugar de `` ya que npuede estar fuera del rango de int firmado.

Jonathan Allan
fuente
Ah, por eso estaba obteniendo la L al final. +1
ElPedro
2

Python 2, 83 77 bytes

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

EDITAR

reducido a 77 con ayuda de @Rod

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

Ejemplos:

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
fuente
puede usar map(int,input())en su lugar [int(h)for h in raw_input()], len(g)/2siempre será int, no es necesario convertir, y or b==0no es realmente necesario
Rod
de hecho b==0es necesario len=1, pero puede acortarlo ab<1
Rod
2

PHP, 73 67 60 57 bytes

Requiere PHP 7.1 para compensaciones de cadena negativas:

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

Correr:

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

Versión previa

Nota: requiere PHP 7 para el operador de la nave espacial.

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

Corre así:

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

Explicación

Itera sobre los dígitos en el número. Comprueba si el dígito pertenece a la primera mitad o la segunda mitad (o es el dígito del medio) comparando el índice del dígito con la longitud de la entrada con la comparación combinada ( 2 * $x <=> $l - 1). Luego multiplique eso con el dígito, tome la suma de todos los dígitos. Si es un número equilibrado, la suma será0 .

Ejemplo con entrada 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

Ajustes

  • No establezca el dígito en $d, solo itere la longitud de la entrada. Guardado 5 bytes.
  • nullNo es necesario convertir el desplazamiento de cadena intpara que PHP lo interprete0 . Guardado 1 byte.
  • Usando compensaciones de cadena negativas para obtener los dígitos de la segunda mitad e iterando a la mitad de la cadena. Guardado 7 bytes, pero requiere PHP 7.1
  • Guardado 3 bytes usando $argn
aross
fuente
2

Clojure, 66 64 bytes

Actualización: se eliminó strde la map intfunción.

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

Esto se habría acortado si el formato de entrada fuera más flexible, ahora tenía que asignar primero el entero en una secuencia de valores ASCII. El interiormap calcula las diferencias de valores por pares de las dos mitades, y esto verifica si la suma de deltas es cero.

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

En realidad, esto terminó teniendo la misma longitud que simplemente hacer el mapeo dentro de ay letsolo definir una sola función.

NikoNyrh
fuente
1

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

Salida:
1 para verdadero
0 para falso

Pruébalo en línea!

Riley
fuente
1

Python 2.7, 102 92 bytes

Para el bucle funciona mejor: /

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

La misma idea, solo usa la longitud - i para obtener el otro lado. Nunca llegará al centro de un número impar.

Código antiguo

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

Obtiene la entrada
Guarda la longitud de la entrada
Función recursiva para obtener la suma de la cadena
Compare la primera mitad de la suma con la segunda mitad de la suma

Tratando de llegar por debajo de 100, pero es difícil: /

greyShift
fuente
1

Función 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;}

Ideona

Trauma digital
fuente
No puedes usar strlen sin incluir #include"string.h"\n, lo que agrega 19 a tu puntaje.
NoSeatbelts
1
@NoSeatbelts Sí, puedes, prueba el enlace Ideone. El compilador probablemente le dará un montón de advertencias, pero compile un ejecutable que funcione de todos modos (al menos GCC y Clang do). ¿Qué compilador estás usando? Incluso hay un consejo de código de golf sobre esto .
Trauma digital
1
No hay necesidad de espacio enchar *n
Cyoce
eliminar espacios l;i;t;f(char*n){..return!t;}-2 bytes
Khaled.K
1

Raqueta 204 bytes

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

Versión detallada:

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

Pruebas:

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

Salida:

#t
#t
#f
#f
rnso
fuente
1

Pyke, 20 bytes

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

Pruébalo aquí!

Azul
fuente
@WeeingIfPrimero tenías razón - Olvidé que not [0]era 0 no 1
Azul
1

Mathematica, 69

Tr@#[[;;⌊l=Length@#/2⌋]]==Tr@#[[⌈l⌉+1;;]]&@*IntegerDigits
shrx
fuente
2
Puede guardar un par de bytes cambiando el final a ...;;]]&@*IntegerDigits
Martin Ender
@ Martininder gracias, pero ¿cómo funciona esto?
shrx
@*es la abreviatura de Composition. f@*ges f[g[##]]&.
Martin Ender