longclaps

function dfs(idx, rest, stack) {
    if (rest) {
        if (idx) {
            idx -= 1;
            dfs(idx, rest, stack);
            if (rest < data[idx]) return;
            stack.push(data[idx]);
            dfs(idx, rest - data[idx], stack)
            stack.pop();
        }
    } else
        console.log(stack);
}

const data = [1, 2, 3, 8, 7, 4].reverse(), n = 10;
dfs(data.length, n, []);

Собирай

Procedure Bubble(var A: array of Integer; M: Integer);
# var A: array of Integer - ссылка на A, передаётся в eax
# M: Integer - размер массива, передаётся в ecx
Asm
    pushad
    dec   ecx
    mov   esi, 1
@1:
    mov   edi,  ecx
    mov   edx, [eax+edi*4] #  mov   edx, A[edi], 4-байтные int
@2:
    mov   ebx, [eax+edi*4-4] # ebx, A[edi - 1]
    cmp   ebx, edx
    ja    @3
    mov   [eax+edi*4-4], edx #mov   A[edi - 1], edx
    mov   [eax+edi*4], ebx  # A[edi], ebx  # вот и поменялись местами
..............................

Вроде всё понятно.
Переделать можно, но зачем - есть quicksort, им пользуйся

"КОРАБЛИК"
consonants = "КРБЛ"
vovels = "ОАИ"
from itertools import permutations

# что за permutations? а вот:
for oai in permutations(vovels):
    print(*oai, sep='')

print(sum(1 for krbl in permutations(consonants, 3))  # сколько перестановок согласных по 3
      *
      sum(1 for oai in permutations(vovels)))  # и гласных

"Но проще решить аналитически" (с) Rsa97

Это старая идея о том, чтобы разбивать те корзины в хэш-таблице, население которых превышает заданый лимит, и напротив сливать в одну две, которые достаточно маленькие и составляют пару. Такой подход вынуждал при операциях на таблице пробовать разные варианты хэш-функции до (не)достижения попадания.

Сейчас мейнстрим-подход иной - при превышении размером таблицы некоего лимита (размера в элементах, не в корзинах) она переразбивается, скажем, на вдвое большее число корзин, а лимит удваивается. И наоборот. Хэш-функция едина для всех корзин, так проще, быстрее.

ЛХЧР был ценен тем, что его изобретатель дал строгую аналитическую оценку скорости операций, для прочих алгоритмов этого не было. С тех пор были посчитаны амортизированные оценки остальных способов, они столь же хорошие асимптотически, а на практике всё у них гораздо быстрее. Хэши научились готовить правильно, в целом поумнели.

Конечно можно. Mongo просто создан для того, чтобы производить такие операции.
Отлично ты всё понимаешь, хоть с помощью того же Middleware.

Хрен знает, завезли ли вам слайсы, а у нас в питоне они всегда были:

def 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)

ps а пятнышко в середине последнего квадрата не нужно?
pps слайсы - те же циклы

UPDATE концентрические квадраты

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)

from itertools import product

s = 'abc'
for i in range(len(s) + 1):
    for t in product(s, repeat=i):
        print(repr(''.join(t)))