import ctypes
 
class DynamicArray:
    def __init__(self):
        self.n = 0        # Count of actual elements
        self.capacity = 1 # Default array capacity
        self.A = self._make_array(self.capacity)
        
    def __len__(self):
        return self.n
        
    def __getitem__(self, k):
        if not 0 <= k < self.n:
            raise IndexError('invalid index')
        return self.A[k]
        
    def append(self, obj):
        # If full, double the capacity
        if self.n == self.capacity:
            self._resize(2 * self.capacity)
        self.A[self.n] = obj
        self.n += 1
        
    def _resize(self, new_cap):
        # Allocate new, bigger array
        B = self._make_array(new_cap)
        # Copy existing elements
        for k in range(self.n):
            B[k] = self.A[k]
        self.A = B
        self.capacity = new_cap
        
    def _make_array(self, new_cap):
        # Returns a low-level C array using the ctypes module
        return (new_cap * ctypes.py_object)()
 
# Usage
arr = DynamicArray()
arr.append(10)
arr.append(20) # Resizes internally
print(arr[0], arr[1])

#include <iostream>
#include <stdexcept>
 
template <typename T>
class DynamicArray {
private:
    T* arr;
    int capacity;
    int size;
 
public:
    DynamicArray() {
        capacity = 1;
        size = 0;
        arr = new T[capacity];
    }
    
    ~DynamicArray() {
        delete[] arr;
    }
 
    void push_back(T data) {
        // If array is full, double its capacity
        if (size == capacity) {
            T* temp = new T[2 * capacity];
            for (int i = 0; i < capacity; i++) {
                temp[i] = arr[i];
            }
            delete[] arr;
            capacity *= 2;
            arr = temp;
        }
        arr[size] = data;
        size++;
    }
 
    T get(int index) {
        if (index < 0 || index >= size) {
            throw std::out_of_range("Index out of bounds");
        }
        return arr[index];
    }
    
    int getSize() { return size; }
    int getCapacity() { return capacity; }
};
 
int main() {
    DynamicArray<int> arr;
    arr.push_back(10);
    arr.push_back(20);
    std::cout << "Element at 0: " << arr.get(0) << std::endl;
    return 0;
}

class DynamicArray {
    constructor() {
        this.length = 0;
        this.capacity = 1;
        this.data = new Array(this.capacity);
    }
 
    get(index) {
        if (index < 0 || index >= this.length) {
            throw new Error("Index out of bounds");
        }
        return this.data[index];
    }
 
    push(item) {
        if (this.length === this.capacity) {
            this._resize(this.capacity * 2);
        }
        this.data[this.length] = item;
        this.length++;
    }
 
    _resize(newCapacity) {
        const newData = new Array(newCapacity);
        for (let i = 0; i < this.length; i++) {
            newData[i] = this.data[i];
        }
        this.data = newData;
        this.capacity = newCapacity;
    }
}
 
// Usage
const arr = new DynamicArray();
arr.push(10);
arr.push(20);
console.log(arr.get(0), arr.get(1));

public class DynamicArray<T> {
    private Object[] data;
    private int size;
    private int capacity;
 
    public DynamicArray() {
        this.capacity = 1;
        this.size = 0;
        this.data = new Object[capacity];
    }
 
    public void add(T element) {
        if (size == capacity) {
            resize(2 * capacity);
        }
        data[size] = element;
        size++;
    }
 
    @SuppressWarnings("unchecked")
    public T get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of bounds");
        }
        return (T) data[index];
    }
 
    private void resize(int newCapacity) {
        Object[] newData = new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
        capacity = newCapacity;
    }
 
    public static void main(String[] args) {
        DynamicArray<Integer> arr = new DynamicArray<>();
        arr.add(10);
        arr.add(20);
        System.out.println(arr.get(0));
    }
}

#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
    int *array;
    size_t size;
    size_t capacity;
} DynamicArray;
 
void initArray(DynamicArray *a, size_t initialCapacity) {
    a->array = (int *)malloc(initialCapacity * sizeof(int));
    a->size = 0;
    a->capacity = initialCapacity;
}
 
void insertArray(DynamicArray *a, int element) {
    if (a->size == a->capacity) {
        a->capacity *= 2;
        a->array = (int *)realloc(a->array, a->capacity * sizeof(int));
    }
    a->array[a->size++] = element;
}
 
void freeArray(DynamicArray *a) {
    free(a->array);
    a->array = NULL;
    a->size = a->capacity = 0;
}
 
int main() {
    DynamicArray arr;
    initArray(&arr, 1);  // initially 1 element
    
    insertArray(&arr, 10);
    insertArray(&arr, 20); // Automatically resizes
    
    printf("Element at 0: %d\n", arr.array[0]);
    printf("Element at 1: %d\n", arr.array[1]);
    
    freeArray(&arr);
    return 0;
}