jcmvbkbc

Обратимы ли функции S0, S1, E0, E1 из алгоритма SHA-256?

Σ0 ( A ) = ( A ⋙ 2 ) ⊕ ( A ⋙ 13 ) ⊕ ( A ⋙ 22 ) -- обратима.
Σ1 ( E ) = ( E ⋙ 6 ) ⊕ ( E ⋙ 11 ) ⊕ ( E ⋙ 25 ) -- тоже обратима.
Что такое E0 и E1 я не нашёл.

Таблицу всех значений S0 и S1 можно построить за несколько минут, если есть свободных 16Г памяти. Все они различны, т.е. обратное преобразование однозначно.
Можно ли найти простую обратную функцию -- непонятно.

git push origin +post

tar --same-owner -xvpf /usb/backup.tgz - C /mnt/

Между - и C не должно быть пробела. С пробелом получается, что вы хотите распаковать /usb/backup.tgz, а следом за ним -- стандартный ввод, на что вам gzip вызванный из tar и отвечает "gzip: stdin: unexpected end of file".

https://buildroot.org/support.html

nexuiz

Слово "литерал" переводится как "буквальный". Это объект, значение которого -- его буквальное значение. Например: "hello" -- это строковый литерал со значением "hello". Или 42 -- это целочисленный литерал со значением 42. Противоположностью литерала, в некотором смысле, является переменная. Переменная -- это объект, значение которого -- последнее присвоенное ему значение. Например: char a[] = "hello world"; a -- это строковая переменная, со значением "hello world". Или int answer = 40 + 2; answer -- целочисленная переменная со значением 42.

Операнд -- это аргумент операции. Во многих контекстах литералы и переменные могут быть операндами. Например: a[0]; операция здесь -- [], взятие элемента массива, операнды -- a и 0, один из них -- переменная, другой -- литерал.

name specifier 'Vector3<V>::' for declaration does not refer into a class

Компилятор прав. У тебя нет такого типа. Есть тип Vector3<V,T>, с двумя параметрами в шаблоне.
Можно написать так:

template <class V, typename T>
Vector3<V> &Vector3<V, T>::operator+=(const Vector3<V> &addVector) {
    this->x += addVector.x;
    this->y += addVector.y;
    this->z += addVector.z;
    return *this;
}

как составить рекурсию из массива

Рекурсия -- это метод решения задачи, использующий сам себя для решения подзадач. Массив -- это массив. Нельзя составить рекурсию из массива. Можно вывести массив на экран рекурсивной функцией.

значения по возрастанию
...
1 2
1 3
1 2 3

Но это же не по возрастанию. По возрастанию (лексикографическому) было бы
1 2
1 2 3
1 3

Я хочу произвести отладку и остановить программу когда будет соблюдаться определенное условие. Допустим сумма регистров eax+ebx будет равна 65463.

Для совсем уж произвольного условия, типа того, что вы написали, готовых средств скорее всего нет.
Если вам нужно остановиться, когда программная переменная в памяти принимает определённое значение -- искать в вашем отладчике по слову watchpoint. В gdb, например, можно поставить watchpoint на переменную, а в commands вписать код, который будет продолжать выполнение, если значение переменной не то, что вам нужно, например:

$ cat > main.c
int v;

static void f(int *p)
{
        int i;

        for (i = 0; i < 20; ++i)
                *p = (i - 10) * (i - 10);
}

int main()
{
        f(&v);
        return 0;
}
$ gcc -g2 -o watch main.c     
$ gdb ./watch              
...
Reading symbols from ./watch...done.
(gdb) start
Temporary breakpoint 1 at 0x4004ec: file main.c, line 13.
Starting program: /home/jcmvbkbc/tmp/toster/watch/watch 

Temporary breakpoint 1, main () at main.c:13
13              f(&v);
(gdb) watch v
Hardware watchpoint 2: v
(gdb) commands 
Type commands for breakpoint(s) 2, one per line.
End with a line saying just "end".
>if (v != 4)
 >continue
 >end
>end
(gdb) c
Continuing.
...
Hardware watchpoint 2: v

Old value = 9
New value = 4
f (p=0x600904 <v>) at main.c:7
7               for (i = 0; i < 20; ++i)
(gdb)

Можно научить интерпретатор читать из последовательного порта, присоединить последовательный порт QEMU к stdio опцией -serial и писать туда например так:
echo '++++++' | qemu-system-... -nographic -monitor none -serial stdio

Мои мысли на тему и получившийся алгоритм:
- обозначим для простоты карты их порядковыми номерами в отсортированной колоде, A_i;
- каждой карте сопоставим расстояние до её конечной желаемой позиции, равное i - A_i;
- перестановка карты с позиции i на позицию j меняет её расстояние на j - i, и одновременно на sign(i - j) меняет расстояния карт между i и j;
- перестановка выгодна если она уменьшает суммарное расстояние, которое потребуется пройти картам после неё;
- для текущей позиции существует по меньшей мере одна наиболее выгодная перестановка -- такая, которая максимально уменьшает оставшееся расстояние; найти её можно тупым перебором исходной и конечной позиции переставляемой карты (но, может быть, можно и быстрее);
- совершая на каждом шаге наиболее выгодную перестановку мы, скорее всего, упорядочим карты за минимальное число перестановок.

Код на c:

#include <limits.h>
#include <stdio.h>
#include <string.h>

#define N (sizeof(a) / sizeof(a[0]))

inline int sign(int d)
{
        if (d == 0)
                return 0;
        return d < 0 ? -1 : 1;
}

inline int abs(int v)
{
        return v < 0 ? -v : v;
}

int main()
{
        int a[] = {2, 1, 3, 4, 0};
        int q[N];

        for (;;) {
                int best_profit = INT_MIN;
                int best_src = -1;
                int best_dst = -1;
                int i, src, dst, tmp;

                for (i = 0; i < N; ++i)
                        q[i] = i - a[i];

                for (src = 0; src < N; ++src)
                        for (dst = 0; dst < N; ++dst) {
                                int d = sign(dst - src);
                                int profit = abs(q[src]) - abs(q[src] + dst - src);

                                //printf("...%d -> %d: profit = %d", src, dst, profit);

                                for (i = src + d; i != dst + d; i += d) {
                                        if (sign(q[i]) == d) {
                                                ++profit;
                                                //printf(" + 1");
                                        } else {
                                                --profit;
                                                //printf(" - 1");
                                        }
                                }
                                //printf(" = %d\n", profit);
                                if (profit > best_profit) {
                                        best_src = src;
                                        best_dst = dst;
                                        best_profit = profit;
                                        //printf("... -- new best!\n");
                                }
                        }
                printf("%d -> %d (profit = %d)\n", best_src, best_dst, best_profit);
                if (best_profit == 0)
                        break;
                tmp = a[best_src];
                if (best_dst < best_src)
                        memmove(a + best_dst + 1, a + best_dst, (best_src - best_dst) * sizeof(int));
                else
                        memmove(a + best_src, a + best_src + 1, (best_dst - best_src) * sizeof(int));
                a[best_dst] = tmp;

                for (i = 0; i < N; ++i)
                        printf("%d ", a[i]);
                printf("\n");
        }
        return 0;
}