c_codes

This is a 3 column calendar written in C.

//in the name of god

#include <stdio.h>

//defining the spacing of the individual cells and gap in between columns
#define col_gap_val 2
#define row_gap_val 2
#define tabsize 3

//defining the vertical separator of length 3 and blank of length 3

#define line printf("%*s",tabsize ,"---")
#define blank printf("%*s",tabsize ,"")

//newline 'cause I can't keep typing it

#define endl puts("")

void col_gap(){
    for (int j = 0; j < col_gap_val; j++){
        blank;
    }
}

void row_gap(){
    for (int j = 0; j < row_gap_val; j++){
        endl;
    }
}


int main(){

    //take the year as an input
    unsigned long long year;

    puts("Please enter an year:");
    scanf("%llu", &year);

    //Array for names of days
    char *day[7] = {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"};

    //Array for names of months
    char *month_name[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

    //Hold number of days in a month
    unsigned short days_in_month[12];

    //Often feel like just hardcoding it would have been easier
    for (int i = 1; i < 13; i++){        
        switch(i){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12: days_in_month[i-1] = 31; break;
            case 2: days_in_month[i-1] = (year%4 == 0 && year%100 != 0)||(year%400 == 0)?29:28; break;
            case 4:
            case 6:
            case 9:
            case 11: days_in_month[i-1] = 30; break;
        }
        
    }

    //Remainder of each month to be used as an offset from Monday
    unsigned short month_offset[12];

    //Offset of Jan depends on the year taken
    month_offset[0] = ((((year-1)%400)/100)*5 + ((year-1)%100)*365 + ((year-1)%100)/4)%7;

    //Offset of other months depend on the previous months
    for (unsigned short i = 1; i < 12; i++){
        month_offset[i] = (month_offset[i-1] + days_in_month[i-1])%7;
    }

    row_gap();
    for (int i = 0; i < 10; i++){
        blank;
    } col_gap();
    printf("%0*llu", tabsize, year);
    row_gap(); 

    //Four iterations for four rows
    for (unsigned short row_iterator = 0; row_iterator < 4; row_iterator++){

        //Month Headers
        printf("%*s%*s%*s", 4*tabsize, month_name[3*row_iterator], (7 + col_gap_val)*tabsize, month_name[3*row_iterator + 1], (7 + col_gap_val)*tabsize, month_name[3*row_iterator + 2]);

        row_gap();

        //Day Headers
        for (unsigned short month_iterator = 0; month_iterator < 3; month_iterator++){
            for (unsigned short day_iterator = 0; day_iterator < 7; day_iterator++){
                printf("%*s", tabsize, day[day_iterator]);
            }
            col_gap();
        }
    
        endl;

        //Divider under day header
        for (unsigned short month_iterator = 0; month_iterator < 3; month_iterator++){
            for (unsigned short day_iterator = 0; day_iterator < 7; day_iterator++){
                line;
            }
            col_gap();
        }
    
        endl;

        //to store the last printed number of each month in each line
        unsigned short flag[3] = {0};

        //First row(week) of each month in the calendar
        for (unsigned short month_iterator = 0; month_iterator < 3; month_iterator++){
            //to leave blanks corresponding to the previous month / according to the Jan of that year
            for (unsigned short day_iterator = 0; day_iterator < month_offset[3*row_iterator + month_iterator]; day_iterator++){
                blank;
            }
            //print the days till Sunday
            for (unsigned short day_iterator =  0; day_iterator + month_offset[3*row_iterator + month_iterator] < 7; day_iterator++){
                printf("%*d", tabsize, day_iterator + 1);
                flag[month_iterator] = day_iterator + 1;
            }
            col_gap();
        }
    
        endl;

        //Print the next three weeks
        for (unsigned short week_iterator = 0; week_iterator < 3; week_iterator++){
            for (unsigned short month_iterator = 0; month_iterator < 3; month_iterator++){
                for (unsigned short day_iterator = 0; day_iterator < 7; day_iterator++){
                    printf("%*d", tabsize, day_iterator + flag[month_iterator] + 1);
                }
                flag[month_iterator] += 7;
                col_gap();
            }
            endl;
        }

        //Stores if a sixth line is required for any month or not
        unsigned short sixlines[3] = {0};

        //Print the last/second-last row of each month
        for (int month_iterator = 0; month_iterator < 3; month_iterator++){
            int day_iterator =  0;
            for (; day_iterator + flag[month_iterator] < days_in_month[3*row_iterator + month_iterator]; day_iterator++){
                printf("%*d", tabsize, day_iterator + flag[month_iterator] + 1);
                //check if sixth line is reqd for any month
                if (day_iterator == 6) {
                    sixlines[month_iterator] = 1;
                    flag[month_iterator] += 7;
                    break;
                }
            }

            //printing necessary blanks if sixth line isnt required
            if (sixlines[month_iterator] == 0){
                for (int k = 0; k <= 6 - day_iterator; k++){
                    blank;
                }
            }
            col_gap();
        }
        endl;

        for (int month_iterator = 0; month_iterator < 3; month_iterator++){
            if (sixlines[month_iterator] != 0){
                for (int day_iterator = 0; day_iterator + flag[month_iterator] < days_in_month[3*row_iterator + month_iterator]; day_iterator++){
                    printf("%*d", tabsize, day_iterator + flag[month_iterator] + 1);
                }
                for (int day_iterator = 0; (day_iterator + days_in_month[3*row_iterator + month_iterator])%7 != 0; day_iterator++){
                    blank;
                }
            } else {
                for (int day_iterator = 0; day_iterator < 7; day_iterator++){
                    blank;
                }
            }
            col_gap();
        }
        
        row_gap();
    
    }    
}

This is a simpler (in code) 1 column version.

//in the name of god

#include <stdio.h>

//defining the spacing of the individual cells

#define tabsize 4

//defining the vertical separator of length 4 and blank of length 4

#define line printf("%*s",tabsize ,"----")
#define blank printf("%*s",tabsize ,"")

//newline 'cause I can't keep typing it

#define endl printf("\n")

int main(){

    //the year to be taken as input
    
    int year;
    
    //prompt to enter the year
    
    printf("\nPlease enter the required year: ");
    
    //take the current year as input
    
    scanf("%d", &year);
    
    //setting offset for January of the year; every 400 years the calendar repeats; every 100 years an offset of 5 days is added; the rest is calculated manually
    
    int start = ((((year-1)%400)/100)*5 + ((year-1)%100)*365 + ((year-1)%100)/4)%7;

    //The below comment was a test to check the offset for each year. Fuck the julian calendar.

    // //printf("%d",start%7);
    
    //blank space for neatness
    
    endl; endl;

    //initialize an array to hold days of the month
    
    int month[12];

    //Array to hold the days
    
    char* day[7] = {"Mon","Tue","Wed","Thu","Fri","Sat","Sun"};
    char* month_name[12] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};

    //Initialising the no. of days in a month; if it is a year divisible by 400 or it is divisible by 4 but not by 100, then feb has 29 days
    
    for (int i = 1; i < 13; i++){
    
        switch(i){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12: month[i-1] = 31; break;
            case 2: month[i-1] = (year%4 == 0 && year%100 != 0)||(year%400 == 0)?29:28; break;
            case 4:
            case 6:
            case 9:
            case 11: month[i-1] = 30; break;
        }
        
    }
    //print the month name

    printf("%*s", 16, month_name[0]);

    endl; endl;
    
    //print the first line of days

    for (int l = 0; l < 7; l++){
       printf("%*s", tabsize, day[l]);
    }

    endl;

    //print a vertical continuous vertical line below it. Note that the continuity is created 
    //by the terminal and font glyphs. Not all terminals support this.
    
    for (int i = 0; i < 7; i++){
            line;
    }
    
    endl;

    //At the very beginning this was an array, later I realised that this wasn't required 
    //and that the offset can be calculated within the loop printing the numbers
    
    // //int rem = start;

    //Print offset for jan
    
    for (int k = 0; k < start%7; k++){
        blank;        
    }

    // start the loop for all the months
    
    for (int i = 0; i < 12; i++){

        //start loop for days in each month
        
        for (int j = 1; j <= month[i]; j++){
            printf("%*d", tabsize, j);

            
            
            if((j+start)%7 == 0){
                
                endl;
            }
        }

        //set the offset for the next month right now
        
        start =  (start + month[i])%7;

        //neatness
        
        endl; endl;

        //only do all this if the month is not dec; otherwise there would be stray spaces and an extra header of days at the very last.
        
        if (i < 11){
            printf("%*s", 16, month_name[i+1]);

            endl; endl;
            
            for (int k = 0; k < 7; k++){
                printf("%*s", tabsize, day[k]);
            }

            endl;

        for (int l = 0; l < 7; l++){
            line;
        }
        
            endl;
            
        }

        for (int m = 0; m < start; m++){
            blank;
        }            

    }
    
    endl;

}

Binary Search Tree template

#include <bits/stdc++.h>

template <typename key_, typename value_> struct Data {
    key_ key;
    value_ value;
    Data(key_ key__, value_ value__) : key(key__), value(value__) {}
    bool operator>(Data<key_, value_> D) { return key > D->key; }
    bool operator<(Data<key_, value_> D) { return key < D->key; }
    bool operator>=(Data<key_, value_> D) { return key >= D->key; }
    bool operator<=(Data<key_, value_> D) { return key <= D->key; }
    bool operator==(Data<key_, value_> D) { return key == D->key; }
    bool operator!=(Data<key_, value_> D) { return key != D->key; }
};

template <typename key_, typename value_> class BSTNode {
    Data<key_, value_> dat;
    BSTNode *parent;
    BSTNode *left;
    BSTNode *right;
    BSTNode(key_ key__, value_ value__)
        : dat(Data<key_, value_>(key__, value__)) {
        parent = nullptr;
        left = nullptr;
        right = nullptr;
    };
    BSTNode(Data<key_, value_> dat_) : dat(dat_) {
        parent = nullptr;
        left = nullptr;
        right = nullptr;
    };
    template <typename> friend class BST;
};

template <typename key_, typename value_> class BST {
  private:
    typedef BSTNode<key_, value_> data_;
    data_ *root;
    void remove_(key_ key, data_ *&ptr) {
        if (ptr == nullptr) {
            return;
        } else if (ptr->dat.key > key) {
            remove_(key, ptr->left);
        } else if (ptr->dat.key < key) {
            remove_(key, ptr->right);
        } else if (ptr->right != nullptr && ptr->left != nullptr) {
            data_ *min = min_(ptr->right);
            ptr->dat = min->dat;
            remove_(ptr->dat.key, ptr->right);
        } else {
            data_ *oldNode = ptr;
            ptr->left != nullptr ? ptr = ptr->left : ptr->right;
            if (ptr != nullptr) {
                ptr->parent = ptr->parent->parent;
            }
            delete oldNode;
        }
    }
    data_ *max_(data_ *ptr) {
        if (ptr == nullptr) {
            return nullptr;
        }
        while (ptr->right != nullptr) {
            ptr = ptr->right;
        }
        return ptr;
    }
    data_ *min_(data_ *ptr) {
        if (ptr == nullptr) {
            return nullptr;
        }
        while (ptr->left != nullptr) {
            ptr = ptr->left;
        }
        return ptr;
    }

  public:
    BST() { root = nullptr; }
    void insert(key_ key, value_ value) {
        if (root == nullptr) {
            root = new data_(key, value);
            return;
        }
        data_ *node = root;
        data_ *ins = new data_(key, value);
        while (node != nullptr) {
            if (node->dat > ins->dat && node->left == nullptr) {
                node->left = ins;
                ins->parent = node;
                return;
            } else if (node->dat < ins->dat && node->right == nullptr) {
                node->right = ins;
                ins->parent = node;
                return;
            } else if (node->dat > ins->dat) {
                node = node->left;
            } else if (node->dat < ins->dat) {
                node = node->right;
            } else {
                return;
            }
        }
    }
    void insert(Data<key_, value_> dat) {
        if (root == nullptr) {
            root = new data_(dat);
            return;
        }
        data_ *node = root;
        data_ *ins = new data_(dat);
        while (node != nullptr) {
            if (node->dat > ins->dat && node->left == nullptr) {
                node->left = ins;
                ins->parent = node;
                return;
            } else if (node->dat < ins->dat && node->right == nullptr) {
                node->right = ins;
                ins->parent = node;
                return;
            } else if (node->dat > ins->dat) {
                node = node->left;
            } else if (node->dat < ins->dat) {
                node = node->right;
            } else {
                return;
            }
        }
    }
    data_ *search(key_ key) {
        data_ *search_ = root;
        while (search_ != nullptr) {
            if (search_->dat.key > key) {
                search_ = search_->left;
            } else if (search_->dat.key < key) {
                search_ = search_->right;
            } else if (search_->dat.key == key) {
                return search_;
            }
        }
        return nullptr;
    }
    void remove(key_ key) { remove_(key, root); }
    data_ *max() { return max_(root); }
    data_ *min() { return min_(root); }
    data_ *closest(data_ num) {
        data_ *search_ = root;
        while (search_ != nullptr) {
            if (search_ == num) {
                return search_;
            } else if (search_ > num) {
                if (search_->left != nullptr) {
                    search_ = search_->left;
                } else if (search_->parent == nullptr) {
                    return search_;
                } else {
                    return (abs(search_->key - num->key) >
                                    abs(search_->parent->key - num->key)
                                ? search_->parent
                                : search_);
                }
            } else {
                if (search_->right != nullptr) {
                    search_ = search_->right;
                } else if (search_->parent == nullptr) {
                    return search_;
                } else {
                    return (abs(search_->key - num->key) >
                                    abs(search_->parent->key - num->key)
                                ? search_->parent
                                : search_);
                }
            }
        }
    }
};

int main(int argc, char *argv[]) {
    BST<int, int> B;
    return 0;
}

Balanced Binary Search Tree template

#include <bits/stdc++.h>
#include <cstdint>

template <typename key_, typename value_> struct Data {
    key_ key;
    value_ value;
    Data(key_ key__, value_ value__) : key(key__), value(value__) {}
    bool operator>(Data<key_, value_> D) { return key > D->key; }
    bool operator<(Data<key_, value_> D) { return key < D->key; }
    bool operator>=(Data<key_, value_> D) { return key >= D->key; }
    bool operator<=(Data<key_, value_> D) { return key <= D->key; }
    bool operator==(Data<key_, value_> D) { return key == D->key; }
    bool operator!=(Data<key_, value_> D) { return key != D->key; }
};

template <typename key_, typename value_> class BSTNode {
    Data<key_, value_> dat;
    BSTNode *parent;
    BSTNode *left;
    BSTNode *right;
    int64_t height;
    BSTNode(key_ key__, value_ value__)
        : dat(Data<key_, value_>(key__, value__)) {
        parent = nullptr;
        left = nullptr;
        right = nullptr;
        height = 0;
    };
    BSTNode(Data<key_, value_> dat_) : dat(dat_) {
        parent = nullptr;
        left = nullptr;
        right = nullptr;
        height = 0;
    };
    template <typename> friend class BST;
};

template <typename key_, typename value_> class BST {
  private:
    typedef BSTNode<key_, value_> data_;
    data_ *root;
    void remove_(key_ key, data_ *&ptr) {
        if (ptr == nullptr) {
            return;
        } else if (ptr->dat.key > key) {
            remove_(key, ptr->left);
        } else if (ptr->dat.key < key) {
            remove_(key, ptr->right);
        } else if (ptr->right != nullptr && ptr->left != nullptr) {
            data_ *min = min_(ptr->right);
            ptr->dat = min->dat;
            remove_(ptr->dat.key, ptr->right);
        } else {
            data_ *oldNode = ptr;
            ptr->left != nullptr ? ptr = ptr->left : ptr->right;
            if (ptr != nullptr) {
                ptr->parent = ptr->parent->parent;
            }
            delete oldNode;
        }
        balance(ptr);
    }
    data_ *max_(data_ *ptr) {
        if (ptr == nullptr) {
            return nullptr;
        }
        while (ptr->right != nullptr) {
            ptr = ptr->right;
        }
        return ptr;
    }
    data_ *min_(data_ *ptr) {
        if (ptr == nullptr) {
            return nullptr;
        }
        while (ptr->left != nullptr) {
            ptr = ptr->left;
        }
        return ptr;
    }
    void right_rot(data_ *&ptr) {
        data_ *right_child = ptr->right;
        ptr->right = right_child->left;
        right_child->left = ptr;
        right_child->parent = ptr->parent;
        ptr->parent = right_child;
        ptr->height = max(height(ptr->left), height(ptr->right)) + 1;
        right_child->height = max(height(right_child->right), ptr->height) + 1;
        ptr = right_child;
    }
    void left_rot(data_ *&ptr) {
        data_ *left_child = ptr->left;
        ptr->left = left_child->right;
        left_child->right = ptr;
        left_child->parent = ptr->parent;
        ptr->parent = left_child;
        ptr->height = max(height(ptr->left), height(ptr->right)) + 1;
        left_child->height = max(height(left_child->left), ptr->height) + 1;
        ptr = left_child;
    }
    int64_t height(data_ *ptr) const {
        return ptr == nullptr ? -1 : ptr->height;
    }
    void balance(data_ *&ptr) {
        if (ptr == nullptr) {
            return;
        }

        if (height(ptr->left) - height(ptr->right) > 1) {
            if (height(ptr->left->left) >= height(ptr->left->right)) {
                left_rot(ptr);
            } else {
                right_rot(ptr->left);
                left_rot(ptr);
            }
        } else if (height(ptr->right) - height(ptr->left) > 1) {
            if (height(ptr->right->right) >= height(ptr->right->left)) {
                right_rot(ptr);
            } else {
                left_rot(ptr->right);
                right_rot(ptr);
            }
        }
    }

  public:
    BST() { root = nullptr; }
    void insert(key_ key, value_ value) {
        if (root == nullptr) {
            root = new data_(key, value);
            return;
        }
        data_ *node = root;
        data_ *ins = new data_(key, value);
        while (node != nullptr) {
            if (node->dat > ins->dat && node->left == nullptr) {
                node->left = ins;
                ins->parent = node;
                return;
            } else if (node->dat < ins->dat && node->right == nullptr) {
                node->right = ins;
                ins->parent = node;
                return;
            } else if (node->dat > ins->dat) {
                node = node->left;
            } else if (node->dat < ins->dat) {
                node = node->right;
            } else {
                return;
            }
        }
        balance(node);
    }
    void insert(Data<key_, value_> dat) {
        if (root == nullptr) {
            root = new data_(dat);
            return;
        }
        data_ *node = root;
        data_ *ins = new data_(dat);
        while (node != nullptr) {
            if (node->dat > ins->dat && node->left == nullptr) {
                node->left = ins;
                ins->parent = node;
                return;
            } else if (node->dat < ins->dat && node->right == nullptr) {
                node->right = ins;
                ins->parent = node;
                return;
            } else if (node->dat > ins->dat) {
                node = node->left;
            } else if (node->dat < ins->dat) {
                node = node->right;
            } else {
                return;
            }
        }
        balance(node);
    }
    data_ *search(key_ key) {
        data_ *search_ = root;
        while (search_ != nullptr) {
            if (search_->dat.key > key) {
                search_ = search_->left;
            } else if (search_->dat.key < key) {
                search_ = search_->right;
            } else if (search_->dat.key == key) {
                return search_;
            }
        }
        return nullptr;
    }
    void remove(key_ key) { remove_(key, root); }
    data_ *max() { return max_(root); }
    data_ *min() { return min_(root); }
};

int main(int argc, char *argv[]) {
    BST<int, int> B;
    return 0;
}