def nice(string):
if not split_pair(string, 0) and not split_pair(string, 1):
return False
seen.clear()
return any(starmap(twin_pair, successive(successive(string))))
def valid(string):
if 8 in string or 11 in string or 14 in string:
return False
if not any(starmap(straight, successive(string, 3))):
return False
pairs = unique_everseen(starfilter(eq, successive(string)))
return 1 < count_items(pairs)
def test_traverse():
"""To test the traverse implementation we call gc.collect() while instances
of all the C objects are still valid."""
acc = iteration_utilities.accumulate([])
app = iteration_utilities.applyfunc(lambda x: x, 1)
cha = iteration_utilities.chained(int, float)
cla = iteration_utilities.clamp([], 0, 1)
com = iteration_utilities.complement(int)
con = iteration_utilities.constant(1)
dee = iteration_utilities.deepflatten([])
dup = iteration_utilities.duplicates([])
fli = iteration_utilities.flip(int)
gro = iteration_utilities.grouper([], 2)
ine = iteration_utilities.intersperse([], 1)
iik = iteration_utilities.ItemIdxKey(10, 2)
ite = iteration_utilities.iter_except(int, TypeError)
mer = iteration_utilities.merge([])
nth = iteration_utilities.nth(1)
pac = iteration_utilities.packed(int)
par = iteration_utilities.partial(int, 10)
rep = iteration_utilities.replicate([], 3)
rou = iteration_utilities.roundrobin([])
see = iteration_utilities.Seen()
sid = iteration_utilities.sideeffects([], lambda x: x)
spl = iteration_utilities.split([], lambda x: True)
sta = iteration_utilities.starfilter(lambda x: True, [])
suc = iteration_utilities.successive([])
tab = iteration_utilities.tabulate(int)
une = iteration_utilities.unique_everseen([])
unj = iteration_utilities.unique_justseen([])
gc.collect()
def part1(text):
def remove(polymer, reaction):
return polymer.replace(reaction, "")
polymer = text.strip()
while react := REACTIONS & frozenset(map("".join, successive(polymer))):
polymer = reduce(remove, react, polymer)
def nice(string):
if any(two in string for two in ("ab", "cd", "pq", "xy")):
return False
if all(starmap(ne, successive(string))):
return False
return 3 <= sum(map(string.count, "aeiou"))
def test_successive_failure_lengthhint1():
f_it = _hf.FailLengthHint(toT([1, 2, 3]))
it = successive(f_it)
with pytest.raises(_hf.FailLengthHint.EXC_TYP,
match=_hf.FailLengthHint.EXC_MSG):
operator.length_hint(it)
with pytest.raises(_hf.FailLengthHint.EXC_TYP,
match=_hf.FailLengthHint.EXC_MSG):
list(it)
def test_successive_failure_lengthhint2():
# This only checks for overflow if the length_hint is above PY_SSIZE_T_MAX.
# In theory that would be possible because with times the length would be
# shorter but "length_hint" throws the exception so we propagate it.
of_it = _hf.OverflowLengthHint(toT([1, 2, 3]), sys.maxsize + 1)
it = successive(of_it)
with pytest.raises(OverflowError):
operator.length_hint(it)
with pytest.raises(OverflowError):
list(it)
def test_successive_failure3():
# Test that a failing iterator doesn't raise a SystemError
with pytest.raises(_hf.FailNext.EXC_TYP, match=_hf.FailNext.EXC_MSG):
next(successive(_hf.FailNext(), 1))
def test_successive_failure2():
with pytest.raises(ValueError): # times must be > 0
successive([T(1), T(2), T(3)], 0)
def test_successive_failure1():
with pytest.raises(_hf.FailIter.EXC_TYP, match=_hf.FailIter.EXC_MSG):
successive(_hf.FailIter())
def test_successive_lengthhint1():
it = successive([0] * 6, 4)
_hf.check_lengthhint_iteration(it, 3)
def part1(text):
adapters = sorted(map(int, text.split()))
padded = chain((0, ), adapters, (adapters[-1] + 3, ))
diffs = tuple(starmap(rsub, successive(padded)))
return diffs.count(1) * diffs.count(3)
def test_successive_failure_setstate2():
# length of first argument not equal to times
suc = successive([T(1), T(2), T(3), T(4)], 2)
with pytest.raises(ValueError):
suc.__setstate__(((T(1), ), ))
def test_successive_copy1():
_hf.iterator_copy(successive(toT([1, 2, 3, 4])))
def test_successive_empty3():
assert list(successive([], times=10)) == []
def test_successive_empty2():
assert list(successive([T(1)])) == []
def test_successive_empty1():
assert list(successive([])) == []
def test_successive_lengthhint2():
assert operator.length_hint(successive([0] * 6, 11)) == 0
def test_successive_failure4():
# Too few arguments
with pytest.raises(TypeError):
successive()
def test_successive_empty4():
assert list(successive([T(1), T(2), T(3)], times=10)) == []
def test_successive_failure5():
# Changing next method
with pytest.raises(_hf.CacheNext.EXC_TYP, match=_hf.CacheNext.EXC_MSG):
list(successive(_hf.CacheNext(1), 3))
def is_sorted(n):
return all(starmap(le, successive(n)))
def test_successive_failure_setstate1():
# first argument must be a tuple
suc = successive([T(1), T(2), T(3), T(4)], 2)
with pytest.raises(TypeError):
suc.__setstate__(([T(1), T(2)], ))
def test_successive_failure_setstate5():
_hf.iterator_setstate_empty_fail(successive([T(1), T(2), T(3), T(4)], 2))
def abas(ip):
return filter(aba, successive(ip, 3))
def test_successive_normal4():
assert (dict(successive([T(1), T(2), T(3), T(4)])) == {
T(1): T(2),
T(2): T(3),
T(3): T(4)
})
def test_successive_normal1():
assert (list(successive([T(1), T(2), T(3), T(4)])) == [(T(1), T(2)),
(T(2), T(3)),
(T(3), T(4))])
def test_successive_pickle2(protocol):
suc = successive([T(1), T(2), T(3), T(4)])
x = pickle.dumps(suc, protocol=protocol)
assert list(pickle.loads(x)) == [(T(1), T(2)), (T(2), T(3)), (T(3), T(4))]
def distance(path):
return sum(dist[a][b] for a, b in successive(path))
def test_successive_normal3():
assert (list(successive([T(1), T(2), T(3), T(4)],
times=4)) == [(T(1), T(2), T(3), T(4))])
