Are we referring to reference implementations? I have always found it easier to understand the C code, as Rust and Python tend to obscure too many details behind high-level abstractions.

C is simple enough to know what is going on, IMO.

For example:

    numbers = [1, 2, 3, 4, 5]
    squared_numbers = [num * num for num in numbers]
    print(squared_numbers)

vs.

    fn main() {
        let numbers = vec![1, 2, 3, 4, 5];
        let squared_numbers: Vec<i32> = numbers.iter().map(|&num| num * num).collect();

        println!("{:?}", squared_numbers);
    }

vs.

    #include <stdio.h>

    int main() {
        int numbers[] = {1, 2, 3, 4, 5};
        int squared_numbers[5];
    
        // Squaring each number
        for (int i = 0; i < 5; i++) {
            squared_numbers[i] = numbers[i] * numbers[i];
        }
    
        // Printing the squared numbers
        printf("[");
        for (int i = 0; i < 5; i++) {
            printf("%d", squared_numbers[i]);
            if (i < 4) printf(", ");
        }
        printf("]\n");

        return 0;
    }

Python and Rust here seem concise and elegant, but can be more difficult to follow to the unaccustomed due to obscurity. I am sure there are examples that involve more higher-level abstractions, and reference implementations typically seem to use a lot of said abstractions. In case of this Rust code, abstractions (like iterators and closures) can also make the code more challenging to follow for those who are not accustomed to functional programming paradigms.

What I am trying to say is that the C implementation is more straightforward, IMO.