Conti paralleli (giorno 2)


10

La sfida è stata presa con il permesso del mio concorso per la sfida del codice universitario


Dopo aver terminato gli studi un paio di mesi fa, Marie ha aperto un conto in banca per iniziare a ricevere il pagamento del suo primo lavoro in città. Da allora ha effettuato alcune transazioni con esso. Il suo primo pagamento è stato di $ 1000 dollari. Con quei soldi che ha pagato per una cena in cui ha invitato i suoi genitori (la cena è costata $ 150 dollari), poi, ha fatto un acquisto in un noto supermercato ($ 80 dollari) e una prenotazione d'albergo per le sue vacanze ($ 200). Alla fine del mese ha ricevuto di nuovo il suo pagamento (1040 dollari, un po 'più del mese precedente) e il giorno dopo ha speso altri $ 70 dollari al supermercato.

Oggi, ha capito che se dopo aver pagato i primi $ 80 dollari al supermercato fosse stato creato un secondo account e il primo congelato, entrambi i conti avrebbero avuto esattamente lo stesso saldo:

100015080Total=770200104070Total=770

L'evento è stato così raro per lei che vuole continuare ad accertare se i movimenti del suo account e quelli dei suoi amici hanno anche questa caratteristica o meno.

Sfida

Dato un elenco di transazioni, visualizza il numero di istanti di tempo in cui il proprietario del conto bancario avrebbe potuto creare un secondo conto in modo che entrambi avessero lo stesso saldo finale.

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

1)Total=0100015080200104070Total=1540
2)1000Total=100015080200104070Total=540
3)1000150Total=85080200104070Total=690
4)100015080Total=770200104070Total=770
5)100015080200Total=570104070Total=970
6)1000150802001040Total=161070Total=70
7)100015080200104070Total=1540Total=0

Caso di prova

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

Appunti


11
Dopo 6 mesi di conti congelati e di nuova creazione, è stato riferito che il banchiere di Marie è ora internato in un ospedale. "Siamo tuoi amici. Hai bisogno di riposare", dissero.
Arnauld

2
Caso di prova suggerito per una singola transazione
Veskah

Risposte:



4

Perl 6 , 25 byte

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

Provalo online!

Spiegazione

Basta anteporre uno zero all'elenco dato ( 0,|$_), fare una sequenza di somme parziali con [\+](cioè la sequenza formata dal primo elemento, la somma dei primi due, la somma dei primi tre ecc.), E cercare ( grep) per qualsiasi elementi esattamente uguali alla metà dello stato del conto finale (somma dell'elenco fornito). Infine, li contiamo con a +.


3

05AB1E , 11 byte

0.ø.œ2ùO€ËO

Provalo online o verifica tutti i casi di test .

Spiegazione:

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


3

JavaScript (Node.js) , 45 byte

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

Provalo online!

Salvare 4 byte utilizzando -~o[s]. Grazie a Shaggy.


+1 per aver battuto Arnauld: o
Luis felipe De jesus Munoz


@LuisfelipeDejesusMunoz, Arnauld non è (sempre) imbattibile! ;)
Shaggy

Il comando @Shaggy +viene modificato in !, quindi potrebbe funzionare per l'input [100].
martedì

Ah, non avevo capito che dovevamo gestire le matrici singleton. Ben riparato
Shaggy,


2

JavaScript (ES6), 52 byte

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

Provalo online!

Commentate

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

Versione ricorsiva,  54  53 byte

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

Provalo online!


Stavo per suggerire quella versione a 52 byte!
Shaggy,

@Shaggy Sì, ho scartato la versione non ricorsiva troppo presto perché pensavo che quella ricorsiva potesse essere più breve.
Arnauld

2

APL (Dyalog Unicode) , 21 byte SBCS

Funzione prefisso tacito anonimo

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

Provalo online!

d ndice
 del
 conteggio delle transazioni

0, anteporre zero

⊂(... )¨⍨ applica la seguente funzione tacita con ognuna di esse come argomento di sinistra e l'intero elenco di transazioni come argomento di destra ( argomento di scambio

 l'intero elenco delle transazioni
(... ) come argomento di sinistra alla funzione di seguito
  ¨ applicata a ciascuno degli indici
    con argomenti scambiati (cioè elenco a destra, indici a sinistra:

   lascia cadere molti da sinistra

  1⊥ somma (lett. valuta in base-1)

  (... )= è (0/1) uguale a ...

    prendi molte transazioni da sinistra

   +/ sommarli

+/ somma quell'elenco booleano per ottenere il conteggio delle verità


2

Lotto, 84 byte

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

Accetta input come argomenti della riga di comando. Spiegazione:

@set s=%*

Unisci gli argomenti con gli spazi.

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

Sostituisci gli spazi con +s e valuta il risultato. Cancella anche il conteggio.

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

Per ogni importo, sottrarre il doppio dalla somma. Se il risultato è zero, allora questa è una corrispondenza valida, quindi incrementa il conteggio. Lo zero aggiuntivo all'inizio consente una corrispondenza prima di qualsiasi importo.

@echo %c%

Stampa il risultato.


2

Carbone , 15 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

 θ              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

Purtroppo in Carbone Sum([])non è 0così, quindi devo assicurarmi che ci sia sempre almeno un elemento da sommare.


2

Python 3 , 67 58 byte

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

Provalo online!

-9 byte grazie a @ Non essere un punto x-triple


1
Sommando invece di filtraggio vi farà risparmiare 7 byte: lambda l:sum(sum(l[:x])==sum(l[x:])for x in range(len(l)+1)).
Mr. Xcoder

sum(l[:x])*2==sum(l)ti salva altri 2 byte.
Neil


2

MATL , 9 byte

s0GhYsE=s

Provalo online!

Stesso approccio di alcune altre risposte: anteporre uno zero e verificare quanto spesso metà della somma cumulativa è uguale alla somma totale.

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

2

Japt -x , 14 11 byte

iT å+ ®¥nUx

Provalo

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

2

PowerShell , 88 82 byte

-6 byte grazie a mazzy

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

Provalo online!

Sembra un metodo molto goffo ma ha fatto il suo lavoro. Proverò a rinnovarlo in futuro.


1
$i+=<predicate>invece puoi scrivereif(<predicate>){$i++}
mazzy


2

Brachylog , 9 byte

Non buono come il giorno 1. Questo perde a Jelly

{~c₂+ᵐ=}ᶜ

Spiegazione

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

Test suite: provalo online!


1

bash, 52 byte

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

TIO

Il trucco: impostazione IFS=+, si "$*"espande in una stringa in cui gli argomenti sono delimitati +, nell'espressione aritmetica eval alla somma



0

J , 19 byte

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

Provalo online!

spiegazione

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.
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.