Same answer.
317 years apart.

// Dynamic array growth: the canonical amortised O(1).
fn amortised_example() {
    let mut v: Vec<i32> = Vec::new(); // capacity starts at 0

    for i in 0..16 {
        v.push(i);
        // capacity doubles when full: 0 -> 1 -> 2 -> 4 -> 8 -> 16
        // each doubling copies all elements (an O(n) spike)
        // but spread over all pushes, it averages to O(1)
        println!("len={:2} cap={:2}", v.len(), v.capacity());
    }
    // total copies across 16 pushes: 1+2+4+8 = 15
    // average extra work per push: about 1 copy
    // O(1) amortised
}

#include <stdlib.h>

typedef struct {
    int    *data;
    size_t  len;
    size_t  cap;
} DynArray;

void push(DynArray *a, int val) {
    if (a->len == a->cap) {
        /* capacity exhausted: double it */
        size_t new_cap = a->cap ? a->cap * 2 : 1;
        a->data = realloc(a->data, new_cap * sizeof *a->data);
        /* this realloc is O(n), but it happens rarely;
         * amortised over all pushes it is O(1) */
        a->cap = new_cap;
    }
    a->data[a->len++] = val;
}

use sha2::{Sha256, Digest};

// O(1): compute SHA-256. Always 64 rounds, any input.
fn hash_block(data: &[u8; 32]) -> [u8; 32] {
    let mut h = Sha256::new();
    h.update(data);
    h.finalize().into()
    // fixed operations regardless of content
}

// O(1): verify. Same cost as computing, then compare.
fn verify_hash(data: &[u8; 32], expected: &[u8; 32]) -> bool {
    hash_block(data) == *expected
}

// O(2^difficulty): mining. No algorithm, only brute force.
fn mine(mut header: [u8; 32], difficulty: u32) -> ([u8; 32], u64) {
    let mut nonce: u64 = 0;
    loop {
        header[24..32].copy_from_slice(&nonce.to_le_bytes());
        let hash = hash_block(&header);
        if hash[0..(difficulty / 8) as usize].iter().all(|&b| b == 0) {
            return (hash, nonce);
        }
        nonce += 1;
        // average iterations: 2^difficulty
        // Bitcoin's current difficulty is around 2^70
    }
}

#include <stdint.h>
#include <string.h>
#include <openssl/sha.h>

/* O(1): fixed 64-round SHA-256 */
void hash_block(const uint8_t in[32], uint8_t out[32]) {
    SHA256(in, 32, out);
}

/* O(1): verify */
int verify_hash(const uint8_t data[32], const uint8_t expected[32]) {
    uint8_t computed[32];
    hash_block(data, computed);
    return memcmp(computed, expected, 32) == 0;
}

/* O(2^difficulty): no algorithm, only the loop */
uint64_t mine(uint8_t header[32], uint32_t difficulty) {
    uint64_t nonce = 0;
    uint8_t  hash[32];
    uint32_t zero_bytes = difficulty / 8;

    for (;;) {
        memcpy(header + 24, &nonce, 8);
        hash_block(header, hash);

        int valid = 1;
        for (uint32_t i = 0; i < zero_bytes; i++)
            if (hash[i] != 0) { valid = 0; break; }
        if (valid) return nonce;
        nonce++;
        /* about 2^70 iterations on average */
    }
}