Contas paralelas (dia 2)

10

Desafio Tomado com permissão do meu Concurso de Desafio de Código da Universidade


Depois de terminar seus estudos há alguns meses, Marie abriu uma conta bancária para começar a receber o pagamento de seu primeiro emprego na cidade. Desde então, ela vem realizando algumas transações com ele. Seu primeiro pagamento foi de US $ 1000. Com esse dinheiro, ela pagou por um jantar no qual convidou seus pais (o jantar custou US $ 150 dólares); depois, fez uma compra em um supermercado conhecido (US $ 80 dólares) e uma reserva de hotel para suas férias (US $ 200). No final do mês, ela recebeu seu pagamento novamente (1040 dólares, um pouco mais que o mês anterior) e no dia seguinte ela gastou outros 70 dólares no supermercado.

Hoje, ela percebeu que se depois de pagar os primeiros US $ 80 no supermercado uma segunda conta tivesse sido criada e a primeira congelada, as duas contas teriam exatamente o mesmo saldo:

1000-150-80Totumaeu=770-2001040-70Totumaeu=770

O evento foi tão raro para ela que ela deseja continuar verificando se os movimentos de sua conta e os de seus amigos também têm esse recurso ou não.

Desafio

Dada uma lista de transações, produza o número de instantes de tempo em que o proprietário da conta bancária poderia ter criado uma segunda conta para que ambos tivessem o mesmo saldo final.

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

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

Caso de teste

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

Notas

Luis felipe De jesus Munoz
fonte
11
Após 6 meses de contas congeladas e recém-criadas, é relatado que o banqueiro de Marie agora está internado em um sanatório. "Nós somos seus amigos. Você precisa descansar", disseram eles.
Arnauld
2
Caso de teste sugerido para uma única transação
Veskah 08/02/19

Respostas:

4

Perl 6 , 25 bytes

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

Experimente online!

Explicação

Apenas adicionamos um zero à lista fornecida ( 0,|$_), fazemos uma sequência de somas parciais com [\+](ou seja, a sequência formada pelo primeiro elemento, a soma dos dois primeiros, a soma dos três primeiros etc.) e procuramos ( grep) por qualquer elementos exatamente iguais à metade do estado final da conta (soma da lista fornecida). Finalmente, contamos com um +.

Ramillies
fonte
3

05AB1E , 11 bytes

0.ø.œ2ùO€ËO

Experimente online ou verifique todos os casos de teste .

Explicação:

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
fonte
3

JavaScript (Node.js) , 45 bytes

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

Experimente online!

Salve 4 bytes usando -~o[s]. Graças a Shaggy.

tsh
fonte
+1 por bater em Arnauld: o
Luis felipe De jesus Munoz
45 bytes
Shaggy,
@LuisfelipeDejesusMunoz, Arnauld não é (sempre) imbatível! ;)
Shaggy
O @Shaggy líder +é alterado para !, para que possa funcionar como entrada [100].
tsh
Ah, não sabia que tínhamos que lidar com matrizes singleton. Bem arrumado.
Shaggy
2

Perl 5 -p , 42 41 bytes

@NahuelFouilleul salva um byte

y/ /+/;$\+=eval$'==eval$`while/^|$|\+/g}{

Experimente online!

Xcali
fonte
y/ /+/;salva 1 byte
Nahuel Fouilleul 07/02/19
34 bytes usando outra abordagem
Nahuel Fouilleul 7/19/19
30 bytes
Nahuel Fouilleul 07/02/19
2

JavaScript (ES6), 52 bytes

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

Experimente online!

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

Versão recursiva,  54  53 bytes

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

Experimente online!

Arnauld
fonte
Eu estava prestes a sugerir essa versão de 52 bytes!
Shaggy
@ Shagy Sim, eu descartei a versão não recursiva muito cedo, porque pensei que a recursiva poderia ser mais curta.
Arnauld
2

APL (Dyalog Unicode) , SBCS de 21 bytes

Função de prefixo tácito anônimo

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

Experimente online!

Ɩ ndices  da contagem de transações

0, preceder zero

⊂()¨⍨ Aplique a seguinte função tácita com cada um deles como argumento à esquerda e a lista inteira de transações como argumento à direita ( argumento de troca

 a lista inteira de transações
() como argumento da esquerda para a função abaixo
  ¨ aplicada a cada um dos índices
    com argumentos trocados (ou seja, lista à direita, índices à esquerda:

   largar muitos da esquerda

  1⊥ soma (lit. avaliar na base-1)

  ()= É (0/1) igual a…

    tome que muitas transações da esquerda

   +/ somar eles

+/ somar essa lista booleana para obter a contagem de verdades

Adão
fonte
2

Lote, 84 bytes

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

Recebe entrada como argumentos da linha de comando. Explicação:

@set s=%*

Junte os argumentos com espaços.

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

Substitua os espaços por se +avalie o resultado. Limpe também a contagem.

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

Para cada quantia, subtraia o dobro da soma. Se o resultado for zero, essa é uma correspondência válida, então aumente a contagem. O zero extra no início permite uma correspondência antes de qualquer valor.

@echo %c%

Imprima o resultado.

Neil
fonte
2

Carvão , 15 bytes

⊞θ⁰IΣEθ⁼Σθ⊗Σ✂θκ

Experimente online! Link é a versão detalhada do código. Explicação:

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

Infelizmente no carvão Sum([])não é 0assim que eu tenho que garantir que sempre haja pelo menos um elemento a ser somado.

Neil
fonte
2

Python 3 , 67 58 bytes

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

Experimente online!

-9 bytes graças a @ Não seja um ponto x triplo

Black Owl Kai
fonte
11
Resumindo, em vez de filtragem você vai economizar 7 bytes: lambda l:sum(sum(l[:x])==sum(l[x:])for x in range(len(l)+1)).
Mr. Xcoder
sum(l[:x])*2==sum(l)economiza mais 2 bytes.
Neil
2

R , 50 bytes 37

sum(c(0,cumsum(x<-scan()))==sum(x)/2)

Experimente online!

Kirill L.
fonte
2

MATL , 9 bytes

s0GhYsE=s

Experimente online!

A mesma abordagem de algumas outras respostas: adicione um zero e verifique com que frequência a metade da soma acumulada é igual à soma 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
fonte
2

Japonês -x , 14 11 bytes

iT å+ ®¥nUx

Tente

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
Shaggy
fonte
2

PowerShell , 88 82 bytes

-6 Bytes graças a mazzy

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

Experimente online!

Parece um método muito desajeitado, mas conseguiu o trabalho. Vou tentar reformá-lo no futuro.

Veskah
fonte
11
você pode escrever em $i+=<predicate>vez dissoif(<predicate>){$i++}
mazzy 08/02/19
2

Brachylog , 9 bytes

Não é tão bom quanto o dia 1. Este perde para Jelly

{~c₂+ᵐ=}ᶜ

Explicação

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

Conjunto de testes: Experimente online!

Kroppeb
fonte
1

bash, 52 bytes

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

TIO

O truque: setting IFS=+, "$*"expande para uma string onde os argumentos são delimitados por +, na expressão aritmética eval à soma

Nahuel Fouilleul
fonte
0

J , 19 bytes

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

Experimente online!

explicação

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.
Jonah
fonte