#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

int getaddrinfo(
  const char* node,               // Имя узла (IP или DNS)
  const char* service,            // Порт или сервис
  const struct addrinfo* hints,   // Дополнительные опции
  struct addrinfo** res           // Результат (список адресов)
);

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int tcp_connect(const char* hostname, const char* port) {
  struct addrinfo hints, *result, *rp;
  int sfd, errcode;

  memset(&hints, 0, sizeof(hints));
  hints.ai_family = AF_UNSPEC;    // Разрешить оба семейства (IPv4 и IPv6)
  hints.ai_socktype = SOCK_STREAM;// Тип сокета TCP
  hints.ai_protocol = IPPROTO_TCP;// Протокол TCP

  // Получаем список возможных адресов
  errcode = getaddrinfo(hostname, port, &hints, &result);
  if (errcode != 0) {
    fprintf(stderr, "Ошибка getaddrinfo(): %s\n", gai_strerror(errcode));
    return -1;
  }

  // Пробуем каждый полученный адрес
  for (rp = result; rp != NULL; rp = rp->ai_next) {
    // Создаем сокет
    sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
    if (sfd == -1) continue; // Перейти к следующему адресу

    // Подключаемся к выбранному адресу
    if (connect(sfd, rp->ai_addr, rp->ai_addrlen) != -1) break; // Успешное подключение!

    close(sfd); // Неудача с данным адресом, закрываем сокет
  }

  freeaddrinfo(result); // Освобождаем память

  if (rp == NULL) { // Ни один адрес не подошел
    fprintf(stderr, "Не удалось подключиться ни к одному адресу\n");
    return -1;
  }

  return sfd; // Вернуть дескриптор сокета
}

#include <boost/asio.hpp>

int main() {
  try {
    boost::asio::ip::tcp::socket socket(io_service);
    boost::asio::connect(socket, endpoint_iterator);
    boost::asio::write(socket, boost::asio::buffer("GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n"));
    boost::asio::read_until(socket, response_buffer, "\r\n");
  } catch (std::exception& e) {
    std::cerr << "Exception: " << e.what() << "\n";
  }
}

#include <Poco/Net/HTTPServer.h>

void requestHandler(const HTTPRequest&, HTTPResponse&) {...}

int main() {
  HTTPServer srv(new RequestHandlerFactory(), 8080);
  srv.start();
}

QTcpSocket socket;
connect(&socket, SIGNAL(connected()), SLOT(onConnected()));
socket.connectToHost("example.com", 80);

#include <iostream>

int main() {
  while(std::cin.peek() == ' ') { // пока впереди пробельный символ
    std::cin.ignore(); // пропускаем его
  }

  // теперь считываем первый непробельный символ
  char firstNonSpace;
  std::cin.get(firstNonSpace);

  std::cout << "Первый непробельный символ: " << firstNonSpace << std::endl;

  return 0;
}

#include <fstream>
#include <iostream>

int main() {
  std::ifstream file("example.txt");

  if (!file.is_open()) {
    std::cerr << "Ошибка открытия файла." << std::endl;
    return 1;
  }

  while(file.peek() != EOF) { // пока не конец файла
    char current_char;
    file.get(current_char); // берем очередной символ
    std::cout << current_char;
  }

  file.close();
  return 0;
}

#include <cstddef> // std::ptrdiff_t

int arr[] = {1, 2, 3};
auto diff = &arr[2] - &arr[0]; // Результат имеет тип ptrdiff_t

#include <cstddef> // std::size_t

char str[] = "Привет";
size_t len = strlen(str); // Результат имеет тип size_t

#include <cinttypes> // std::intptr_t

void* ptr = malloc(10);
intptr_t ip = reinterpret_cast<intptr_t>(ptr); // Преобразование указателя в целое число
free(reinterpret_cast<void*>(ip)); // Обратное преобразование назад в указатель

#include <cinttypes> // std::uintptr_t

void* data = new char[10];
uintptr_t addr = reinterpret_cast<uintptr_t>(data); // Сохранение адреса в беззнаковом целом числе
delete [] reinterpret_cast<char*>(addr); // Обратное преобразование

#include <iostream>
#include <string>
#include <regex>

bool isValidIPv4(const std::string& ip) {
  // Регулярное выражение для валидной строки IPv4 адреса:
  std::regex ipv4_regex(R"(^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$)");
    
  return std::regex_match(ip, ipv4_regex);
}

int main() {
  std::string test_ip = "192.168.1.1";
  if(isValidIPv4(test_ip))
    std::cout << "IP-адрес корректен." << std::endl;
  else
    std::cout << "IP-адрес некорректен." << std::endl;

  return 0;
}

int main(int argc, char** argv):
// и далеее
int main(int argc, char** argv) {
  //Тело функции main
  return 0;
}

#include <stdio.h>

int main(int argc, char** argv) {
  int returnValue;
  if (argc == 2) {
    sscanf(argv[1], "%d", &returnValue);
  }
  if (returnValue == 0) {
    return returnValue;
  }
  --returnValue;
  argv[1][0] = '0' + returnValue;
  printf("argv[1] = %s, returnValue = %d\n", argv[1], returnValue);
  return main(argc, argv);
}

compukter@barracol:~/Programs/C/edu_task$ ./a.out 9
argv[1] = 8, returnValue = 8
argv[1] = 7, returnValue = 7
argv[1] = 6, returnValue = 6
argv[1] = 5, returnValue = 5
argv[1] = 4, returnValue = 4
argv[1] = 3, returnValue = 3
argv[1] = 2, returnValue = 2
argv[1] = 1, returnValue = 1
argv[1] = 0, returnValue = 0

sudo apt-get install libcurl4-openssl-dev

// Подключение библиотеки:
#include <curl/curl.h>
   
/* Инициализация и выполнение простого GET-запроса*/
CURL* curl = curl_easy_init();
if (curl) {
  curl_easy_setopt(curl, CURLOPT_URL, "https://example.com");
  res = curl_easy_perform(curl); // Выполняем запрос
  curl_easy_cleanup(curl);       // Освобождаем ресурсы
}

#include <openssl/ssl.h>

void init_openssl() {
  SSL_library_init();
}

#include <openssl/opensslv.h> /* OPENSSL_VERSION_NUMBER */
#include <openssl/ssl.h>

#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
#define USE_OPENSSL_INIT_API
#endif

#ifdef USE_OPENSSL_INIT_API
void init_openssl() {
  OPENSSL_init_ssl(0, NULL);
}
#else
void init_openssl() {
  SSL_library_init();
}
#endif

#include <openssl/err.h>

void load_errors() {
  SSL_load_error_strings();
}

#include <openssl/err.h>

void load_errors() {
  ERR_load_crypto_strings();
}

#include <openssl/opensslv.h> /* OPENSSL_VERSION_NUMBER */
#include <openssl/ssl.h>

#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
#define USE_OPENSSL_INIT_API
#endif

#ifdef USE_OPENSSL_INIT_API
void load_errors() {
  OPENSSL_init_ssl(0, NULL);
}
#else
void load_errors() {
  SSL_load_error_strings();
}
#endif

#include <curl/curl.h>

int main(void) {
  CURL *curl_handle = curl_easy_init();
  if (!curl_handle) {
    fprintf(stderr, "Ошибка инициализации cURL.\n");
    return 1;
  }

  // Далее можно настроить опции, такие как URL, HTTP-метод и др.
  curl_easy_setopt(curl_handle, CURLOPT_URL, "http://example.com");

  // Отправляем запрос
  CURLcode result = curl_easy_perform(curl_handle);

  // Очищаем ресурсы
  curl_easy_cleanup(curl_handle);

  return 0;
}

// +build linux darwin

package main

import (
  "fmt"
)

func main() {
  fmt.Println("Hello from Linux or Darwin!")
}

main_linux.go
main_windows_amd64.go
file_darwin_arm64.go

mylib_windows.go

// +build windows

package mylib

func HelloWorld() string {
  return "Привет мир! (Windows)"
}

mylib_linux.go

// +build linux

package mylib

func HelloWorld() string {
  return "Привет мир! (Linux)"
}

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

SELECT * FROM users WHERE age > 18;

parent(john, mary).
grandparent(X,Y):- parent(X,Z), parent(Z,Y).

package main

import (
  "fmt"
)

func describe(x interface{}) {
  switch x.(type) { // используем type switch
    case int:
      fmt.Printf("целое число %v\n", x)
    case string:
      fmt.Printf("строка длиной %d символов\n", len(x.(string)))
    default:
      fmt.Printf("неопределённый тип\n")
  }
}

func main() {
  describe(42)
  describe("hello world")
  describe(true)
}

целое число 42
строка длиной 11 символов
неопределённый тип

package main

import (
  "fmt"
)

// TypeSum представляет собой объединение типов int64, float64 и complex128
type TypeSum struct {
  Kind uint8     // определяет тип хранимого значения
  Value any      // общее хранилище для различных типов
}

const (
  Int64 Kind = iota
  Float64
  Complex128
)

// NewInt создает новый TypeSum с целым числом
func NewInt(i int64) TypeSum {
  return TypeSum{
    Kind: Int64,
    Value: i,
  }
}

// NewFloat создает новый TypeSum с вещественным числом
func NewFloat(f float64) TypeSum {
  return TypeSum{
    Kind: Float64,
    Value: f,
  }
}

// NewComplex создает новый TypeSum с комплексным числом
func NewComplex(c complex128) TypeSum {
  return TypeSum{
    Kind: Complex128,
    Value: c,
  }
}

// Add добавляет целое число к существующему значению
func (ts *TypeSum) Add(i int64) {
  switch ts.Kind {
  case Int64:
    ts.Value = ts.Value.(int64) + i
  case Float64:
    ts.Value = ts.Value.(float64) + float64(i)
  case Complex128:
    ts.Value = ts.Value.(complex128) + complex(float64(i), 0)
  default:
    panic(fmt.Sprintf("Неподдерживаемый тип %v", ts.Kind))
  }
}

// String возвращает строковое представление текущего значения
func (ts TypeSum) String() string {
  switch ts.Kind {
  case Int64:
    return fmt.Sprint(ts.Value.(int64))
  case Float64:
    return fmt.Sprint(ts.Value.(float64))
  case Complex128:
    return fmt.Sprint(ts.Value.(complex128))
  default:
    return "<unknown>"
  }
}

func main() {
  var sum TypeSum

  sum = NewInt(10)
  sum.Add(5)
  fmt.Printf("Сумма целого числа: %s\n", sum.String()) // Output: Сумма целого числа: 15

  sum = NewFloat(3.14)
  sum.Add(-1)
  fmt.Printf("Сумма вещественного числа: %s\n", sum.String()) // Output: Сумма вещественного числа: 2.14

  sum = NewComplex(complex(1, 2))
  sum.Add(3)
  fmt.Printf("Сумма комплексного числа: %s\n", sum.String()) // Output: Сумма комплексного числа: (4+2i)
}

type Reader interface {
  Read(p []byte) (n int, err error)
}

type MyType struct{}

func (m *MyType) Read(p []byte) (n int, err error) {
  // Реализация чтения данных здесь...
  return len(p), nil
}

var r Reader = &MyType{}
// Это сработает, поскольку MyType реализует интерфейс Reader

// Ошибка компиляции! Наш тип не реализует другой интерфейс Writer
var w io.Writer = &MyType{} 

def walk_and_talk(animal):
  animal.walk()
  animal.talk()

class Dog:
  def walk(self):
    print("Собака идет")
    
  def talk(self):
    print("Гав!")

class Cat:
  def walk(self):
    print("Кошка идёт")
    
  def talk(self):
    print("Мяу!")

dog = Dog()
cat = Cat()
walk_and_talk(dog) # Собака идет, Гав!
walk_and_talk(cat) # Кошка идёт, Мяу!

package main

import (
    "fmt"
)

type Animal interface {
  Walk()
  Talk()
}

type Dog struct {}

func (d *Dog) Walk() {
  fmt.Println("Собака идет.")
}

func (d *Dog) Talk() {
  fmt.Println("Гав!")
}

type Cat struct {}

func (c *Cat) Walk() {
  fmt.Println("Кошка идёт.")
}

func (c *Cat) Talk() {
  fmt.Println("Мяу!")
}

func walkAndTalk(a Animal) {
  a.Walk()
  a.Talk()
}

func main() {
  d := new(Dog)
  c := new(Cat)
  walkAndTalk(d) // Собака идет., Гав!
  walkAndTalk(c) // Кошка идёт., Мяу!
}

numbers := []int{1, 2, 3}
numbers = append(numbers, 4)
fmt.Println(numbers) // Output: [1 2 3 4]

letters := []string{"a", "b"}
moreLetters := []string{"c", "d"}
letters = append(letters, moreLetters...)
fmt.Println(letters) // Output: ["a" "b" "c" "d"]

arr := [...]int{1, 2, 3}
sl := arr[:]
newSl := append(sl, 4, 5)
fmt.Println(newSl) // Output: [1 2 3 4 5]

// Вернуть назад в массив нельзя без потери хвостовых элементов
finalArr := newSl[:len(arr)]
fmt.Println(finalArr) // Output: [1 2 3]

preallocatedSlice := make([]int, 0, expectedSize)
for i := 0; i < expectedSize; i++ {
  preallocatedSlice = append(preallocatedSlice, i)
}

package main

import (
  "fmt"
)

// SparseArray хранит разреженный массив без использования map
type SparseArray struct {
  data []int     // фактические данные
  indexes []int  // индексы хранимых элементов
  size   int     // размер полного массива
}

// NewSparseArray создает новый разреженный массив заданного размера
func NewSparseArray(size int) *SparseArray {
  return &SparseArray{
    data: make([]int, 0),
    indexes: make([]int, 0),
    size: size,
  }
}

// Get возвращает элемент по указанному индексу
func (sa *SparseArray) Get(index int) int {
  for i, idx := range sa.indexes {
    if index == idx {
      return sa.data[i]
    }
  }
  return 0 // Возвращаем ноль, если элемента нет
}

// Set устанавливает значение по данному индексу
func (sa *SparseArray) Set(index int, value int) bool {
  if index >= sa.size || index < 0 {
    return false
  }

  // Проверяем наличие элемента
  found := false
  for i, idx := range sa.indexes {
    if index == idx {
      sa.data[i] = value
      found = true
      break
    }
  }

  // Добавляем новый элемент, если не найден
  if !found && value != 0 {
    sa.indexes = append(sa.indexes, index)
    sa.data = append(sa.data, value)
  }

  return true
}

// Remove удаляет элемент по индексу
func (sa *SparseArray) Remove(index int) bool {
  for i, idx := range sa.indexes {
    if index == idx {
      copy(sa.indexes[i:], sa.indexes[i+1:])
      sa.indexes[len(sa.indexes)-1] = 0
      sa.indexes = sa.indexes[:len(sa.indexes)-1]

      copy(sa.data[i:], sa.data[i+1:])
      sa.data[len(sa.data)-1] = 0
      sa.data = sa.data[:len(sa.data)-1]
      return true
    }
  }
  return false
}

func main() {
  sparseArr := NewSparseArray(100)
  sparseArr.Set(10, 100)
  sparseArr.Set(50, 200)

  fmt.Println(sparseArr.Get(10)) // Выведет 100
  fmt.Println(sparseArr.Get(50)) // Выведет 200
  fmt.Println(sparseArr.Get(70)) // Выведет 0 (такого элемента нет)

  sparseArr.Remove(10)
  fmt.Println(sparseArr.Get(10)) // Теперь выведет 0
}

var s []string // нулевое значение: []
var i []int   // нулевое значение: []

// создаем пустой срез длины 0 и емкости 0
s := make([]string, 0)
i := make([]int, 0)    // аналогично

s := []string{"apple", "banana"}
fmt.Println(s[0]) // выведет "apple"

s[0] = "orange"
fmt.Println(s) // теперь ["orange", "banana"]

a := []int{1, 2, 3, 4, 5}
b := a[:3]      // b = [1, 2, 3]
c := a[2:]      // c = [3, 4, 5]
d := a[1:4]     // d = [2, 3, 4]

x := []int{1, 2, 3}
y := append(x, 4)
z := append(y, 5, 6)
fmt.Println(z) // выводит [1, 2, 3, 4, 5, 6]

src := []byte{'h', 'e', 'l', 'l', 'o'}
dst := make([]byte, len(src))
n := copy(dst, src)
fmt.Printf("Copied %d bytes\n", n) // Copied 5 bytes

func remove(slice []int, index int) []int {
  return append(slice[:index], slice[index+1:]...)
}

arr := []int{1, 2, 3, 4, 5}
arr = remove(arr, 2) // arr становится [1, 2, 4, 5]