कम भरोसेमंद दोस्तों के लिए एक बैंक

Question

परिचय

आपने अपने बैक यार्ड में अपने बनाए देश में वित्त मंत्री के रूप में नौकरी प्राप्त की है। आपने अपने और अपने कम भरोसेमंद दोस्तों के लिए अपने देश में अपना बैंक बनाने का फैसला किया है। चूंकि आप अपने दोस्तों पर भरोसा नहीं करते हैं, इसलिए आपने अपने दोस्तों को अपनी बनाई हुई मुद्रा को ओवरस्पीड करने और अपनी अर्थव्यवस्था को बर्बाद करने से रोकने के लिए सभी लेनदेन को मान्य करने के लिए एक कार्यक्रम लिखने का फैसला किया है।

कार्य

शुरुआती शेष राशि और सभी लेन-देन को देखते हुए, उन सभी लेनदेन को फ़िल्टर करें, जहाँ कोई व्यक्ति किसी ऐसे व्यक्ति की देखरेख करने और उसे ब्लॉक करने का प्रयास करता है, जो भविष्य में होने वाले लेन-देन को फ़िल्टर करके या फिर से अपने बैंक का उपयोग करके किसी बंद खाते की देखरेख करने की कोशिश करता है (जिसमें एक बंद खाते की देखरेख करना भी शामिल है)। / उसका बैंक खाता

इनपुट आउटपुट

दो सूचियों Aऔर Bइनपुट के रूप में और Cआउटपुट के रूप में एक सूची । Aप्रारूप के साथ प्रत्येक खाते का प्रारंभिक संतुलन है [["Alice", 5], ["Bob", 8], ["Charlie", 2], ...]। Bप्रारूप के साथ लेनदेन की एक सूची है [["Bob", "Alice", 3], ["Charlie", "Bob", 5], ...], जहां ["Bob", "Alice", 3]साधन बॉब ऐलिस 3 मुद्रा इकाइयों का भुगतान करना चाहता है। Cजैसा प्रारूप होना चाहिए B। A, Bऔर Cकिसी भी उचित प्रारूप में हो सकता है।

परीक्षण के मामलों

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

स्कोरिंग

यह कोड-गोल्फ है , प्रत्येक भाषा में बाइट्स में सबसे छोटा कोड जीतता है।

Comments

IO प्रारूप कितना सख्त है? कर सके Aयह भी एक शब्दकोश, या tuples की एक सूची हो सकता है?

— लैकोनी

@ लिकोनी या सिर्फ फॉर्म की एक सूची ["A", 2, "B", 3, "C", 5]?

— निकोलग्राफ

सुझाए गए परीक्षण का मामला: A: [["A", 2], ["B", 3], ["C", 4]], B: [["A", "B", 3], ["C", "B", 4]], C: [["C", "B", 4]](गलत एक के बाद एक वैध लेनदेन)।

— अरनौलद

यदि कोई व्यक्ति ओवरस्पीड करने का प्रयास करता है, और इच्छित प्राप्तकर्ता पहले ही ओवरस्पेंड कर चुका है, तो क्या होगा?

— नाइट्रोडॉन

दूसरे और तीसरे टेस्ट मामलों में ["बी" 3] में कोई कॉमा नहीं है

— जो किंग

Answer 1

जावास्क्रिप्ट (ईएस 6), 91 88 79 बाइट्स

@NahuelFouilleul के लिए 8 बाइट्स धन्यवाद सहेजे गए

करी सिंटैक्स में इनपुट लेता है (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))

परीक्षण के मामलों

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

सुशोभित और टिप्पणी की

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()

Comments

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+1))जावास्क्रिप्ट के लिए पर्ल समाधान के बारे में क्या ?

— नहुएल फौलीउल

@NahuelFouilleul वास्तव में बेहतर है। धन्यवाद!

— अरनौलद

Answer 2

पर्ल 5, 72 + 2 (-प) = 74 बाइट्स

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

इसे ऑनलाइन आज़माएं

Answer 3

पायथन 2 , 103 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-12 ओवी के लिए धन्यवाद ।

आउटपुट स्वरूप प्रतिबंधों के कारण लंबा:

Cजैसा प्रारूप होना चाहिए B।

अन्यथा मैं 92 बाइट्स के लिए यह कर सकता था:

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)

Comments

103 बाइट्स

— ओव्स

@ नोव्स वाह, यह चतुर है

— एरिक आउट द आउटगलर

Answer 4

रूबी , 57 बाइट्स

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

इसे ऑनलाइन आज़माएं!

प्रारूप में Aएक के रूप Hashमें इनपुट लेता है {"A"=>2, "B"=>3}। इनपुट Bऔर आउटपुट Cसुझाए गए प्रारूप में हैं।

व्याख्या

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

Answer 5

सी ++, 193 बाइट्स

के रूप में इनपुट एक std::map, के रूप में बी 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;}

इसे ऑनलाइन आज़माएं!