introduzione

Hai ottenuto un lavoro come ministro delle finanze nel tuo paese inventato nel tuo cortile. Hai deciso di creare la tua banca nel tuo paese per te e i tuoi amici meno affidabili. Dato che non ti fidi dei tuoi amici, hai deciso di scrivere un programma per convalidare tutte le transazioni per impedire ai tuoi amici di spendere troppo la tua valuta inventata e rovinare la tua economia.

Compito

Dato il saldo iniziale e tutte le transazioni, filtra tutte le transazioni in cui qualcuno tenta di spendere in eccesso e blocca chiunque tenti di spendere in eccesso (questo include il tentativo di spendere in eccesso a un conto chiuso) dall'utilizzare di nuovo la tua banca filtrando le transazioni future da o verso la sua / il suo conto bancario.

Input Output

Due elenchi Ae Bcome input e un elenco Ccome output. Aè il saldo iniziale di ciascun account con il formato [["Alice", 5], ["Bob", 8], ["Charlie", 2], ...]. Bè un elenco di transazioni con il formato in [["Bob", "Alice", 3], ["Charlie", "Bob", 5], ...]cui ["Bob", "Alice", 3]significa che Bob vuole pagare le unità valutarie di Alice 3. Cdovrebbe avere lo stesso formato di B. A, BE Cpuò essere in qualsiasi formato ragionevole.

Casi test

A: [["Alice", 5], ["Bob", 2]]
B: [["Alice", "Bob", 5], ["Bob", "Alice" 7]]
C: [["Alice", "Bob", 5], ["Bob", "Alice" 7]]

A: [["A", 2], ["B", 3], ["C", 5]]
B: [["C", "A", 2], ["B", "C", 4], ["A", "B", 2]]
C: [["C", "A", 2]]

A: [["A", 2], ["B", 3]]
B: [["A", "B", 2], ["A", "B", 2]]
C: [["A", "B", 2]]

A: [["A", 4], ["B", 0]]
B: [["A", "B", 1], ["A", "B", 5], ["A", "B", 2]]
C: [["A", "B", 1]]

A: [["A", 2], ["B", 3], ["C", 4]]
B: [["A", "B", 3], ["C", "B", 4]]
C: [["C", "B", 4]]

A: [["A", 2], ["B", 3], ["C", 4]]
B: [["A", "B", 3], ["B", "A", 4], ["C", "B" 2]]
C: []

punteggio

Questo è code-golf , vince il codice più breve in byte in ogni lingua.

JavaScript (ES6), 91 88 79 byte

Risparmiato 8 byte grazie a @NahuelFouilleul

Accetta input nella sintassi del curry (a)(b).

a=>b=>b.filter(([x,y,z])=>(a[x]+=z)<0&a[y]<0?a[y]-=z:0,a.map(([x,y])=>a[x]=~y))

Casi test

let f =

a=>b=>b.filter(([x,y,z])=>(a[x]+=z)<0&a[y]<0?a[y]-=z:0,a.map(([x,y])=>a[x]=~y))

console.log(JSON.stringify(f(
  [["Alice", 5], ["Bob", 2]]
)(
  [["Alice", "Bob", 5], ["Bob", "Alice", 7]]
)))

console.log(JSON.stringify(f(
  [["A", 2], ["B", 3], ["C", 5]]
)(
  [["C", "A", 2], ["B", "C", 4], ["A", "B", 2]]
)))

console.log(JSON.stringify(f(
  [["A", 2], ["B", 3]]
)(
  [["A", "B", 2], ["A", "B", 2]]
)))

console.log(JSON.stringify(f(
  [["A", 4], ["B", 0]]
)(
  [["A", "B", 1], ["A", "B", 5], ["A", "B", 2]]
)))

console.log(JSON.stringify(f(
  [["A", 2], ["B", 3], ["C", 4]]
)(
  [["A", "B", 3], ["C", "B", 4]]
)))

Abbellito e commentato

a => b =>                 // given the two lists a and b
  b.filter(([x, y, z]) => // for each (x = payer, y = payee, z = amount) in b:
    (a[x] += z) < 0 &     //   update the payer's account; if it's still valid
    a[y] < 0 ?            //   and the payee's account is also valid:
      a[y] -= z           //     update the payee's account
    :                     //   else:
      0,                  //     do nothing
    a.map(([x, y]) =>     //   initialization: for each (x = owner, y = amount) in a:
      a[x] = ~y           //     set up this account (>= 0: closed, -1: $0, -2: $1, etc.)
    )                     //   end of map()
  )                       // end of filter()

Perl 5, 72 + 2 (-ap) = 74 byte

%h=@F;$_=<>;s/(\S+) (\S+) (\S+)/($h{$1}-=$3)<0||($h{$2}+=$3)<$3?"":$&/ge

provalo online

Python 2 , 103 byte

A,B=input()
C=[]
for i in B:
 N,P,M=i
 if M>A[N]:A[N]=-1
 if A[N]>-1<A[P]:A[N]-=M;A[P]+=M;C+=i,
print C

Provalo online!

-12 grazie agli ovs .

Più a causa delle restrizioni sul formato di output:

Cdovrebbe avere lo stesso formato di B.

Altrimenti avrei potuto farlo per 92 byte:

A,B=input()
for(N,P,M)in B:
 if M>A[N]:A[N]=-1
 if A[N]>-1<A[P]:A[N]-=M;A[P]+=M;print(N,P,M)

Rubino , 57 byte

->a,b{b.select{|(s,r,x)|a[r]+=x if[a[s]-=x,a[r]].min>-1}}

Provalo online!

Accetta input Acome Hashnel formato {"A"=>2, "B"=>3}. L'input Be l'output Csono nel formato suggerito.

Spiegazione

->a,b{                      # lambda function taking arguments A and B
b.select{|(s,r,x)|              # select items in B that return truthy (s = sender, r = receiver, x = amount)
            a[s]-=x,                # subtract amount from sender
        if [         a[r]].min>-1   # check if the smaller of the balances is non-negative
                                    # (true if both values are non-negative)
a[r]+=x                             # if so, add to the receiver's balance
}                               # the select function returns truthy when the above if statement passes
}

C ++, 193 byte

Immettere A come std::map, B come std::list.

#import<bits/stdc++.h>
using s=std::string;struct p{s a,b;int c;};using t=std::list<p>;t f(std::map<s,int>A,t B){t C;for(p&i:B)(A[i.a]-=i.c)<0|A[i.b]<0?0:(C.push_back(i),A[i.b]+=i.c);return C;}

Provalo online!