ANY OF U REDDY 2 CHALLENGE ME YET?

CARN

>>42
I found this amusing:

array.py:
#!/usr/bin/env python
NUM_ELEMS = 10000000
print sum(range(NUM_ELEMS))

$ time ./array.py
49999995000000
./array.py  0.76s user 0.36s system 99% cpu 1.126 total
$ time ./list
49999995000000
./list  0.71s user 0.15s system 99% cpu 0.860 total
$ time ./array
49999995000000
./array  0.08s user 0.04s system 97% cpu 0.124 total

The linked list is only slightly faster than the equivalent Python code, whereas the dynamic array is almost 10x faster.

>>42
Let's not forget that in a real program, we'll want to cleanup after ourselves. With the dynamic array, this is as simple as one free

array.c:
#include <stdio.h>
#include <stdlib.h>
#include "numelems.h"

int main() {
    int *a;
    int i;
    size_t n;
    unsigned long total;

    n = 1;
    a = malloc(n * sizeof(*a));
    for (i = 0; i < NUM_ELEMS; ++i) {
        while (n <= i) {
            n *= 2;
            a = realloc(a, n * sizeof(*a));
        }
        a[i] = i;
    }
    while (--i)
        total += a[i];
    printf("%lu\n", total);
    free(a);
    return 0;
}

With the linked-list, of course, you have free every node.

list.c
#include <stdio.h>
#include <stdlib.h>
#include "numelems.h"

typedef struct node {
    int n;
    struct node *next;
} node;

node *new(int n) {
    node *l;

    l = malloc(sizeof(*l));
    l->n = n;
    l->next = NULL;
    return l;
}

int main() {
    int i;
    unsigned long total;
    node *head;
    node *tail;

    head = NULL;
    for (i = 0; i < NUM_ELEMS; ++i) {
        if (head) {
            tail = tail->next = new(i);
        } else {
            tail = head = new(i);
        }
    }
    total = 0;
    tail = head;
    while (tail) {
        total += tail->n;
        tail = tail->next;
    }
    printf("%lu\n", total);
    while (head) {
        tail = head->next;
        free(head);
        head = tail;
    }
    return 0;
}

And let's see how this scales:
time ./array
49999995000000
./array  0.08s user 0.05s system 97% cpu 0.134 total
$ time ./list
49999995000000
./list  1.96s user 0.18s system 99% cpu 2.141 total

OUCH! Two seconds? You mean 10000000 mallocs and frees isn't BLINDING FAST?! Who would have thought?

``B-b-but, muh O(n) traversal.''
-- Lambda A. ``List Boy'' Calculus and his fag buddy

List: O(n) traversal, O(n) allocation, O(n) deallocation, O(n) access.
Array O(n) traversal, O(sqrt n) allocation, O(1) deallocation, O(1) access.

List: non-primitive, requires struct, optional auxiliary functions, etc.
Array: native to C, just declare and use it, fast as FUCK.

Time to the Standard again, Lambda. Maybe work out some Project Euler problems until you understand how to write non-shitty, non-slow, non-bloated, non-standard code.