I will always be here but maybe not every day, I am the same as you guys, eating and drinking as well as playing and resting, this is just a simple education about Cryptography especially the entropy of each Cryptography that you can learn

SHA-256

Part of the SHA-2 family, this algorithm produces a 256-bit (32-byte) hash value.

Hᵢ = Hᵢ₋₁ + (Ch(E,F,G) + Σ₁(E) + Wᵢ + Kᵢ)

Recommendations for complex but still easy to apply elementals

Keccak (SHA-3)

Based on sponge construction, resistant to attacks that compromise SHA-2.

S' = Keccak-p[1600, 24](S ⊕ P)

Suitable for service or service

RIPEMD-256

An improved version of RIPEMD with a 256-bit output size.

H = Lₙ ∥ Rₙ where Lᵢ = F(Lᵢ₋₁, mᵢ)

Stronger than SHA-256 and only suitable for one role per elemental

RIPEMD-320

Extended version with 320-bit output for enhanced security.

H = Lₙ ∥ Rₙ ∥ Eₙ

Useful for privacy either personal or state E-documents if needed

SHA-256 Detailed Calculation

// Message Schedule Expansion

For i from 16 to 63:

    s0 = rightrotate(W[i-15], 7) XOR

         rightrotate(W[i-15], 18) XOR (W[i-15] >> 3)

    s1 = rightrotate(W[i-2], 17) XOR

         rightrotate(W[i-2], 19) XOR (W[i-2] >> 10)

    W[i] = W[i-16] + s0 + W[i-7] + s1

// Compression Function

For i from 0 to 63:

    S1 = rightrotate(e, 6) XOR rightrotate(e, 11) XOR rightrotate(e, 25)

    ch = (e AND f) XOR ((NOT e) AND g)

    temp1 = h + S1 + ch + K[i] + W[i]

    S0 = rightrotate(a, 2) XOR rightrotate(a, 13) XOR rightrotate(a, 22)

    maj = (a AND b) XOR (a AND c) XOR (b AND c)

    temp2 = S0 + maj

    h = g

    g = f

    f = e

    e = d + temp1

    d = c

    c = b

    b = a

    a = temp1 + temp2

Warning that Qubits will never exist but SHA-256 needs to be upgraded in the temp2 section before later Bit 1 Perform the baseline rate

Keccak (SHA-3) Calculation Framework

// Theta (θ) step

For all pairs (x,z):

    C[x,z] = A[x,0,z] XOR A[x,1,z] XOR A[x,2,z] XOR A[x,3,z] XOR A[x,4,z]

For all pairs (x,z):

    D[x,z] = C[(x-1) mod 5, z] XOR C[(x+1) mod 5, (z-1) mod 64]

For all triples (x,y,z):

    A'[x,y,z] = A[x,y,z] XOR D[x,z]

// Rho (ρ) and Pi (π) steps

For all pairs (x,y):

    (x',y') = (y mod 5, (2x+3y) mod 5)

For all z:

    A''[x',y',z] = A'[x,y,(z-(r[x,y])) mod 64]

where r[x,y] is a rotation constant

// Chi (χ) step

For all triples (x,y,z):

    A'''[x,y,z] = A''[x,y,z] XOR ((NOT A''[(x+1) mod 5,y,z]) AND A''[(x+2) mod 5,y,z])

// Iota (ι) step - adds round constants

A''''[0,0,z] = A'''[0,0,z] XOR RC[i][z]

Actually, if you create an Altcoin with KECCAK Cryptography, then it is irrelevant plus Hackers will easily find loopholes because the constant arrangement of this Cryptography is XOR-based

RIPEMD-256 Calculation Structure

// RIPEMD-256 uses two parallel instances of RIPEMD-128

// Initialization Vectors

h0[0..3] = (0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476)

h1[0..3] = (0x76543210, 0xFEDCBA98, 0x89ABCDEF, 0x01234567)

// Processing

For each 512-bit message block:

    // Copy state

    A = h0[0]; B = h0[1]; C = h0[2]; D = h0[3];

    A' = h1[0]; B' = h1[1]; C' = h1[2]; D' = h1[3];

    // 64 steps of transformation

    For t = 0 to 63:

        T = rol_s(A + f(t,B,C,D) + X[r(t)] + K(t), s(t))

        A = D; D = C; C = B; B = T;

        T = rol_s(A' + f(63-t,B',C',D') + X[r'(t)] + K'(t), s'(t))

        A' = D'; D' = C'; C' = B'; B' = T;

    // Combine results

    T = h1[1] + C + D';

    h1[1] = h0[1] + D + A';

    h0[1] = T;

    // Final 256-bit hash is (h0[0], h1[0], h0[1], h1[1], h0[2], h1[2], h0[3], h1[3])

This may be suitable for those of you who want to create an Altcoin with solid cryptography, but it is necessary to pay attention to excess consumption if with this, add 448 Bit EdDSA

RIPEMD-320 Calculation Structure

// RIPEMD-320 uses five parallel instances extended from RIPEMD-160

// Initialization Vectors

h0[0..4] = (0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0)

h1[0..4] = (0x76543210, 0xFEDCBA98, 0x89ABCDEF, 0x01234567, 0x3C2D1E0F)

// Processing

For each 512-bit message block:

    // Copy state

    A1 = h0[0]; B1 = h0[1]; C1 = h0[2]; D1 = h0[3]; E1 = h0[4];

    A2 = h1[0]; B2 = h1[1]; C2 = h1[2]; D2 = h1[3]; E2 = h1[4];

    // 80 steps of transformation with 5 rounds each

    For t = 0 to 79:

        // Left line

        T = rol_s(A1 + f_j(t,B1,C1,D1) + X[r_j(t)] + K_j(t), s_j(t)) + E1;

        A1 = E1; E1 = D1; D1 = rol_10(C1); C1 = B1; B1 = T;

        // Right line

        T = rol_s(A2 + f_j(79-t,B2,C2,D2) + X[r'_j(t)] + K'_j(t), s'_j(t)) + E2;

        A2 = E2; E2 = D2; D2 = rol_10(C2); C2 = B2; B2 = T;

    // Combine results

    T = h1[1] + C1 + D2;

    h1[1] = h0[1] + D1 + E2;

    h0[1] = T;

// Final 320-bit hash combines both line results

// (h0[0], h1[0], h0[1], h1[1], h0[2], h1[2], h0[3], h1[3], h0[4], h1[4])

RIPEMD-320 may not be suitable for all of your Cryptography creations but for Privacy it will be suitable if you have a specific wallet, read how the 5 Rounds work.