introduction

Vous avez obtenu un emploi en tant que ministre des Finances dans votre pays inventé dans votre arrière-cour. Vous avez décidé de créer votre propre banque dans votre pays pour vous et vos amis moins fiables. Puisque vous ne faites pas confiance à vos amis, vous avez décidé d'écrire un programme pour valider toutes les transactions afin d'empêcher vos amis de dépenser trop cher et de ruiner votre économie.

Tâche

Compte tenu du solde de départ et de toutes les transactions, filtrez toutes les transactions où quelqu'un essaie de dépenser trop et empêchez toute personne qui essaie de dépenser trop (cela inclut essayer de dépenser trop pour un compte fermé) de ne plus jamais utiliser votre banque en filtrant les transactions futures vers ou depuis son / son compte bancaire.

Entrée sortie

Deux listes Aet Ben entrée et une liste Cen sortie. Aest le solde de départ de chaque compte au format [["Alice", 5], ["Bob", 8], ["Charlie", 2], ...]. Best une liste de transactions au format [["Bob", "Alice", 3], ["Charlie", "Bob", 5], ...]où ["Bob", "Alice", 3]Bob veut payer Alice 3 unités monétaires. Cdevrait avoir le même format que B. A, BEt Cpeut - être dans tout format raisonnable.

Cas de 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: []

Notation

C'est le code-golf , le code le plus court en octets dans chaque langue gagne.

JavaScript (ES6), 91 88 79 octets

8 octets enregistrés grâce à @NahuelFouilleul

Prend des entrées dans la syntaxe de 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))

Cas de 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]]
)))

Embellie et commentée

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 octets

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

essayez-le en ligne

Python 2 , 103 octets

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

Essayez-le en ligne!

-12 grâce aux ovs .

Plus longue en raison des restrictions de format de sortie:

Cdevrait avoir le même format que B.

Sinon, j'aurais pu le faire pour 92 octets:

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)

Rubis , 57 octets

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

Essayez-le en ligne!

Prend l'entrée en Atant que Hashdans le format {"A"=>2, "B"=>3}. L'entrée Bet la sortie Csont dans le format suggéré.

Explication

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

Entrez A as std::map, B as 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;}

Essayez-le en ligne!