Cuentas paralelas (día 2)

10

Reto tomado con permiso de mi concurso de desafío de código universitario

Después de terminar sus estudios hace un par de meses, Marie abrió una cuenta bancaria para comenzar a recibir el pago de su primer trabajo en la ciudad. Desde entonces, ha estado realizando algunas transacciones con él. Su primer pago fue de $ 1000 dólares. Con ese dinero pagó una cena en la que invitó a sus padres (la cena costó $ 150 dólares), luego hizo una compra en un conocido supermercado ($ 80 dólares) y una reserva de hotel para sus vacaciones ($ 200). Al final del mes recibió nuevamente su pago (1040 dólares, un poco más que el mes anterior) y al día siguiente gastó otros $ 70 dólares en el supermercado.

Hoy, se dio cuenta de que si después de pagar los primeros $ 80 dólares en el supermercado se hubiera creado una segunda cuenta y la primera congelada, ambas cuentas tendrían exactamente el mismo saldo:

1000-150-80⏟Totunal=770-2001040-70⏟Totunal=770

El evento fue tan raro para ella que quiere seguir averiguando si los movimientos de su cuenta y los de sus amigos también tienen esta característica o no.

Desafío

Dada una lista de transacciones, genere el número de instantes de tiempo en que el propietario de la cuenta bancaria podría haber creado una segunda cuenta para que ambos tuvieran el mismo saldo final.

Ejemplo: [1000, -150, -80, -200, 1040, -70]

1)⏟Total=01000−150−80−2001040−70⏟Total=1540
2)1000⏟Total=1000−150−80−2001040−70⏟Total=540
3)1000−150⏟Total=850−80−2001040−70⏟Total=690
4)1000−150−80⏟Total=770−2001040−70⏟Total=770
5)1000−150−80−200⏟Total=5701040−70⏟Total=970
6)1000−150−80−2001040⏟Total=1610−70⏟Total=−70
7 7)1000-150-80-2001040-70⏟Totunal=1540⏟Totunal=0 0

Caso de prueba

  • Entrada: 1000 -150 -80 -200 1040 -70Salida:1
  • Entrada: 100 -100Salida:2
  • Entrada: 1 2 3Salida:1
  • Entrada: 10 -20 15Salida:0
  • Entrada: 15 -15 15 -15Salida:3
  • Entrada: 1Salida:0

Notas

code-golf 
— Luis felipe De jesus Munoz
fuente
11
Después de 6 meses de cuentas congeladas y de nueva creación, se informa que el banquero de Marie ahora está internado en un sanatorio. "Somos tus amigos. Necesitas descansar", dijeron.
— Arnauld
2
Caso de prueba sugerido de una sola transacción
— Veskah,

Respuestas:

4

Perl 6 , 25 bytes

{+grep .sum/2,[\+] 0,|$_}

Pruébalo en línea!

Explicación

Simplemente anteponemos un cero a la lista dada ( 0,|$_), hacemos una secuencia de sumas parciales con [\+](es decir, la secuencia formada por el primer elemento, la suma de los dos primeros, la suma de los primeros tres, etc.) y buscamos ( grep) elementos que son exactamente iguales a la mitad del estado final de la cuenta (suma de la lista dada). Finalmente, los contamos con a +.

— Ramillies
fuente
3

05AB1E , 11 bytes

0.ø.œ2ùO€ËO

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

0.ø          # Surround the (implicit) input list with a leading and trailing 0
             #  i.e. [100,-100] → [0,100,-100,0]
   .œ        # Get all possible partitions to divide the list
             #  → [[[0],[100],[-100],[0]],[[0],[100],[-100,0]],[[0],[100,-100],[0]],[[0],[100,-100,0]],[[0,100],[-100],[0]],[[0,100],[-100,0]],[[0,100,-100],[0]],[[0,100,-100,0]]]
     2ù      # Only leave partitions consisting of 2 items
             #  → [[[0],[100,-100,0]],[[0,100],[-100,0]],[[0,100,-100],[0]]]
       O     # Take the sum of each
             #  → [[0,0],[100,-100],[0,0]]
        €Ë   # Check of each inner list if both sums are equal (1 if truthy; 0 if falsey)
             #  → [1,0,1]
          O  # Take the sum of that (and output as result)
             #  → 2
— Kevin Cruijssen
fuente
3

JavaScript (Node.js) , 45 bytes

a=>!a.map(v=>o[s+=v]=-~o[s],s=0,o=[1])|o[s/2]

Pruébalo en línea!

Ahorre 4 bytes mediante el uso -~o[s]. Gracias a Shaggy

— tsh
fuente
+1 por vencer a Arnauld: o
— Luis felipe De jesus Munoz
— Shaggy
@LuisfelipeDejesusMunoz, Arnauld no es (siempre) inmejorable! ;)
— Shaggy
El cambio de @Shaggy +se cambia a !, por lo que podría funcionar como entrada [100].
— tsh
Ah, no me di cuenta de que teníamos que manejar matrices singleton. Muy bien arreglado.
— Shaggy
2

JavaScript (ES6), 52 bytes

a=>a.map(x=>n+=(s+=x)==eval(a.join`+`)-s,n=s=0)|n+!s

Pruébalo en línea!

Comentado

a =>                        // a[] = input array
  a.map(x =>                // for each element x in a[]:
    n +=                    //   increment n if the following test is truthy:
      (s += x)              //     update the left sum
      ==                    //     and test whether it's equal to
      eval(a.join`+`) - s,  //     the right sum
    n = s =0                //   start with n = s = 0
  )                         // end of map()
  | n                       // yield n; if the final sum is 0, it means that we could have
  +                         // created a balanced account at the beginning of the process;
  !s                        // so, we increment n if it is

Versión recursiva,  54  53 bytes

f=(a,s=0)=>a+a?(s==eval(a.join`+`))+f(a,s+a.pop()):!s

Pruébalo en línea!

— Arnauld
fuente
¡Estaba a punto de sugerir esa versión de 52 bytes!
— Shaggy
@ Shaggy Sí, descarté la versión no recursiva demasiado pronto porque pensé que la recursiva podría ser más corta.
— Arnauld
2

APL (Dyalog Unicode) , SBCS de 21 bytes

Función de prefijo tácito anónimo

+/⊂((+/↑)=1⊥↓)¨⍨0,⍳∘≢

Pruébalo en línea!

⍳ ɩ ndices
 ∘ de
≢ la cuenta de transacciones

0, anteponer cero

⊂(... )¨⍨ aplique la siguiente función tácita con cada uno de ellos como argumento izquierdo y la lista completa de transacciones como argumento derecho (⍨ argumento de intercambio

⊂ la lista completa de transacciones
 (... ) como argumento izquierdo de la siguiente función
  ¨ aplicada a cada uno de los índices
   ⍨ con argumentos intercambiados (es decir, lista a la derecha, índices a la izquierda:

  ↓ soltar tantos desde la izquierda

  1⊥ suma (lit. evaluar en base-1)

  (... )= es (0/1) igual a ...

   ↑ tomar tantas transacciones desde la izquierda

   +/ sumalos

+/ suma esa lista booleana para obtener el recuento de verdades

— Adán
fuente
2

Lote, 84 bytes

@set s=%*
@set/as=%s: =+%,c=0
@for %%n in (0 %*)do @set/as-=%%n*2,c+=!s
@echo %c%

Toma datos como argumentos de línea de comandos. Explicación:

@set s=%*

Une los argumentos con espacios.

@set/as=%s: =+%,c=0

Reemplace los espacios con + sy evalúe el resultado. También borra el conteo.

@for %%n in (0 %*)do @set/as-=%%n*2,c+=!s

Para cada cantidad, reste el doble de la suma. Si el resultado es cero, entonces esta es una coincidencia válida, así que incremente la cuenta. El cero extra al principio permite una coincidencia antes de cualquier cantidad.

@echo %c%

Imprime el resultado.

— Neil
fuente
2

Carbón de leña , 15 bytes

⊞θ⁰ＩΣＥθ⁼Σθ⊗Σ✂θκ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

 θ              Input list
  ⁰             Literal 0
⊞               Push to list
      θ         Augmented list
     Ｅ          Mapped to
             θ  Augmented list
            ✂   Sliced from
              κ Current index
           Σ    Summed
          ⊗     Doubled
       ⁼        Equals
         θ      (Augmented) list
        Σ       Summed
    Σ           Sum of booleans
   Ｉ            Cast to string
                Implicitly print

Lamentablemente, en el carbón Sum([])no es 0así, tengo que asegurarme de que siempre haya al menos un elemento para sumar.

— Neil
fuente
2

Python 3 , 67 58 bytes

lambda l:sum(sum(l[:x])*2==sum(l)for x in range(len(l)+1))

Pruébalo en línea!

-9 bytes gracias a @ No seas un punto triple x

— Black Owl Kai
fuente
1
Sumando en lugar de filtrado le ahorrará 7 bytes: lambda l:sum(sum(l[:x])==sum(l[x:])for x in range(len(l)+1)).
— Sr. Xcoder
sum(l[:x])*2==sum(l)le ahorra otros 2 bytes.
— Neil
2

MATL , 9 bytes

s0GhYsE=s

Pruébalo en línea!

El mismo enfoque que algunas otras respuestas: anteponer un cero y verificar con qué frecuencia la mitad de la suma acumulativa es igual a la suma total. 

s   % Total sum of (implicit) input
0Gh % Prepend 0 to another copy of the input
Ys  % Cumulative sum
E=  % Check element-wise equality of 2*cumulative sum with total sum
s   % Sum number of `true` values
— Sanchises
fuente
2

Japt -x , 14 11 bytes

iT å+ ®¥nUx

Intentalo

iT å+ ®¥nUx     :Implicit input of array U
i               :Prepend
 T              :  Zero
   å+           :Cumulatively reduce by addition
      ®         :Map each Z
       ¥        :  Test for equality with
        n       :  Z subtracted from
         Ux     :  U reduced by addition
                :Implicitly reduce by addition and output
— Lanudo
fuente
2

PowerShell , 88 82 bytes

-6 Bytes gracias a mazzy 

param($n)0..($x=$n.length)|%{$i+=+$z-eq($n[$_..$x]|measure -Su).sum;$z+=$n[$_]};$i

Pruébalo en línea!

Esto parece un método muy torpe, pero hizo el trabajo. Intentaré renovarlo en el futuro.

— Veskah
fuente
1
puedes escribir en su $i+=<predicate>lugarif(<predicate>){$i++}
— mazzy
2

Brachylog , 9 bytes

No tan bueno como el día 1. Este pierde con Jelly

{~c₂+ᵐ=}ᶜ

Explicación

{      }ᶜ   # Count the ways to:
 ~c₂        #   Split the input array in 2 ...
    +ᵐ      #   so that their sums ...
      =     #   are equal

Paquete de prueba: ¡ Pruébelo en línea!

— Kroppeb
fuente
1

bash, 52 bytes

IFS=+;for i in 0 $@;{((c+=2*(x+=i)=="$*"));};echo $c

TIO

El truco: configuración IFS=+, se "$*"expande a una cadena donde los argumentos están delimitados por +, en expresión aritmética eval a la suma

— Nahuel Fouilleul
fuente
0

J , 19 bytes

1#.[:(={:-])0+/\@,]

Pruébalo en línea!

explicación

1 #. [: (= ({: - ])) 0 +/\@, ]

                     0     , ]  NB. prepend 0 to input...
                       +/\@     NB. and take the prefix sums...
     [:    ({: - ])             NB. then subtract that list
                                NB. from its final elm 
                                NB. (`{:`), giving the list
                                NB. of suffix sums...
     [: (= (      ))            NB. create a 1-0 list showing
                                NB. where the prefix sums 
                                NB. equal the suffix sums
1 #.                            NB. and take the sum.
— Jonás
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.