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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
import random
from collections import Counter, defaultdict, deque
from datetime import datetime, timedelta
from functools import lru_cache
from heapq import heapify, heappop, heappush, nlargest, nsmallest
from itertools import combinations, compress, permutations, starmap, tee
from math import ceil, comb, fabs, floor, gcd, log, perm, sqrt
from string import ascii_lowercase, ascii_uppercase
from sys import exit, setrecursionlimit, stdin
from typing import Any, Dict, List, Optional, Tuple, TypeVar, Union
TYPE = TypeVar('TYPE')
N = int(2e5 + 10)
M = int(20)
INF = int(1e12)
OFFSET = int(100)
MOD = int(1e9 + 7)
setrecursionlimit(int(2e9))
class Arr:
array = staticmethod(lambda x=0, size=N: [x() if callable(x) else x for _ in range(size)])
array2d = staticmethod(lambda x=0, rows=N, cols=M: [Arr.array(x, cols) for _ in range(rows)])
graph = staticmethod(lambda size=N: [[] for _ in range(size)])
class Math:
max = staticmethod(lambda a, b: a if a > b else b)
min = staticmethod(lambda a, b: a if a < b else b)
class IO:
input = staticmethod(lambda: stdin.readline().rstrip("\r\n"))
read = staticmethod(lambda: map(int, IO.input().split()))
read_list = staticmethod(lambda: list(IO.read()))
class Std:
pass
class Solution:
def longestNiceSubarray(self, nums: List[int]) -> int:
l, ans, or_ = 0, 1, 0
for r, num in enumerate(nums):
while or_ & num:
or_ ^= nums[l]
l += 1
or_ |= num
ans = Math.max(ans, r - l + 1)
return ans
class Bit(int):
def __new__(cls, value):
return super(Bit, cls).__new__(cls, value)
def __init__(self, value):
self.bin_rep = bin(value)[2:]
def bit_length(self): return len(self.bin_rep)
def bit_count(self): return self.bin_rep.count('1')
def lowest1(self): return Bit(self & -self)
def lowest0(self): return Bit(~self & (self + 1))
def clear_lowest1(self): return Bit(self & (self - 1))
def clear_lowest0(self): return Bit(self | (self + 1))
def get_bits(self, start, end): return self & Bit.range_mask(start, end)
def __or__(self, other): return Bit(super(Bit, self).__or__(other))
def __and__(self, other): return Bit(super(Bit, self).__and__(other))
def __sub__(self, other): return Bit(super(Bit, self).__and__(~other))
all_ones_mask = staticmethod(lambda length: (1 << length) - 1)
all_zeros_mask = staticmethod(lambda length: 0)
single_bit_mask = staticmethod(lambda position: 1 << position)
range_mask = staticmethod(lambda start, end: ((1 << (end - start + 1)) - 1) << start)
class Solution:
def longestNiceSubarray(self, nums: List[int]) -> int:
l, ans, or_ = 0, 1, Bit(0)
for r, num in enumerate(nums):
bit_num = Bit(num)
while or_ & bit_num:
or_ -= Bit(nums[l])
l += 1
or_ |= Bit(num)
ans = Math.max(ans, r - l + 1)
return ans
|