x, y = 1.2345, 3.2109
le0 = sqrt(x * x + y * y)
if x < y:
x, y = y, x
y /= x
le1 = x * (1.0 + y * y * 0.5)
print(le1 / le0) # 1.0023767214085302, неплохоif x < y:
x, y = y, x
le1 = x + y * 0.41421356237309515 # sqrt(2.0) - 1.0def f(n):
l = [' '] * (n * (n + 1) - 1)
l[n::n + 1] = '\n' * (n - 1)
l[:n] = l[-n:] = l[::n + 1] = l[n - 1::n + 1] = '#' * n
print(''.join(l))
f(5)def f(n):
l = [[' '] * n for _ in range(n)] # двумерный массив
for shift in range(0, n // 2 + 1, 2):
# рисуем как умеем верхние стороны квадратов
l[shift][shift:n - shift] = '#' * (n - shift * 2)
for i, row in enumerate(l):
for j, ch in enumerate(row):
if ch == '#':
# заполняем симметричные точки
l[j][i] = l[j][n - i - 1] = l[n - i - 1][n - j - 1] = '#'
for row in l:
print(''.join(row))
f(17)>>> import operator
>>> sum(map(operator.eq,'111111111111121','111111111111112'))
13function shuffle(str, seed) {
let arr = str.split(''), j;
for (let i = 0; i < arr.length; i++) {
// так называемый минимальный стандартный генератор случайных чисел
// https://ru.wikipedia.org/wiki/Линейный_конгруэнтный_метод
// аккуратно, с нуля он не стартует )
j = (seed = seed * 16807 % 2147483647) % arr.length;
[arr[i], arr[j]] = [arr[j], arr[i]];
}
return arr.join('');
}
console.log(shuffle('abcdefgh', 42));'012' 0 1 2
'0123' 0 1 2 3
'01234' 0 1 2 3 4
'012345' 0 1 2 3 4 5
'0123456' 0 1 2 3 4 5 6
'01234567' 0 1 2 3 4 5 6 7
'012345678' 0 1 2 3 4 5 6 7 8
'0123456789' 0 1 2 3 4 5 6 7 8 9
'01234567890' 0 18 36 54 72 90
'012345678901' 0 1 2 3 4 5 6 7 8 9 10
'0123456789012' 56 94 132 170 208
'01234567890123' 57 120 183 246 309
'012345678901234' 100 312 524 736 948
'0123456789012345' 0 181 362 543 724 905
'01234567890123456' 58 179 300 421 542 663
'012345678901234567' 50 1736 3422 5108 6794
'0123456789012345678' 6 139 272 405 538 671 804
'01234567890123456789' 0 9 18 27 36 45 54 63 72 81 90
'012345678901234567890' 162 300 438 576 714 852 990
'0123456789012345678901' 28 37 46 55 64 73 82 91 100 109
'01234567890123456789012' 584 1007 1430 1853 2276 2699
'012345678901234567890123' 102 219 336 453 570 687 804 921
'0123456789012345678901234' 91 674 1257 1840 2423 3006 3589
'01234567890123456789012345' 105 984 1863 2742 3621 4500 5379
'012345678901234567890123456' 162 1300 2438 3576 4714 5852 6990
'0123456789012345678901234567' 1621 3002 4383 5764 7145 8526 9907
'01234567890123456789012345678' 72 163 254 345 436 527 618 709 800 891
'012345678901234567890123456789' 108 197 286 375 464 553 642 731 820 909from fractions import Fraction
def foo(n):
a, b = Fraction(1), Fraction(0)
for i in range(n * 2, 0, -2):
a, b = (a * i + b) / (i + 1), (a + b * i) / (i + 1),
return b
print(foo(1))
print(foo(100))не особо разобравшись в ее теорииЭто звучит забавно.
Каким образом средствами Python работать с такими большими цифрами при возведении в степень?
from math import log10, modf
f, p = modf(log10(9) * 9 ** 9)
print(f'9 ** (9 ** 9) == {10 ** f}e{int(p)}')
print(f'последняя цифра этого числа - {pow(9, pow(9, 9), 10)}')sample = (("11", "1 1 2"),
("1111\n1111\n1111\n0100", "2 1 3\n3 1 1\n3 2 1"),
("000101\n001101\n110000\n111111\n001110\n111110",
"1 1 2\n2 1 3\n3 1 1\n2 2 1\n6 1 2"),
("111\n101\n111", "2 1 4"))
class Field:
def flip(self):
self.cells[:] = sorted((x, y) for y, x in self.cells)
self.flipped ^= True
def dismantle(self, cells, flipped):
self.cells, self.flipped = cells, flipped
left, right = cells[0][0], cells[-1][0]
tmp = sorted(y for _, y in cells)
top, bottom = tmp[0], tmp[-1]
h, w = bottom - top + 1, right - left + 1
if w * h == len(cells):
wh = (w, h) if h < w else (h, w)
c = tails.get(wh, 0)
if c:
tails[wh] = c - 1
yield (self,)
tails[wh] = c
for lo, hi in (left, right), (top, bottom):
for i, (x, _) in enumerate(cells):
if lo < x <= hi:
for one in Field().dismantle(cells[:i], self.flipped):
for two in Field().dismantle(cells[i:], self.flipped):
yield [*one, *two]
lo = x
self.flip()
_field, _tails = sample[0]
tails = {}
for s in _tails.splitlines():
w, h, c = map(int, s.split())
if w < h:
w, h = h, w
tails[w, h] = c
for partition in Field().dismantle(
sorted((x, y) for y, s in enumerate(_field.splitlines())
for x, c in enumerate(s) if c == '1'), False):
for f in partition:
if f.flipped:
f.flip()
print(*f.cells)
break
else:
print('не смогла')