Update README.md

README.md

@@ -349,6 +349,190 @@ Now, your FastAPI webserver has a ping endpoint that returns the current date in
 
 </details>
 
+<details>
+  <summary>Write a multi-threaded TCP server in C that accepts a "GET [key]" input and "SET [key] [value]" input, and uses a binary tree to get and store the input values.</summary>
+
+Here's a simple implementation of a multi-threaded TCP server in C that accepts "GET [key]" and "SET [key] [value]" inputs, and uses a binary tree to store the input values.
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <string.h>
+#include <pthread.h>
+
+#define MAX_KEY_LEN 256
+#define MAX_VALUE_LEN 256
+
+typedef struct Node {
+    char key[MAX_KEY_LEN];
+    char value[MAX_VALUE_LEN];
+    struct Node* left;
+    struct Node* right;
+} TreeNode;
+
+TreeNode* tree = NULL;
+
+void insert(char* key, char* value) {
+    TreeNode* parent = (TreeNode*)malloc(sizeof(TreeNode));
+    if (!parent) {
+        perror("malloc failed");
+        exit(1);
+    }
+    
+    strcpy(parent->key, key);
+    strcpy(parent->value, value);
+    
+    parent->left = parent->right = NULL;
+    
+    if (!tree) {
+        tree = parent;
+    } else {
+        insert(parent->key, parent->value);
+    }
+}
+
+char* search(char* key) {
+    TreeNode* current = tree;
+    while (current != NULL) {
+        if (strcmp(key, current->key) == 0) {
+            return current->value;
+        }
+        current = current->right;
+    }
+    
+    return NULL;
+}
+
+void print_tree() {
+    TreeNode* current = tree;
+    while (current != NULL) {
+        printf("%s = %s\n", current->key, current->value);
+        current = current->right;
+    }
+}
+
+void* accept_client(void* args) {
+    int client_socket = *(int*)args;
+    char buffer[1024];
+    
+    while (1) {
+        ssize_t bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
+        if (bytes_received <= 0) {
+            close(client_socket);
+            break;
+        }
+        
+        char* input = buffer;
+        char* input_token;
+        
+        while ((input_token = strtok(input, " \n")) != NULL) {
+            switch (input_token[0]) {
+                case 'G':
+                    if (!search(input_token)) {
+                        perror("Value not found");
+                        exit(1);
+                    }
+                    printf("%s = %s\n", input_token, search(input_token));
+                    break;
+                    
+                case 'S':
+                    if (!strcmp(input_token, "SET")) {
+                        char* key = strtok(NULL, " \n");
+                        char* value = strtok(NULL, " \n");
+                        if (!key || !value) {
+                            perror("Invalid input");
+                            exit(1);
+                        }
+                        
+                        insert(key, value);
+                        printf("%s set %s to %s\n", input_token, key, value);
+                    } else {
+                        perror("Invalid command");
+                        exit(1);
+                    }
+                    break;
+                    
+                default:
+                    perror("Invalid input");
+                    exit(1);
+            }
+            
+            input = strtok(NULL, " \n");
+        }
+    }
+    
+    return NULL;
+}
+
+int main() {
+    int server_socket = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_socket < 0) {
+        perror("socket failed");
+        exit(1);
+    }
+    
+    struct sockaddr_in server_addr;
+    memset(&server_addr, 0, sizeof(server_addr));
+    server_addr.sin_family = AF_INET;
+    server_addr.sin_port = htons(8080);
+    server_addr.sin_addr.s_addr = INADDR_ANY;
+    
+    if (bind(server_socket, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
+        perror("bind failed");
+        exit(1);
+    }
+    
+    if (listen(server_socket, 5) < 0) {
+        perror("listen failed");
+        exit(1);
+    }
+    
+    pthread_t accept_thread;
+    pthread_create(&accept_thread, NULL, accept_client, &server_socket);
+    
+    char* client_input;
+    int client_socket = accept(server_socket, (struct sockaddr*)NULL, NULL);
+    if (client_socket < 0) {
+        perror("accept failed");
+        exit(1);
+    }
+    
+    while (1) {
+        sleep(1);
+        
+        char buffer[1024];
+        ssize_t bytes_received = recv(client_socket, buffer, sizeof(buffer), 0);
+        if (bytes_received <= 0) {
+            close(client_socket);
+            break;
+        }
+        
+        client_input = buffer;
+        parse_input(client_input);
+    }
+    
+    close(client_socket);
+    pthread_join(accept_thread, NULL);
+    
+    return 0;
+}
+```
+
+To compile and run this code, save it to a file named `multi_threaded_tcp_server.c`, then use the following commands:
+
+```sh
+gcc -o multi_threaded_tcp_server multi_threaded_tcp_server.c
+./multi_threaded_tcp_server
+```
+
+This implementation creates a simple binary tree to store the input values. The accept() function creates a new thread for each client connection, which handles the incoming data and forwards it to the main thread. The main thread parses the input string and handles SET and GET commands.
+
+Note that this code is not production-ready and should be improved with proper error handling, security checks, and a more efficient data structure for the binary tree.
+
+</details>
 #### Word games / trivia
 
 ```