ciso646

---

1. Character Processing

int main() {
  // Convert a character to uppercase
  char c = 'a';
  c = toupper(c); // c is now 'A'
}

2. Mathematical Operations

int main() {
  // Calculate the absolute value of a number
  int x = -5;
  x = abs(x); // x is now 5
}

3. String Manipulation

int main() {
  // Concatenate two strings
  char s1[] = "Hello";
  char s2[] = "World";
  strcat(s1, s2); // s1 is now "HelloWorld"
}

4. Memory Management

int main() {
  // Allocate memory for a variable
  int* p = (int*)malloc(sizeof(int));
  *p = 5; // Store 5 at memory address pointed by p
}

5. File I/O

int main() {
  // Read a character from a file
  FILE* fp = fopen("file.txt", "r");
  char c = fgetc(fp); // Read the first character from the file
}

6. Date and Time

int main() {
  // Get the current time
  time_t now = time(0);
  struct tm* timeinfo = localtime(&now);
  printf("%d-%d-%d %d:%d:%d\n", timeinfo->tm_year + 1900, timeinfo->tm_mon + 1,
         timeinfo->tm_mday, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
}

7. Error Handling

int main() {
  // Check if file opening failed
  FILE* fp = fopen("file.txt", "r");
  if (fp == NULL) {
    perror("Error opening file");
    return EXIT_FAILURE;
  }

  // Read the first character from the file
  char c = fgetc(fp);
}

8. Networking

int main() {
  // Create a socket
  int sock = socket(AF_INET, SOCK_STREAM, 0);
  if (sock == -1) {
    perror("Error creating socket");
    return EXIT_FAILURE;
  }

  // Bind the socket to an address
  struct sockaddr_in addr;
  addr.sin_family = AF_INET;
  addr.sin_port = htons(80);
  addr.sin_addr.s_addr = INADDR_ANY;
  int bind_result = bind(sock, (struct sockaddr*)&addr, sizeof(addr));
  if (bind_result == -1) {
    perror("Error binding socket");
    return EXIT_FAILURE;
  }

  // Listen for connections
  int listen_result = listen(sock, 5);
  if (listen_result == -1) {
    perror("Error listening on socket");
    return EXIT_FAILURE;
  }
}

9. Multithreading

int main() {
  // Create a thread
  pthread_t tid;
  pthread_create(&tid, NULL, thread_function, (void*)arg);

  // Join the thread
  pthread_join(tid, NULL);
}

10. Synchronization

int main() {
  // Create a mutex
  pthread_mutex_t mutex;
  pthread_mutex_init(&mutex, NULL);

  // Lock the mutex
  pthread_mutex_lock(&mutex);

  // Unlock the mutex
  pthread_mutex_unlock(&mutex);
}

11. Sorting

int main() {
  // Sort an array of integers
  int arr[] = {5, 3, 1, 2, 4};
  qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), compare_function);
}

12. Searching

int main() {
  // Search for a value in an array using binary search
  int arr[] = {1, 2, 3, 4, 5};
  int value = 3;
  int index = binary_search(arr, sizeof(arr) / sizeof(arr[0]), value);
}

13. Hashing

int main() {
  // Create a hash table
  hash_table* ht = create_hash_table(10);

  // Insert a key-value pair into the hash table
  hash_insert(ht, "key", "value");

  // Retrieve a value from the hash table given a key
  char* value = hash_get(ht, "key");
}

14. Recursion

int factorial(int n) {
  if (n == 0) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}

15. Dynamic Programming

int main() {
  // Solve the Fibonacci sequence using dynamic programming
  int fib[10];
  fib[0] = 0;
  fib[1] = 1;
  for (int i = 2; i < 10; i++) {
    fib[i] = fib[i - 1] + fib[i - 2];
  }
}

16. Graph Algorithms

int main() {
  // Create a graph
  graph* g = create_graph(10);

  // Add an edge to the graph
  add_edge(g, 0, 1, 10);

  // Perform a depth-first search on the graph
  depth_first_search(g, 0);
}

17. Sorting Algorithms

int main() {
  // Sort an array of integers using the bubble sort algorithm
  int arr[] = {5, 3, 1, 2, 4};
  bubble_sort(arr, sizeof(arr) / sizeof(arr[0]));
}

18. Searching Algorithms

int main() {
  // Search for a value in an array using the linear search algorithm
  int arr[] = {5, 3, 1, 2, 4};
  int value = 3;
  int index = linear_search(arr, sizeof(arr) / sizeof(arr[0]), value);
}

19. String Manipulation

int main() {
  // Convert a string to lowercase
  char s[] = "HELLO";
  int length = strlen(s);
  for (int i = 0; i < length; i++) {
    s[i] = tolower(s[i]);
  }
}

20. Memory Management

int main() {
  // Allocate memory for a variable dynamically
  int* p = (int*)malloc(sizeof(int));
  *p = 5; // Initialize the allocated memory

  // Free the allocated memory
  free(p);
}

21. File Input/Output

int main() {
  // Open a file for reading
  FILE* fp = fopen("file.txt", "r");
  if (fp == NULL) {
    perror("Error opening file");
    return EXIT_FAILURE;
  }

  // Read the contents of the file
  char ch;
  while ((ch = fgetc(fp)) != EOF) {
    printf("%c", ch);
  }

  // Close the file
  fclose(fp);
}

22. Command-Line Arguments

int main(int argc, char* argv[]) {
  // Check if the command-line argument is present
  if (argc > 1) {
    printf("The command-line argument is: %s\n", argv[1]);
  } else {
    printf("No command-line argument provided\n");
  }
}

23. Mathematical Functions

int main() {
  // Calculate the sine of an angle
  double angle = 30;
  double sine = sin(angle * M_PI / 180);
}

24. Random Numbers

int main() {
  // Generate a random number between 0 and 9
  srand(time(NULL));
  int random_number = rand() % 10;
}

25. Date and Time Manipulation

int main() {
  // Get the current date and time
  time_t now = time(NULL);
  struct tm* timeinfo = localtime(&now);
  printf("%d/%d/%d %d:%d:%d\n", timeinfo->tm_mday, timeinfo->tm_mon + 1, timeinfo->tm_year + 1900, timeinfo->tm_hour,
         timeinfo->tm_min, timeinfo->tm_sec);
}

26. Input/Output Redirection

int main() {
  // Redirect standard output to a file
  freopen("output.txt", "w", stdout);
  printf("This output will be written to the file output.txt\n");
}

27. Error Handling

int main() {
  // Handle an error using the try-catch block
  try {
    // Code that may throw an exception
  } catch (const std::exception& e) {
    std::cerr << "An exception occurred: " << e.what() << "\n";
  }
}

28. Object-Oriented Programming

class MyClass {
public:
  int x;
  MyClass(int x) : x(x) {}
  int get_x() { return x; }
};

int main() {
  // Create an object of the MyClass class
  MyClass my_object(5);
  std::cout << my_object.get_x() << "\n";
}

29. Inheritance

class BaseClass {
public:
  int x;
  BaseClass(int x) : x(x) {}
};

class DerivedClass : public BaseClass {
public:
  int y;
  DerivedClass(int x, int y) : BaseClass(x), y(y) {}
  int get_y() { return y; }
};

int main() {
  // Create an object of the DerivedClass class
  DerivedClass derived_object(5, 10);
  std::cout << derived_object.get_x() << " " << derived_object.get_y() << "\n";
}

30. Polymorphism

class Shape {
public:
  virtual double get_area() = 0;
};

class Circle : public Shape {
public:
  double radius;
  Circle(double radius) : radius(radius) {}
  double get_area() { return M_PI * radius * radius; }
};

class Rectangle : public Shape {
public:
  double length;
  double width;
  Rectangle(double length, double width) : length(length), width(width) {}
  double get_area() { return length * width; }
};

int main() {
  // Create an array of shapes
  Shape* shapes[] = {new Circle(5), new Rectangle(10, 5)};

  // Calculate the area of each shape
  for (int i = 0; i < 2; i++) {
    std::cout << shapes[i]->get_area() << "\n";
  }
}

31. Templates

template <typename T>
T max(T a, T b) { return (a > b) ? a : b; }

int main() {
  int i = max(5, 10);
  double d = max(3.5, 10.5);
  std::cout << i << " " << d << "\n";
}

32. Exception Handling

int main() {
  try {
    // Code that may throw an exception
    throw std::runtime_error("An error occurred");
  } catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << "\n";
  }
}

33. Iterators

std::vector<int> numbers = {1, 2, 3, 4, 5};

// Iterate over the vector using an iterator
for (std::vector<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) {
  std::cout << *it << " ";
}

34. Containers

std::map<std::string, int> my_map = {{"key1", 1}, {"key2", 2}, {"key3", 3}};

// Access the value associated with a key
int value = my_map["key2"];
std::cout << value << "\n";

35. Algorithms

std::vector<int> numbers = {1, 2, 3, 4, 5};

// Sort the vector in ascending order
std::sort(numbers.begin(), numbers.end());
for (int number : numbers) {
  std::cout << number << " ";
}

36. Input/Output Streams

std::ofstream output_file("output.txt");
output_file << "This is a line of text that will be written to the file\n";
output_file.close();

37. Regular Expressions

std::regex phone_number_regex("^(\\d{3}-){2}\\d{4}$");

// Check if a string matches a phone number pattern
bool is_phone_number = std::regex_match("123-456-7890", phone_number_regex);

38. Multithreading

#include <thread>

void thread_function() {
  std::cout << "This is running in a separate thread\n";
}

int main() {
  std::thread t(thread_function);
  t.join();
}

39. Networking

#include <sys/socket.h>
#include <netinet/in.h>

int main() {
  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
  if (sockfd == -1) {
    perror("Error creating socket");
    return EXIT_FAILURE;
  }

  // ...
}

40. Database Connectivity

#include <mysql.h>

int main() {
  MYSQL* conn = mysql_init(NULL);
  if (conn == NULL) {
    fprintf(stderr, "Error initializing MySQL connection\n");
    return EXIT_FAILURE;
  }

  // ...
}

41. XML Parsing

#include <rapidxml.hpp>

int main() {
  rapidxml::xml_document<> doc;
  doc.parse<0>(xml_string);

  // ...
}

42. JSON Parsing

#include <jsoncpp/json.h>

int main() {
  Json::Value root;
  std::ifstream ifs("json_file.json");
  ifs >> root;

  // ...
}

43. Web Scraping

#include <curl/curl.h>
#include <iostream>

int main() {
  CURL* curl = curl_easy_init();
  curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
  curl_easy_perform(curl);

  // ...
}

44. Data Visualization

#include <matplotlibcpp.h>

int main() {
  std::vector<double> x = {1, 2, 3, 4, 5};
  std::vector<double> y = {2, 4, 6, 8, 10};

  matplotlibcpp::plot(x, y);
  matplotlibcpp::show();
}

45. Machine Learning

#include <mlpack/core.hpp>

int main() {
  arma::mat data = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
  arma::rowvec labels = {0, 1, 0};

  // ...
}

46. Image Processing

#include <opencv2/opencv.hpp>

int main() {
  cv::Mat image = cv::imread("image.jpg");
  cv::imshow("Image", image);
  cv::waitKey(0);

  // ...
}

47. Signal Processing

#include <fftw3.h>

int main() {
  double data[] = {1, 2, 3, 4, 5, 6, 7, 8};
  fftw_complex out[8];

  // ...
}

48. Natural Language Processing

#include <nltk/corpus.hh>
#include <nltk/tokenizer.hh>

int main() {
  nltk::corpus::load("words.txt");
  nltk::PunktSentenceTokenizer tokenizer;

  std::string text = "This is a sentence. This is another sentence.";
  std::vector<std::string> sentences = tokenizer.sentences(text);

  // ...
}

49. Computer Graphics

#include <GLFW/glfw3.h>

int main() {
  glfwInit();
  GLFWwindow* window = glfwCreateWindow(640, 480, "Window", NULL, NULL);

  // ...
}

50. Game Development

#include <SDL.h>

int main() {
  SDL_Init(SDL_INIT_EVERYTHING);
  SDL_Window* window = SDL_CreateWindow("Window", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480,
                                         SDL_WINDOW_OPENGL);

  // ...
}