Aristides
Senior Member
ờm chỗ speedSum toy ko để ý![]()
mà lạ vậy pq size là k vẫn đúng àà chắc vì xét max sau khi -= nên vẫn đúng![]()
Đây trư re-submit lại lần thứ n vẫn đúng: https://leetcode.com/submissions/detail/797171689/
ờm chỗ speedSum toy ko để ý![]()
mà lạ vậy pq size là k vẫn đúng àà chắc vì xét max sau khi -= nên vẫn đúng![]()
down để lấy power, phần II là nothing không làm gì cả, phần III là up gồm nhưng token giá trị nhỏ để score,down thì cần score >= 1 nên nếu từ đầu power nhỏ hơn token nhỏ nhất thì trả về 0 luôn.T lại thấy bài hôm nay dễ hơn,220912: 948. Bag of Tokens
Bài hôm nay medium mà thấy khó hơn 2 bài hard cuối tuần. Mãi mới ra được cách O(n^2) 5%. Nhưng có thể optimize thành O(nlogn) hoặc O(n).
. Dùng 2 pointers thôiMình cũng làm như này, mà lúc đầu ko để ý dính 2 cái edge case [] với [26],51T lại thấy bài hôm nay dễ hơn,. Dùng 2 pointers thôi
B1: Sort cái tokens
B2: Dùng indies bên trái và bên phải để loop qua cái tokens. Face up thì lấy token bên trái (mất ít power nhất). Face down thì lấy bên phải (được nhiều power nhất).
https://leetcode.com/submissions/detail/797693682/


struct Solution {
int bagOfTokensScore(vector<int>& tokens, int power) {
sort(begin(tokens), end(tokens));
for (int i = 0, j = tokens.size() - 1, score = 0;;) {
while (i <= j && power >= tokens[i]) power -= tokens[i++], ++score;
if (score == 0 || i >= j || tokens[j] + power < tokens[i]) return score;
power += tokens[j--], --score;
}
}
};
k phải là k có, chính xác hơn là k cần,ủa mà hàm trong Python không có chức năng "Khai báo trước" (Forward declaration) à các bác?![]()
. nó bind tại run time mà
defmodule Solution do
def bag_of_tokens_score(tokens, power) do
play(
tokens |> Enum.sort(),
tokens |> Enum.sort(:desc),
power,
tokens |> Enum.count(),
0,
0
)
end
defp play(_up, _down, _power, n, played, score) when played == n, do: score
defp play([cost | c_rest] = up, [restore | r_rest] = down, power, n, played, score) do
cond do
power >= cost -> play(c_rest, down, power - cost, n, played + 1, score + 1)
score == 0 or played == n - 1 -> score
true -> play(up, r_rest, power + restore, n, played + 1, score - 1)
end
end
end
class Solution:
def bagOfTokensScore(self, tokens: List[int], power: int) -> int:
tokens=sorted(tokens)
left,right=0,len(tokens)-1
score, res = 0, 0
while left<=right and power>=tokens[left]:
score+=1
power-=tokens[left]
left+=1
res=max(res,score)
while left<=right and power<tokens[left] and score>=1:
power+=tokens[right]
right-=1
score-=1
return res
class Solution:
def bagOfTokensScore(self, tokens: List[int], power: int) -> int:
tokens.sort()
l, r = 0, len(tokens) - 1
res, res_max = 0, 0
while l <= r:
while l <= r and power >= tokens[l]:
power -= tokens[l]
res += 1
l += 1
res_max = max(res_max, res)
if res >= 1:
res -= 1
power += tokens[r]
r -= 1
if l <= r and res == 0 and power < tokens[l]:
break
return res_max

class Solution:
def validUtf8(self, data: List[int]):
def check_type(num):
if 0 <= num <= 127:
return 0
elif num <= 191:
return -1
elif num <= 223:
return 1
elif num <= 239:
return 2
elif num <= 247:
return 3
else:
return None
remain = 0
for num in data:
tp = check_type(num)
# print(remain, tp)
if tp is None:
return False
if remain == 0 and tp < 0:
return False
elif remain > 0 and tp >= 0:
return False
remain += tp
if remain == 0:
return True
else:
return False
return
all_of tiện hơn
struct Solution {
bool validUtf8(vector<int>& data, int remainingBytes = 0) {
return all_of(begin(data), end(data), [&](int byte){
return ((byte >> 7) == 0b0 && !remainingBytes) ||
((byte >> 6) == 0b10 && remainingBytes--) ||
((byte >> 5) == 0b110 && !exchange(remainingBytes, 1)) ||
((byte >> 4) == 0b1110 && !exchange(remainingBytes, 2)) ||
((byte >> 3) == 0b11110 && !exchange(remainingBytes, 3));
}) && !remainingBytes;
}
};
struct Solution {
bool validUtf8(vector<int>& data, int remainingBytes = 0) {
return all_of(begin(data), end(data), [&](int byte){
return byte >> 7 == 0b0 && !remainingBytes ||
byte >> 6 == 0b10 && remainingBytes-- ||
byte >> 5 == 0b110 && !exchange(remainingBytes, 1) ||
byte >> 4 == 0b1110 && !exchange(remainingBytes, 2) ||
byte >> 3 == 0b11110 && !exchange(remainingBytes, 3);
}) && !remainingBytes;
}
};
defmodule Solution do
def valid_utf8(data), do: check(Enum.map(data, &to_bin/1))
defp check([]), do: true
defp check(["0" <> _ | rest]), do: check(rest)
defp check(["110" <> _, "10" <> _ | rest]), do: check(rest)
defp check(["1110" <> _, "10" <> _, "10" <> _ | rest]), do: check(rest)
defp check(["11110" <> _, "10" <> _, "10" <> _, "10" <> _ | rest]), do: check(rest)
defp check(_), do: false
defp to_bin(num), do: :io_lib.format("~8.2.0B", [num]) |> List.to_string()
end
chắc là do ko check đủ hết điều kiện valid utf-8. Có thằng xài Pythoncái bài gì mà dislike nhiều hơn like thế này?
.decode('utf8') để check thì ra xai vì utf8 hiện tại chỉ encode 17 planes = 16 * 2^16 = 1,114,112 code points thoy
Cái code này mà vẫn pass đc hả?
