Skip to content

Commit 1dacc3b

Browse files
MaskRayMaskRay
committed
misc
1 parent 057d4aa commit 1dacc3b

23 files changed

+535
-13
lines changed

‎24-game.nim

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
proc judgePoint24(cards: ptr UncheckedArray[cint], cardsSize: cint): cint {.exportc.} =
2+
var a: array[4, float]
3+
proc dfs(n: int): bool =
4+
if n == 0:
5+
return abs(a[0]-24) < 1e-8
6+
for i in 0..n:
7+
swap a[i], a[n]
8+
for j in 0..<n:
9+
let saved = a[j]
10+
a[j] = a[n-1]
11+
if (a[n-1]=saved+a[n]; dfs(n-1)) or
12+
(a[n-1]=saved-a[n]; dfs(n-1)) or
13+
(a[n-1]=saved*a[n]; dfs(n-1)) or
14+
(a[n-1]=saved/a[n]; a[n].abs > 1e-8 and dfs(n-1)):
15+
result = true
16+
a[n-1] = a[j]
17+
a[j] = saved
18+
swap a[i], a[n]
19+
if result: break
20+
21+
for i in 0..<4:
22+
a[i] = cards[i].float
23+
cast[cint](dfs(3))

‎binary-subarrays-with-sum.nim

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
proc numSubarraysWithSum(nums: ptr UncheckedArray[cint], numsSize: int, goal: int): int {.exportc.} =
2+
var
3+
prev = -1
4+
j = 0
5+
s = 0
6+
for i in 0..<numsSize:
7+
s += nums[i]
8+
while j < i and s-nums[j] >= goal:
9+
if nums[j] > 0: prev = j
10+
s -= nums[j]
11+
j += 1
12+
if s == goal:
13+
result += j-prev

‎closest-subsequence-sum.nim

+58
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,58 @@
1+
# Closest Subsequence Sum
2+
import std/[algorithm, sequtils, sets]
3+
4+
proc minAbsDifference(nums: ptr UncheckedArray[cint], n: int, goal: int): int {.exportc.} =
5+
proc fn(a: openarray[cint]): seq[int] =
6+
var
7+
b = newSeq[int]()
8+
i, j: int
9+
result.add 0
10+
for x in a:
11+
b.setLen 0
12+
i = 0
13+
j = 0
14+
while i < result.len or j < result.len:
15+
if i < result.len and (j == result.len or result[i] > result[j]+x):
16+
b.add result[i]
17+
inc i
18+
else:
19+
b.add result[j]+x
20+
if i < result.len and result[i] == result[j]+x: inc i
21+
inc j
22+
result.swap b
23+
result.reverse
24+
25+
let
26+
nleft = n div 2
27+
left = fn(nums.toOpenArray(0, nleft-1))
28+
var i = left.len
29+
result = int.high
30+
for x in fn(nums.toOpenArray(nleft, n-1)):
31+
while i > 0 and left[i-1] >= goal-x: dec i
32+
if i < left.len: result = result.min(left[i]+x-goal)
33+
if i > 0: result = result.min(goal-left[i-1]-x)
34+
35+
###
36+
37+
import std/[algorithm, sequtils, sets]
38+
39+
proc minAbsDifference(nums: ptr UncheckedArray[cint], n: int, goal: int): int {.exportc.} =
40+
proc fn(a: openarray[cint]): seq[int] =
41+
var s = initHashSet[int]()
42+
s.incl 0
43+
for x in a.toOpenArray(0, a.high):
44+
var s1 = s
45+
for y in s: s1.incl x+y
46+
s = s1.move
47+
result = s.items.toSeq
48+
result.sort
49+
50+
let
51+
nleft = n div 2
52+
left = fn(nums.toOpenArray(0, nleft-1))
53+
var i = left.len
54+
result = int.high
55+
for x in fn(nums.toOpenArray(nleft, n-1)):
56+
while i > 0 and left[i-1] >= goal-x: dec i
57+
if i < left.len: result = result.min(left[i]+x-goal)
58+
if i > 0: result = result.min(goal-left[i-1]-x)

‎count-nodes-with-the-highest-score.nim

+37
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
# Count Nodes With the Highest Score
2+
import std/sequtils
3+
4+
proc countHighestScoreNodes(parents: ptr UncheckedArray[cint], n: int): int {.exportc.} =
5+
var
6+
indegree = newSeq[int](n)
7+
size = newSeqWith[int](n, 1)
8+
product = newSeqWith[int](n, 1)
9+
top = -1
10+
best = 0
11+
for i in 0..<n:
12+
if parents[i] >= 0:
13+
inc indegree[parents[i]]
14+
for i in 0..<n:
15+
if indegree[i] == 0:
16+
indegree[i] = top
17+
top = i
18+
while top >= 0:
19+
let
20+
u = top
21+
v = parents[u]
22+
top = indegree[top]
23+
if v >= 0:
24+
size[v] += size[u]
25+
product[v] *= size[u]
26+
dec indegree[v]
27+
if indegree[v] == 0:
28+
indegree[v] = top
29+
top = v
30+
31+
if n > size[u]:
32+
product[u] *= n-size[u]
33+
if product[u] > best:
34+
best = product[u]
35+
result = 0
36+
if product[u] == best:
37+
inc result

‎detect-squares.nim

+3-5
Original file line numberDiff line numberDiff line change
@@ -18,17 +18,15 @@ proc detectSquaresAdd(obj: ptr DetectSquares, point: ptr UncheckedArray[cint], p
1818
obj.rs.mgetOrPut(x-y, @[]).add(y)
1919
obj.c[x+y*N] += 1
2020

21-
proc detectSquaresCount(obj: ptr DetectSquares, point: ptr UncheckedArray[cint], pointSize: cint): cint {.exportc.} =
21+
proc detectSquaresCount(obj: ptr DetectSquares, point: ptr UncheckedArray[cint], pointSize: cint): int {.exportc.} =
2222
let (x0, y0) = (cast[int](point[0]), cast[int](point[1]))
23-
var res = 0
2423
for y1 in obj.ls.getOrDefault(x0+y0, @[]):
2524
if y0 == y1: continue
2625
let x1 = x0+y0-y1
27-
res += obj.c[x0+y1*N] * obj.c[x1+y0*N]
26+
result += obj.c[x0+y1*N] * obj.c[x1+y0*N]
2827
for y1 in obj.rs.getOrDefault(x0-y0, @[]):
2928
if y0 == y1: continue
3029
let x1 = x0-y0+y1
31-
res += obj.c[x0+y1*N] * obj.c[x1+y0*N]
32-
cast[cint](res)
30+
result += obj.c[x0+y1*N] * obj.c[x1+y0*N]
3331

3432
proc detectSquaresFree(obj: sink DetectSquares) {.exportc.} = discard

‎find-longest-awesome-substring.nim

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
import std/algorithm
2+
3+
proc longestAwesome(s: cstring): int {.exportc} =
4+
var
5+
bgn: array[1024, int]
6+
m = 0
7+
i = 0
8+
bgn.fill(-1)
9+
bgn[0] = 0
10+
while s[i] != '\0':
11+
m = m xor 1 shl (s[i].ord-'0'.ord)
12+
inc i
13+
for j in 0..<10:
14+
let l = bgn[m xor 1 shl j]
15+
if l >= 0:
16+
result = max(result, i-l)
17+
if bgn[m] >= 0:
18+
result = max(result, i-bgn[m])
19+
else:
20+
bgn[m] = i

‎find-the-longest-substring-containing-vowels-in-even-counts.nim

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
# Find the Longest Substring Containing Vowels in Even Counts
2+
import std/algorithm
3+
4+
proc findTheLongestSubstring(s: cstring): int {.exportc.} =
5+
var
6+
bgn: array[32, int]
7+
m = 0
8+
i = 0
9+
bgn.fill(-1)
10+
bgn[0] = 0
11+
while s[i] != '\0':
12+
case s[i]
13+
of 'a': m = m xor 1
14+
of 'e': m = m xor 2
15+
of 'i': m = m xor 4
16+
of 'o': m = m xor 8
17+
of 'u': m = m xor 16
18+
else: discard
19+
inc i
20+
if bgn[m] >= 0:
21+
result = max(result, i-bgn[m])
22+
else:
23+
bgn[m] = i

‎find-the-most-competitive-subsequence.nim

+15
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
# Find the Most Competitive Subsequence
2+
proc malloc(size: csize_t): pointer {.importc.}
3+
4+
proc mostCompetitive(nums: ptr UncheckedArray[cint], numsSize: int, k0: int, resultSize: ptr cint): ptr UncheckedArray[cint] {.exportc.} =
5+
var
6+
j = 0
7+
k = numsSize-k0
8+
result = cast[ptr UncheckedArray[cint]](malloc(cast[csize_t](cint.sizeof * numsSize)))
9+
for i in 0..<numsSize:
10+
while k > 0 and j > 0 and result[j-1] > nums[i]:
11+
dec j;
12+
dec k
13+
result[j] = nums[i]
14+
inc j
15+
resultSize[] = cast[cint](max(j-k, 0))

‎longest-repeating-character-replacement.nim

+15
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
# Longest Repeating Character Replacement
2+
proc characterReplacement(s: cstring, k: int): int {.exportc.} =
3+
var
4+
l = 0
5+
r = 0
6+
mx = 0
7+
c: array[127, int]
8+
while s[r] != '\0':
9+
inc c[s[r].ord]
10+
mx = mx.max(c[s[r].ord])
11+
inc r
12+
if mx+k < r-l:
13+
dec c[s[l].ord]
14+
inc l
15+
r-l

‎max-consecutive-ones-iii.nim

+10
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
proc longestOnes(nums: ptr UncheckedArray[cint], numsSize: int, k: cint): int {.exportc.} =
2+
var
3+
l = 0
4+
bal = cast[int](k)
5+
for r in 0..<numsSize:
6+
if cast[int](nums[r]) == 0:
7+
dec bal
8+
if bal < 0:
9+
while (inc l; nums[l-1] > 0): discard
10+
result = max(result, r-l+1)

‎maximize-the-confusion-of-an-exam.nim

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
# Maximize the Confusion of an Exam
2+
proc maxConsecutiveAnswers(answerKey: cstring, k: int): cint {.exportc.} =
3+
var
4+
l = 0
5+
r = 0
6+
c = [0, 0]
7+
while answerKey[r] != '\0':
8+
inc c[if answerKey[r] == 'T': 1 else: 0]
9+
inc r
10+
if c[0].min(c[1]) > k:
11+
dec c[if answerKey[l] == 'T': 1 else: 0]
12+
inc l
13+
cast[cint](r-l)
14+
15+
###
16+
17+
proc maxConsecutiveAnswers(answerKey: cstring, k: int): cint {.exportc.} =
18+
var
19+
l = 0
20+
r = 0
21+
c = [0, 0]
22+
while answerKey[r] != '\0':
23+
inc c[if answerKey[r] == 'T': 1 else: 0]
24+
inc r
25+
while c[0].min(c[1]) > k:
26+
dec c[if answerKey[l] == 'T': 1 else: 0]
27+
inc l
28+
result = max(result, cast[cint](r-l))

‎maximum-number-of-ways-to-partition-an-array.nim

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
# Maximum Number of Ways to Partition an Array
2+
import std/tables
3+
4+
proc waysToPartition(nums: ptr UncheckedArray[cint], n: int, k: int): cint {.exportc.} =
5+
var
6+
s = 0
7+
prefix = 0
8+
left = initTable[int, int]()
9+
right = initTable[int, int]()
10+
ans = 0
11+
for i in 0..<n:
12+
s += cast[int](nums[i])
13+
inc right.mgetOrPut(s, 0)
14+
dec right[s]
15+
if s mod 2 == 0:
16+
ans = right.getOrDefault(s div 2, 0)
17+
18+
for i in 0..<n:
19+
let a = cast[int](nums[i])
20+
if a != k:
21+
let s1 = s+k-a
22+
if s1 mod 2 == 0:
23+
ans = ans.max(left.getOrDefault(s1 div 2, 0) + right.getOrDefault(s1 div 2+a-k, 0))
24+
prefix += a
25+
inc left.mgetOrPut(prefix, 0)
26+
dec right[prefix]
27+
28+
return cast[cint](ans)

‎minimum-adjacent-swaps-for-k-consecutive-ones.nim

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
# Minimum Adjacent Swaps for K Consecutive Ones
2+
proc minMoves(nums: ptr UncheckedArray[cint], n: int, k: int): int {.exportc.} =
3+
var
4+
a: seq[int]
5+
s = 0
6+
for i in 0..<n:
7+
if nums[i] > 0:
8+
a.add s
9+
s += i-a.len
10+
a.add s
11+
result = int.high
12+
for i in 0..<a.len-k:
13+
let
14+
m = i+k div 2
15+
x = a[m+1]-a[m]
16+
left = x*(m-i) - (a[m]-a[i])
17+
right = a[i+k]-a[m] - x*(i+k-m)
18+
result = min(result, left+right)

‎minimum-operations-to-make-a-uni-value-grid.nim

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
# Minimum Operations to Make a Uni-Value Grid
2+
import std/algorithm
3+
4+
proc minOperations(grid: ptr UncheckedArray[ptr UncheckedArray[cint]], gridSize: int, gridColSize: ptr UncheckedArray[cint], x: cint): cint {.exportc.} =
5+
let n = gridSize * gridColSize[0]
6+
var
7+
a = newSeq[cint](n)
8+
k = 0
9+
for i in 0..<gridSize:
10+
for j in 0..<gridColSize[0]:
11+
a[k] = grid[i][j]
12+
inc k
13+
a.sort
14+
let median = a[n div 2]
15+
for y in a:
16+
let d = abs(y-median)
17+
if d mod x != 0: return -1
18+
result += d div x

‎partition-array-into-two-arrays-to-minimize-sum-difference.cc

+39
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
#define ALL(x) (x).begin(), (x).end()
2+
#define REP(i, n) for (long i = 0; i < (n); i++)
3+
4+
class Solution {
5+
public:
6+
int minimumDifference(vector<int>& a) {
7+
int n2 = a.size(), n = a.size()/2, sum = accumulate(ALL(a), 0), sum2 = sum/2;
8+
vector<vector<int>> ls(n+1), rs(n+1);
9+
REP(k, 1<<n) {
10+
int s = 0;
11+
REP(i, n) if (k>>i & 1) s += a[i];
12+
ls[__builtin_popcount(k)].push_back(s);
13+
14+
s = 0;
15+
REP(i, n) if (k>>i & 1) s += a[n+i];
16+
rs[__builtin_popcount(k)].push_back(s);
17+
}
18+
for (auto &l: ls) {
19+
sort(ALL(l));
20+
l.erase(unique(ALL(l)), l.end());
21+
}
22+
for (auto &r: rs) {
23+
sort(ALL(r));
24+
r.erase(unique(ALL(r)), r.end());
25+
}
26+
27+
int ans = INT_MAX;
28+
REP(i, n+1) {
29+
for (int l: ls[i]) {
30+
auto it = lower_bound(ALL(rs[n-i]), sum2-l);
31+
if (it != rs[n-i].end())
32+
ans = min(ans, abs(2*(l+*it)-sum));
33+
if (it != rs[n-i].begin())
34+
ans = min(ans, sum-2*(l+it[-1]));
35+
}
36+
}
37+
return ans;
38+
}
39+
};

0 commit comments

Comments
 (0)