Hello, I'm Hendry

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <conio.h>
#include <time.h>

void MainMenu()
{
    printf("2048\n\n\n");
    printf("    1. New Game\n");
    printf("    2. Highscore\n");
    printf("    3. Exit\n");
    printf("    >> ");
}

struct Player
{
    char UserID[6];
    char Name[16];
    int score;

    struct Player* next;
};

struct Player* addPlayer(struct Player* head, char UserID[6], char Name[16], int score)
{
    struct Player* newNode = (struct Player*)malloc(sizeof(struct Player));

    strcpy(newNode->UserID, UserID);
    strcpy(newNode->Name, Name);
    newNode->score = score;

    newNode->next = head;

    head = newNode;

    return head;
}

void swapPlayers(struct Player* a, struct Player* b)
{
    struct Player temp = *a;
    *a = *b;
    *b = temp;
}

int partition(struct Player* arr, int low, int high)
{
    int pivot = arr[high].score;
    int i = (low - 1);

    for (int j = low; j <= high - 1; j++)
    {
        if (arr[j].score > pivot)
        {
            i++;
            swapPlayers(&arr[i], &arr[j]);
        }
    }
    swapPlayers(&arr[i + 1], &arr[high]);
    return (i + 1);
}

void quickSort(struct Player* arr, int low, int high)
{
    if (low < high)
    {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

void printTop10Scores(struct Player* head)
{
    if (head == NULL)
    {
        printf("No HighScores\n");
        return;
    }

    struct Player* top10 = (struct Player*)malloc(10 * sizeof(struct Player));
    int i;
    for (i = 0; i < 10; i++)
    {
        top10[i].score = -1;
    }

    struct Player* current = head;
    while (current != NULL)
    {
        for (i = 0; i < 10; i++)
        {
            if (current->score > top10[i].score)
            {
                for (int j = 9; j > i; j--)
                {
                    top10[j] = top10[j - 1];
                }
                top10[i] = *current;
                break;
            }
        }
        current = current->next;
    }

    quickSort(top10, 0, 9);

    printf("%-3s |%-10s |%-15s |%s\n", "No.", "ID", "Username", "Score");
    for (i = 0; i < 10; i++)
    {
        printf("%-3d |%-10s |%-15s |%d\n", i + 1, top10[i].UserID, top10[i].Name, top10[i].score);
    }

    free(top10);
}

int BOARD_SIZE = 4;

int board[6][6];

void StartingBoard()
{
    for (int i = 0; i < BOARD_SIZE; i++)
    {
        for (int j = 0; j < BOARD_SIZE; j++)
        {
            board[i][j] = 0;
        }
    }
}

void randomTiles()
{
    int emptyTiles[BOARD_SIZE * BOARD_SIZE][2];
    int count = 0;

    for (int i = 0; i < BOARD_SIZE; i++)
    {
        for (int j = 0; j < BOARD_SIZE; j++)
        {
            if (board[i][j] == 0)
            {
                emptyTiles[count][0] = i;
                emptyTiles[count][1] = j;
                count++;
            }
        }
    }

    if (count > 0)
    {
        int randomIndex = rand() % count;
        int value = (rand() % 2 + 1) * 2;
        int x = emptyTiles[randomIndex][0];
        int y = emptyTiles[randomIndex][1];
        board[x][y] = value;
    }
}

int score = 0;

void printBoard()
{
    system("cls");
    printf("2048 Game\n");

    for (int i = 0; i < BOARD_SIZE; i++)
    {
        for (int j = 0; j < BOARD_SIZE; j++)
        {
            if (board[i][j] == 0)
            {
                printf("| %-4s ", "");
            }
            else
            {
                printf("| %-4d ", board[i][j]);
            }
        }
        printf("|\n");
        if (i < BOARD_SIZE - 1)
        {
            for (int j = 0; j < BOARD_SIZE; j++)
            {
                printf("+------");
            }
            printf("+\n");
        }
    }

    printf("Score: %d\n\n\n[Press Enter To Exit]", score);
}

void moveUp()
{
    for (int column = 0; column < BOARD_SIZE; column++)
    {
        for (int row = 1; row < BOARD_SIZE; row++)
        {
            if (board[row][column] != 0)
            {
                int newRow = row;

                while (newRow > 0 && board[newRow - 1][column] == 0)
                {
                    board[newRow - 1][column] = board[newRow][column];
                    board[newRow][column] = 0;
                    newRow--;
                }

                if (newRow > 0 && board[newRow - 1][column] == board[newRow][column])
                {
                    int merge = board[newRow - 1][column] * 2;
                    board[newRow - 1][column] = merge;
                    board[newRow][column] = 0;
                    score += merge;
                }
            }
        }
    }
}

void moveDown()
{
    for (int column = 0; column < BOARD_SIZE; column++)
    {
        for (int row = BOARD_SIZE - 2; row >= 0; row--)
        {
            if (board[row][column] != 0)
            {
                int newRow = row;
                while (newRow < BOARD_SIZE - 1 && board[newRow + 1][column] == 0)
                {
                    board[newRow + 1][column] = board[newRow][column];
                    board[newRow][column] = 0;
                    newRow++;
                }
                if (newRow < BOARD_SIZE - 1 && board[newRow + 1][column] == board[newRow][column])
                {
                    int merge = board[newRow + 1][column] * 2;
                    board[newRow + 1][column] = merge;
                    board[newRow][column] = 0;
                    score += merge;
                }
            }
        }
    }
}

void moveLeft()
{
    for (int row = 0; row < BOARD_SIZE; row++)
    {
        for (int column = 1; column < BOARD_SIZE; column++)
        {
            if (board[row][column] != 0)
            {
                int newColumn = column;
                while (newColumn > 0 && board[row][newColumn - 1] == 0)
                {
                    board[row][newColumn - 1] = board[row][newColumn];
                    board[row][newColumn] = 0;
                    newColumn--;
                }
                if (newColumn > 0 && board[row][newColumn - 1] == board[row][newColumn])
                {
                    int merge = board[row][newColumn - 1] * 2;
                    board[row][newColumn - 1] = merge;
                    board[row][newColumn] = 0;
                    score += merge;
                }
            }
        }
    }
}

void moveRight()
{
    for (int row = 0; row < BOARD_SIZE; row++)
    {
        for (int column = BOARD_SIZE - 2; column >= 0; column--)
        {
            if (board[row][column] != 0)
            {
                int newColumn = column;
                while (newColumn < BOARD_SIZE - 1 && board[row][newColumn + 1] == 0)
                {
                    board[row][newColumn + 1] = board[row][newColumn];
                    board[row][newColumn] = 0;
                    newColumn++;
                }
                if (newColumn < BOARD_SIZE - 1 && board[row][newColumn + 1] == board[row][newColumn])
                {
                    int merge = board[row][newColumn + 1] * 2;
                    board[row][newColumn + 1] = merge;
                    board[row][newColumn] = 0;
                    score += merge;
                }
            }
        }
    }
}

int GameOver()
{
    for (int i = 0; i < BOARD_SIZE; i++)
    {
        for (int j = 0; j < BOARD_SIZE; j++)
        {
            if (board[i][j] == 0)
            {
                return 0;
            }

            if ((i > 0 && board[i][j] == board[i - 1][j]) ||
                (i < BOARD_SIZE - 1 && board[i][j] == board[i + 1][j]) ||
                (j > 0 && board[i][j] == board[i][j - 1]) ||
                (j < BOARD_SIZE - 1 && board[i][j] == board[i][j + 1]))
            {
                return 0;
            }
        }
    }

    return 1;
}

struct Player* readPlayersFromFile(const char* filename)
{
    FILE* fp = fopen("highscore.txt", "r");
    if (fp == NULL)
    {
        return NULL;
    }

    struct Player* head = NULL;
    char UserID[6];
    char Name[16];
    int score;

    while (fscanf(fp, "%5[^#]#%14[^#]#%d\n", UserID, Name, &score) == 3)
    {
        head = addPlayer(head, UserID, Name, score);
    }

    fclose(fp);
    return head;
}

int main()
{
    int count = 0;

    struct Player* head = readPlayersFromFile("highscore.txt");

    int MenuChoice;

    do
    {
        MainMenu();

        scanf("%d", &MenuChoice);
        getchar();

        switch (MenuChoice)
        {
        case 1: // play
        {
            int gameRunning = 1;

            do
            {
                printf("Input Grid Size [4 or 6]: ");
                scanf("%d", &BOARD_SIZE);
                getchar();
            } while (BOARD_SIZE != 4 && BOARD_SIZE != 6);

            score = 0;

            srand(time(NULL));

            StartingBoard();
            randomTiles();
            randomTiles();

            do
            {
                printBoard();

                char key = getch();

                switch (key)
                {
                case 'w':
                    moveUp();
                    break;

                case 's':
                    moveDown();
                    break;

                case 'a':
                    moveLeft();
                    break;

                case 'd':
                    moveRight();
                    break;

                case '\r':
                    gameRunning = 0;
                    break;
                }

                int checkGameOver = GameOver();

                if (checkGameOver == 1)
                {
                    getchar();

                    break;
                }

                randomTiles();
            } while (gameRunning == 1);

            system("cls");

            char name[16];

            do
            {
                printf("Input Name [name length must be between 3-15]: ");
                scanf(" %[^\n]", name);
                getchar();
            } while (strlen(name) < 3 || strlen(name) > 15);

            char id[6];

            int random[3];

            for (int i = 0; i < 3; i++)
            {
                random[i] = rand() % 10;
            }

            sprintf(id, "%c%c%d%d%d", toupper(name[0]), toupper(name[1]), random[0], random[1], random[2]);

            head = addPlayer(head, id, name, score);

            FILE* ADD = fopen("highscore.txt", "a");
            fprintf(ADD, "%s#%s#%d\n", id, name, score);
            fclose(ADD);

            break;
        }

        case 2: // show highscore
            system("cls");

            printTop10Scores(head);

            printf("\n\nPress Enter to Continue...");

            getchar();
            break;

        case 3: // exit
            system("cls");

            printf("Thank you for playing!");

            return 0;
            break;
        }

        system("cls");
    } while (MenuChoice != 3);

    return 0;
}      
                    

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <conio.h>

void printLabirinth()
{
    printf(" _      ____ ____  ____ ____  ____ ____	 ______	__ __		\n");
    printf("| |    /    |    \\|    |    \\|    |    \\|      |  |  |	\n");
    printf("| |   |  o  |  o  )|  ||  D  )|  ||  _  |      |  |  |		\n");
    printf("| |___|	    |     ||  ||    / |  ||  |  |_|  |_|  _  |		\n");
    printf("|     |  _  |  O  ||  ||    \\ |  ||  |  | |  | |  |  |	   	\n");
    printf("|     |  |  |     ||  ||  .  \\|  ||  |  | |  | |  |  | 	\n");
    printf("|_____|__|__|_____|____|__|\\_|____|__|__| |__| |__|__|		\n");
    printf("_--___-^_^-_--__^-_--__^-^--^^^^-^_^-_-^_^-_---__^--__-	  \n\n");
}

void printIntro()
{
    printf("Welcome to labIRinth!\n\n");
    printf("One day, you wake up in a cursed labyrinth and want to escape.\n");
    printf("But, you realised that it might not be that easy.\n");
    printf("As you look around, you realize that there are mummies roaming the place.\n");
    printf("Try to get to the exit without getting caught by the mummies.\n");
    printf("Good luck and have fun!\n");
}

char easy[20][40] = 
{
    "######################################",
    "#                                    #",
    "#  P        #                        #",
    "#           #                        #",
    "#           #                        #",
    "#           # ######                 #",
    "#                                    #",
    "#                                    #",
    "#      # ######                      #",
    "#      #                             #",
    "#      #                     ###     #",
    "#      #                     ###     #",
    "#                            ###     #",
    "#                                    #",
    "#                ####                #",
    "#                #  #                #",
    "#                ####              O #",
    "#                                    #",
    "######################################",
};

char medium[20][40] =
{
    "######################################",
    "#                 O                  #",
    "#                ###       #         #",
    "#                                    #",
    "#                     ####           #",
    "#                                    #",
    "#                #                   #",
    "#    ##             #                #",
    "#       #                            #",
    "#       #         # # #              #",
    "#                                    #",
    "#                #                   #",
    "#                #                   #",
    "#                                    #",
    "#        ##                          #",
    "#            #                    ####",
    "#          #                 #     P #",
    "#                 #          #       #",
    "######################################",
};

char hard[20][40] =
{
    "######################################",
    "#                               P    #",
    "#                    #               #",
    "#       #                    ####### #",
    "#                  #                 #",
    "#      # ######              ###     #",
    "#      #                     #       #",
    "#      #           ####              #",
    "#                          ##        #",
    "#               ###                  #",
    "#         ##            #            #",
    "#         ##          # #            #",
    "#               #####                #",
    "#    ###                ############ #",
    "#    ###          ###                #",
    "#    ###              #         #### #",
    "#                     #       #   O  #",
    "#                                    #",
    "######################################",
};

void printWin()
{
    printf(" __      __ __	 ___   __ __     __    __  ____  ____       __		\n");
    printf("|  |    |  |  | /   \\ |  |  |   |  |__|  ||    ||    \\     |  | 	\n");
    printf("|  |    |  |  ||     ||  |  |   |  |  |  | |  | |  _  |    |  |		\n");
    printf("|__|    |  ~  ||  O  ||  |  |   |  |  |  | |  | |  |  |    |__|		\n");
    printf(" __     |___, ||     ||  :  |   |  `  '  | |  | |  |  |     __ 		\n");
    printf("|  |    |     ||     ||     |    \\      /  |  | |  |  |    |  |	\n");
    printf("|__|    |____/  \\___/  \\__,_|     \\_/\\_/  |____||__|__|    |__|	\n");
}


void printInformation()
{
    printf("\nW A S D to move\n\nLegends\n");
    printf("P player\nl mummy\nO escape");
    printf("\n\nPress ENTER to exit");
}


void showMaze(char maze[20][40])
{
    for(int i=0; i<20; i++)
    {
        for(int j=0; j<40; j++)
        {
            printf("%c", maze[i][j]);
        }
        printf("\n");
    }
}

int main()
{
	printLabirinth();
	printIntro();
	
	printf("\nPress any key to continue...");
	getch();
	
	system("cls");

    char moveInput;
    
    int easyY = 2;
    int easyX = 2;
    
    int mediumY = 16;
    int mediumX = 35;
    
    int hardY = 1;
    int hardX = 32;
    
    int difficulty;
    int win = 0;

    do
	{
        printLabirinth();

        printf("Difficulty Level\n");
        printf("--------------------\n");
        printf("1. Easy\n2. Medium\n3. Hard\nChoose your difficulty (0 to exit): ");

        scanf("%d", &difficulty);
        getchar();
        system("cls");

        switch(difficulty)
		{
            case 1:
                system("cls");
                showMaze(easy);
                printInformation();

                do
				{
                    moveInput = _getch();

                    switch (moveInput)
					{
                        case 'w':
                            if(easy[easyY - 1][easyX] != '#')
							{
                                easy[easyY][easyX] = ' ';
                                easyY--;
                                easy[easyY][easyX] = 'P';
							}

                            break;
                        case 'a':
                            if(easy[easyY][easyX - 1] != '#')
							{
                                easy[easyY][easyX] = ' ';
                                easyX--;
                                easy[easyY][easyX] = 'P';
							}

                            break;
                        case 's':
                            if(easy[easyY + 1][easyX] != '#')
							{
                                easy[easyY][easyX] = ' ';
                                easyY++;
                                easy[easyY][easyX] = 'P';
							}

                            break;
                        case 'd':
                            if(easy[easyY][easyX + 1] != '#')
							{
                                easy[easyY][easyX] = ' ';
                                easyX++;
                                easy[easyY][easyX] = 'P';
							}

                            break;
                        default:
                            break;
                    }

                    system("cls");
                    showMaze(easy);
                    printInformation();
                    
                }while(easyY != 16 || easyX != 35);
                
                system("cls");
                
                printWin();
                
                return 0;

                break;
                
            case 2:
                system("cls");
                showMaze(medium);
                printInformation();
                
                do
				{
                    moveInput = _getch();

                    switch (moveInput)
					{
                        case 'w':
                            if(medium[mediumY - 1][mediumX] != '#')
							{
                                medium[mediumY][mediumX] = ' ';
                                mediumY--;
                                medium[mediumY][mediumX] = 'P';
							}

                            break;
                        case 'a':
                            if(medium[mediumY][mediumX - 1] != '#')
							{
                                medium[mediumY][mediumX] = ' ';
                                mediumX--;
                                medium[mediumY][mediumX] = 'P';
							}

                            break;
                        case 's':
                            if(medium[mediumY + 1][mediumX] != '#')
							{
                                medium[mediumY][mediumX] = ' ';
                                mediumY++;
                                medium[mediumY][mediumX] = 'P';
							}

                            break;
                        case 'd':
                            if(medium[mediumY][mediumX + 1] != '#')
							{
                                medium[mediumY][mediumX] = ' ';
                                mediumX++;
                                medium[mediumY][mediumX] = 'P';
							}

                            break;
                        default:
                            break;
                    }

                    system("cls");
                    showMaze(medium);
                    printInformation();
                    
                }while(mediumY != 1 || mediumX != 18);
                
                system("cls");
                
                printWin();
                
                return 0;

                break;
                
            case 3:
                system("cls");
                showMaze(hard);
                printInformation();
                
                do
				{
                    moveInput = _getch();

                    switch (moveInput)
					{
                        case 'w':
                            if(hard[hardY - 1][hardX] != '#')
							{
                                hard[hardY][hardX] = ' ';
                                hardY--;
                                hard[hardY][hardX] = 'P';
							}

                            break;
                        case 'a':
                            if(hard[hardY][hardX - 1] != '#')
							{
                                hard[hardY][hardX] = ' ';
                                hardX--;
                                hard[hardY][hardX] = 'P';
							}

                            break;
                        case 's':
                            if(hard[hardY + 1][hardX] != '#')
							{
                                hard[hardY][hardX] = ' ';
                                hardY++;
                                hard[hardY][hardX] = 'P';
							}

                            break;
                        case 'd':
                            if(hard[hardY][hardX + 1] != '#')
							{
                                hard[hardY][hardX] = ' ';
                                hardX++;
                                hard[hardY][hardX] = 'P';
							}

                            break;
                        default:
                            break;
                    }

                    system("cls");
                    showMaze(hard);
                    printInformation();
                    
                }while(hardY != 16 || hardX != 34);
                
                system("cls");
                
                printWin();
                
                return 0;

                break;
                
            default:
                break;
        }

    } while (difficulty != 0);

    return 0;
}
                    

#include <stdio.h>
#include <string.h>

int main() {
    int N, M, K;
    scanf("%d %d %d", &N, &M, &K);

    char team_names[N][101];
    char institutions[N][101];

    for(int i=0; i<N; i++)
    {
        scanf(" %s %s", team_names[i], institutions[i]);
    }
    
    char uneligible_institutions[M][101];
    int uneligible_count;
    
    for(int i=0; i<M; i++)
    {
        strcpy(uneligible_institutions[i], institutions[i]);
        uneligible_count++;
    }
    
    int golden_tickets_count = 0;
    char golden_tickets_teams[N][101];
    int institution_won[N];

    for(int i=0; i<N; i++)
    {
        institution_won[i] = 0;
    }
    
    for(int i=0; i<N; i++)
    {
        if(golden_tickets_count < K)
        {
            int is_unelegible = 0;
            
            for(int j=0; j<uneligible_count; j++)
            {
                if(strcmp(institutions[i], uneligible_institutions[j]) == 0)
                {
                    is_unelegible = 1;
                    break;
                }
            }
                        
            if(!is_unelegible && !institution_won[i])
            {
                strcpy(golden_tickets_teams[golden_tickets_count], team_names[i]);
                golden_tickets_count++;
                
                strcpy(uneligible_institutions[uneligible_count], institutions[i]);
                uneligible_count++;
            }
        }
    }
    
    printf("%d\n", golden_tickets_count);
    
    for(int i=0; i<golden_tickets_count; i++)
    {
        printf("%s\n", golden_tickets_teams[i]);
    }
    

    return 0;
}
                        
                    

#include <stdio.h>

int main()
{
    int N = 0, M = 0, K = 0;
    scanf("%d %d %d", &N, &M, &K);
    
    int P[N+1] = {0};
    
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &P[i]);
    }

    int i = 0;
    
    for(i=0; i<N; i++)
    {
        int max = 0;
        int index = 0;
        M -= P[i];
        
        if(M >= 0)
        {
            continue;
        }
        else if(K > 0)
        {
            K--;
            for(int j=0; j<=i; j++)
            {
                if(max < P[j])
                {
                    max = P[j];
                    index = j;
                }
            }
            
            M += max;
            P[index] = 0;
        }
        else
        {
            printf("%d\n", i);
            break;
        }
    }
    
    if(i == N)
    {
        printf("%d\n", N);
    }

    return 0;
}
                        
                    

#include <stdio.h>
#include <stdlib.h>

struct Treasure
{
    int weight;
    int value;
    int index;
    int taken;
};

int compare(const void *a, const void *b)
{
    return ((struct Treasure *)b)->value - ((struct Treasure *)a)->value;
}

int compareWeight(const void *a, const void *b)
{
    return ((struct Treasure *)a)->weight - ((struct Treasure *)b)->weight;
}

void swap(struct Treasure *a, struct Treasure *b)
{
    struct Treasure temp = *a;
    *a = *b;
    *b = temp;
}

int main()
{
    int N, M;

    scanf("%d %d", &N, &M);

    struct Treasure treasures[N];
    for (int i=0; i<N; i++)
    {
        scanf("%d %d", &treasures[i].weight, &treasures[i].value);
        treasures[i].index = i + 1;
        treasures[i].taken = 0;
    }

    qsort(treasures, N, sizeof(struct Treasure), compare);

    int S[M];
    for (int j = 0; j < M; j++)
    {
        scanf("%d", &S[j]);
    }

    qsort(S, M, sizeof(int), compareWeight);

    int total_treasure = 0;
    
    for (int j=0; j<M; j++)
    {
        for (int i=0; i<N; i++)
        {
            if (S[j] >= treasures[i].weight && treasures[i].taken == 0)
            {
                total_treasure += treasures[i].value;
                treasures[i].taken = 1;
                
                break;
            }
        }
    }

    printf("%d\n", total_treasure);

    return 0;
}