2043-简易银行系统

Raphael Liu Lv10
  2023-09-13 00:47:26 2023-09-13 00:47:26 Created   2023-09-13 16:06:29 2023-09-13 16:06:29 Updated    

你的任务是为一个很受欢迎的银行设计一款程序，以自动化执行所有传入的交易（转账，存款和取款）。银行共有 n 个账户，编号从 1 到 n
。每个账号的初始余额存储在一个下标从 0 开始的整数数组 balance 中，其中第 (i + 1) 个账户的初始余额是
balance[i] 。

请你执行所有 有效的 交易。如果满足下面全部条件，则交易 有效 ：

  • 指定的账户数量在 1 和 n 之间，且
  • 取款或者转账需要的钱的总数 小于或者等于 账户余额。

实现 Bank 类：

  • Bank(long[] balance) 使用下标从 0 开始的整数数组 balance 初始化该对象。
  • boolean transfer(int account1, int account2, long money) 从编号为 account1 的账户向编号为 account2 的账户转帐 money 美元。如果交易成功，返回 true ，否则，返回 false 。
  • boolean deposit(int account, long money) 向编号为 account 的账户存款 money 美元。如果交易成功，返回 true ；否则，返回 false 。
  • boolean withdraw(int account, long money) 从编号为 account 的账户取款 money 美元。如果交易成功，返回 true ；否则，返回 false 。

示例：

**输入** ：
["Bank", "withdraw", "transfer", "deposit", "transfer", "withdraw"]
[[[10, 100, 20, 50, 30]], [3, 10], [5, 1, 20], [5, 20], [3, 4, 15], [10, 50]]
**输出：**
[null, true, true, true, false, false]

**解释：**
Bank bank = new Bank([10, 100, 20, 50, 30]);
bank.withdraw(3, 10);    // 返回 true ，账户 3 的余额是 20 ，所以可以取款 10 。
                         // 账户 3 余额为 20 - 10 = 10 。
bank.transfer(5, 1, 20); // 返回 true ，账户 5 的余额是 30 ，所以可以转账 20 。
                         // 账户 5 的余额为 30 - 20 = 10 ，账户 1 的余额为 10 + 20 = 30 。
bank.deposit(5, 20);     // 返回 true ，可以向账户 5 存款 20 。
                         // 账户 5 的余额为 10 + 20 = 30 。
bank.transfer(3, 4, 15); // 返回 false ，账户 3 的当前余额是 10 。
                         // 所以无法转账 15 。
bank.withdraw(10, 50);   // 返回 false ，交易无效，因为账户 10 并不存在。

提示：

  • n == balance.length
  • 1 <= n, account, account1, account2 <= 105
  • 0 <= balance[i], money <= 1012
  • transfer, deposit, withdraw 三个函数， 每个 最多调用 104 次

方法一：模拟

思路与算法

已有的帐号为 1 到 n，分别对三种操作进行分析：

  • transfer 操作

    如果要进行操作的帐号不在已有的帐号中，即 account1} > n 或者 account2} > n，那么交易无效。如果账号 account1 的余额小于 money，那么交易无效。交易有效时，我们将账号 account1 的余额减少 money，账号 account2 的余额增加 money。

  • deposit 操作

    如果要进行操作的帐号不在已有的帐号中，即 account} > n，那么交易无效。交易有效时，我们将账号 account 的余额增加 money。

  • withdraw 操作

    如果要进行操作的帐号不在已有的帐号中，即 account} > n，那么交易无效。如果账号 account 的余额小于 money，那么交易无效。交易有效时，我们将账号 account 的余额减少 money。

代码

[sol1-Python3]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Bank:
    def __init__(self, balance: List[int]):
        self.balance = balance

    def transfer(self, account1: int, account2: int, money: int) -> bool:
        if account1 > len(self.balance) or account2 > len(self.balance) or self.balance[account1 - 1] < money:
            return False
        self.balance[account1 - 1] -= money
        self.balance[account2 - 1] += money
        return True

    def deposit(self, account: int, money: int) -> bool:
        if account > len(self.balance):
            return False
        self.balance[account - 1] += money
        return True

    def withdraw(self, account: int, money: int) -> bool:
        if account > len(self.balance) or self.balance[account - 1] < money:
            return False
        self.balance[account - 1] -= money
        return True
[sol1-C++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Bank {
private:
    vector<long long> balance;

public:
    Bank(vector<long long>& balance) : balance(balance) {}

    bool transfer(int account1, int account2, long long money) {
        if (account1 > balance.size() || account2 > balance.size() || balance[account1 - 1] < money) {
            return false;
        }
        balance[account1 - 1] -= money;
        balance[account2 - 1] += money;
        return true;
    }

    bool deposit(int account, long long money) {
        if (account > balance.size()) {
            return false;
        }
        balance[account - 1] += money;
        return true;
    }

    bool withdraw(int account, long long money) {
        if (account > balance.size() || balance[account - 1] < money) {
            return false;
        }
        balance[account - 1] -= money;
        return true;
    }
};
[sol1-Java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Bank {
    long[] balance;

    public Bank(long[] balance) {
        this.balance = balance;
    }

    public boolean transfer(int account1, int account2, long money) {
        if (account1 > balance.length || account2 > balance.length || balance[account1 - 1] < money) {
            return false;
        }
        balance[account1 - 1] -= money;
        balance[account2 - 1] += money;
        return true;
    }

    public boolean deposit(int account, long money) {
        if (account > balance.length) {
            return false;
        }
        balance[account - 1] += money;
        return true;
    }

    public boolean withdraw(int account, long money) {
        if (account > balance.length || balance[account - 1] < money) {
            return false;
        }
        balance[account - 1] -= money;
        return true;
    }
}
[sol1-C#]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Bank {
    long[] balance;

    public Bank(long[] balance) {
        this.balance = balance;
    }

    public bool Transfer(int account1, int account2, long money) {
        if (account1 > balance.Length || account2 > balance.Length || balance[account1 - 1] < money) {
            return false;
        }
        balance[account1 - 1] -= money;
        balance[account2 - 1] += money;
        return true;
    }

    public bool Deposit(int account, long money) {
        if (account > balance.Length) {
            return false;
        }
        balance[account - 1] += money;
        return true;
    }

    public bool Withdraw(int account, long money) {
        if (account > balance.Length || balance[account - 1] < money) {
            return false;
        }
        balance[account - 1] -= money;
        return true;
    }
}
[sol1-C]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
typedef struct {
    long long * balance;
    int balanceSize;
} Bank;

Bank* bankCreate(long long* balance, int balanceSize) {
    Bank * obj = (Bank *)malloc(sizeof(Bank));
    obj->balance = (long long *)malloc(sizeof(long long) * balanceSize);
    obj->balanceSize = balanceSize;
    memcpy(obj->balance, balance, sizeof(long long) * balanceSize);
    return obj;
}

bool bankTransfer(Bank* obj, int account1, int account2, long long money) {
    if (account1 > obj->balanceSize || account2 > obj->balanceSize || obj->balance[account1 - 1] < money) {
        return false;
    }
    obj->balance[account1 - 1] -= money;
    obj->balance[account2 - 1] += money;
    return true;
}

bool bankDeposit(Bank* obj, int account, long long money) {
    if (account > obj->balanceSize) {
        return false;
    }
    obj->balance[account - 1] += money;
    return true;
}

bool bankWithdraw(Bank* obj, int account, long long money) {
    if (account > obj->balanceSize || obj->balance[account - 1] < money) {
        return false;
    }
    obj->balance[account - 1] -= money;
    return true;
}

void bankFree(Bank* obj) {
    free(obj->balance);
}
[sol1-JavaScript]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
var Bank = function(balance) {
    this.balance = balance;
};

Bank.prototype.transfer = function(account1, account2, money) {
    if (account1 > this.balance.length || account2 > this.balance.length || this.balance[account1 - 1] < money) {
        return false;
    }
    this.balance[account1 - 1] -= money;
    this.balance[account2 - 1] += money;
    return true;
};

Bank.prototype.deposit = function(account, money) {
    if (account > this.balance.length) {
        return false;
    }
    this.balance[account - 1] += money;
    return true;
};

Bank.prototype.withdraw = function(account, money) {
    if (account > this.balance.length || this.balance[account - 1] < money) {
        return false;
    }
    this.balance[account - 1] -= money;
    return true;
};
[sol1-Golang]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
type Bank []int64

func Constructor(balance []int64) Bank {
    return balance
}

func (b Bank) Transfer(account1, account2 int, money int64) bool {
    if account1 > len(b) || account2 > len(b) || b[account1-1] < money {
        return false
    }
    b[account1-1] -= money
    b[account2-1] += money
    return true
}

func (b Bank) Deposit(account int, money int64) bool {
    if account > len(b) {
        return false
    }
    b[account-1] += money
    return true
}

func (b Bank) Withdraw(account int, money int64) bool {
    if account > len(b) || b[account-1] < money {
        return false
    }
    b[account-1] -= money
    return true
}

复杂度分析

  • 时间复杂度：

    • transfer：O(1)；
    • deposit：O(1)；
    • withdraw：O(1)。

  • 空间复杂度：

    • 初始化：O(n)，其中 n 为已有的帐号数目。
    • transfer：O(1)；
    • deposit：O(1)；
    • withdraw：O(1)。
 Comments
On this page
2043-简易银行系统