Discover Community Snippets

x = [1,2,3]     # inizializzo una lista e la assegno a x
y = x           # x e y puntano alla stessa lista ora
y.append(4)     # aggiungo un elemento
print(x)        # anche se ho modificato y anche x aggiungerà 4

# given an integer find how many zero's repeating
# his factorial has at the end of the number
def trailingZeroes(n):
    if n < 5 : 
        return 0

    while n >= 5:
        n //= 5
        count += n
    
    return count
    
# 5! = 120 => expected output: 1
print(trailingZeroes(5))

# factorial trailing zeros
def factorialZeroTrail(n) :
    if not n or n == 0 : 
        return 0

    """
    if n < 900 use this
    def factorial(n) :
        if n <= 1 : 
            return 1 
        else :
            return n * factorial(n - 1)
    
    for bigger numbers use this other:
    """
    def factorial(n) :
        result = 1
        for i in range(2, n+1) :
            result *= i
        return result

    fact = factorial(n)
    
    count = 0

    while fact % 10 == 0 :
        count += 1
        fact = fact // 10

    return count

n = 8425

print(factorialZeroTrail(abs(n)))

"""
Read the integer by skipping leading zeros 
until a non-digit character is encountered or 
the end of the string is reached. 
If no digits were read, then the result is 0.
"""

s = "3-az" # input

def toInt(s) :
    s = s.strip()
    num = ""
    for char in s :
        if char.isdigit() :
            num += char
        elif char == "-" and num == "" :
            num += char
        else:
            break;

    if not num or num == "-" :
        return 0

    return int(num)

# expected result: 3
print(toInt(s))

target = 9
nums = [2,7,11,15]

# find indexes of the numbers that
# summed up give the target number
def twoSum(nums, t) :
    for i, n in enumerate(nums) :
        for j, n in enumerate(nums) :
            if i != j and nums[i] + nums[j] == t :
                return i, j
    

# expected output (0, 1)
print(twoSum(nums, target))

# reversed integer
integer = 123 

# [::-1] to reverse a string
def reverseInt(num) :
    sign = -1 if num < 0 else 1
    res = int(str(abs(num))[::-1]) * sign
    return res
    
reversedInt = reverseInt(integer)

# expected output: 321
print(reversedInt)

using System;
using System.Collections.Generic;

class Program {
    static void Main(string[] Args)
    {
        // median of 2 arrays
        int[] a = { 0, 1, 3 };
        int[] b = { 2, 4, 6, 5 };
        
        // expected output: 3
        Console.WriteLine(FindMedianSortedArrays(a, b));
    }

    static double FindMedianSortedArrays(int[] a, int[] b) {
        // merge arrays
        int[] merged = mergeSortedArrays(a, b);
        double median = 0;
        int len = merged.Length;

        if (len % 2 != 0)
            return merged[len/2];
        else  // trovo gli indici a cavallo e li sommo e li divido per 2    
            median = (merged[len / 2] + merged[len / 2 + 1]) / 2.0;

        return median;
    }

    static int[] mergeSortedArrays(int[] a, int[] b) {
        List<int> list = new List<int>();

        for (int i = 0; i < a.Length; i++)
            list.Add(a[i]);

        for (int i = 0; i < b.Length; i++)
            list.Add(b[i]);

        list.Sort();

        return list.ToArray();
    }
}

-- data una tabella capire quali numeri sono 
-- consecutivi 3 volte nella tabella
create table logs ( id INTEGER, num INTEGER );

insert into logs 
values (1, 1), (2, 1), (3, 1), (4, 2), (5, 2), (6, 2), (7, 1);

select * from logs;

select distinct l1.num as repeating 
from logs as l1
join logs as l2 on (l1.id = l2.id + 1 AND l1.num = l2.num)
join logs as l3 on (l1.id = l3.id + 2 AND l1.num = l3.num)

using System;
using System.Linq;

class Program {
    static void Main() {
        // given a string "s" and an array of strings "arr"
        // find how many subsequences of "s" are in "arr"
        
        string s = "abcdef";
        string[] arr = {"abf", "ba", "bcd", "f", "cb"};

        // output expected: 3
        Console.WriteLine(findHowManySubSeq(s, arr));
    }

    static short findHowManySubSeq(string s, string[] arr){
        short count = 0;
        
        for(int i = 0; i < arr.Length; i++) {
            bool isSubseq = false;
            string remaining = s;

            for(int j = 0; j < arr[i].Length; j++) {
                int index = remaining.IndexOf(arr[i][j]);
                if(index != -1) {
                    remaining = remaining.Substring(index+1);
                    isSubseq = true;
                } else {
                    isSubseq = false;
                }
            }
            if(isSubseq) count++;
        }
        return count;
    }
}

interface User {
    customerId: number
    name: string
    email: string
    isPro: boolean
}

const users: User[] = [
    {
        customerId: 54987,
        name: "xhoeli",
        email: "xhoeli@hotmail.com",
        isPro: false
    },
    {
        customerId: 52327,
        name: "xhoelino",
        email: "xhoelino@hotmail.com",
        isPro: true
    }
]

// a nice table for debugging
console.table(users)

(async () => {
  // dummy data
  const BASE_URL = "https://jsonplaceholder.typicode.com";
  const API_KEY  = "demo_key_123";

  // helper 
  async function apiFetch(endpoint, options = {}, retries = 3) {
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), 5000);

    for (let attempt = 1; attempt <= retries; attempt++) {
      try {
        const res = await fetch(`${BASE_URL}${endpoint}`, {
          ...options,
          signal: controller.signal,
          headers: {
            "Content-Type": "application/json",
            "Authorization": `Bearer ${API_KEY}`,
            "Accept": "application/json",
            ...options.headers,
          },
        });

        clearTimeout(timeout);

        if (!res.ok) {
          const error = await res.json().catch(() => ({ message: res.statusText }));
          throw new Error(`HTTP ${res.status}: ${error.message}`);
        }

        return await res.json();

      } catch (err) {
        const isLast = attempt === retries;
        if (err.name === "AbortError") throw new Error("Request timed out");
        if (isLast) throw err;
        console.log(`!Attempt ${attempt} failed, retrying in ${attempt}s...`);
        await new Promise(r => setTimeout(r, 1000 * attempt));
      }
    }
  }

  // req's
  try {
    // 1. GET list
    console.log("── GET users");
    const users = await apiFetch("/users?_limit=3");
    users.forEach(u => console.log(`  ${u.id}. ${u.name} <${u.email}>`));

    // 2. GET single
    console.log("\n── GET single");
    const post = await apiFetch("/posts/1");
    console.log(`  Title : ${post.title}`);
    console.log(`  Body  : ${post.body.slice(0, 60)}...`);

    // 3. POST create
    console.log("\n── POST create");
    const created = await apiFetch("/posts", {
      method: "POST",
      body: JSON.stringify({ title: "My Post", body: "Hello World", userId: 1 }),
    });
    console.log(`  Created ID : ${created.id}`);
    console.log(`  Title      : ${created.title}`);

    // 4. PUT update
    console.log("\n── PUT update");
    const updated = await apiFetch("/posts/1", {
      method: "PUT",
      body: JSON.stringify({ id: 1, title: "Updated Title", body: "New body", userId: 1 }),
    });
    console.log(`  New title : ${updated.title}`);

    // 5. DELETE
    console.log("\n── DELETE post");
    await apiFetch("/posts/1", { method: "DELETE" });
    console.log(`  Deleted successfully`);

    // 6. Parallel fetch
    console.log("\n── Parallel fetch");
    const [comments, todos] = await Promise.all([
      apiFetch("/comments?_limit=2"),
      apiFetch("/todos?_limit=2"),
    ]);
    console.log(`  Comments : ${comments.map(c => c.email).join(", ")}`);
    console.log(`  Todos    : ${todos.map(t => `[${t.completed ? "x" : " "}] ${t.title.slice(0, 30)}`).join("\n             ")}`);

  } catch (err) {
    console.error("✖ Error:", err.message);
  }
})();

(async () => {
  try {
    const res = await fetch("https://api.github.com/users/torvalds");
    
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    
    const data = await res.json();
    
    console.log(`Name: ${data.name}`);
    console.log(`Repos: ${data.public_repos}`);
    console.log(`Followers: ${data.followers}`);
  } catch (err) {
    console.error("Error:", err.message);
  }
})();

async function fetchWithPostAndJson () {
    try{
        const res = await fetch("https://jsonplaceholder.typicode.com/posts", {
          method: "POST",
          headers: { "Content-Type" : "application/json" },
          body: JSON.stringify({ title: "Hello", body: "World", userId: 1 })
        });

        const data = await res.json();

        // if(!data) return;

        console.log("\n")
        console.log(JSON.stringify(data, null, 2));
    }
    catch (err) {
        console.log(err.message);
    }
}

fetchWithPostAndJson();

public class Main {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        
        System.out.print("Original numbers: ");
        printArray(numbers);
        
        int[] squares = new int[numbers.length];
        for (int i = 0; i < numbers.length; i++) {
            squares[i] = numbers[i] * numbers[i];
        }
        System.out.print("Squared numbers: ");
        printArray(squares);
        
        System.out.print("Even numbers: ");
        for (int n : numbers) {
            if (n % 2 == 0) System.out.print(n + " ");
        }
        System.out.println();
        
        int sum = 0;
        for (int n : numbers) sum += n;
        System.out.println("Sum of numbers: " + sum);
    }
    
    private static void printArray(int[] arr) {
        for (int n : arr) System.out.print(n + " ");
        System.out.println();
    }
}

CREATE TABLE scuola (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nome VARCHAR(100),
    indirizzo VARCHAR(150)
);

CREATE TABLE studente (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nome VARCHAR(100),
    cognome VARCHAR(100),
    scuola_id INT,
    FOREIGN KEY (scuola_id) REFERENCES scuola(id)
);

CREATE TABLE voto (
    id INT AUTO_INCREMENT PRIMARY KEY,
    voto INT,
    materia VARCHAR(100),
    studente_id INT,
    FOREIGN KEY (studente_id) REFERENCES studente(id)
);

INSERT INTO studente (nome, cognome,scuola_id) VALUES ("Filippo", "Autiero",1);
INSERT INTO scuola (nome,indirizzo) VALUES ("marconi","via Leonardo");
INSERT INTO voto (voto,materia,studente_id) VALUES (10,"informatica",1)

interface User {
    id: number
    name: string
    email: string
    telephone? : number
    prefix?: string
}

const user1 : User = {
    id:1,
    name: "xhoeli",
    email: "xhoeli@hotmail.com",
}

const getRandomTelephoneNumber = () => {
    const rnd = Math.floor(Math.random() * 380_000_0000);
    return rnd;
}

const getRandomPrefix = () => {
    const rnd: string = "+" + Math.floor(Math.random() * 20) + 1;
    return rnd;
}

const user2: User = {
    id:1,
    name: "joel",
    email: "joel@gmail.com",
    telephone: getRandomTelephoneNumber(), // esempio randomico
    prefix: getRandomPrefix()
}

// destrutturo l'oggetto user2 estraendo prefix e telephone
const { prefix, telephone } = user2;

// stampo numero e prefisso
console.log(prefix + " " + telephone);

// Type-safe Route Definitions

const routes = {
    home: "/",
    about: "/about",
    contact: "/contact",
} as const; // as const make constats all the layers of the object

const routesFreeze = Object.freeze({
    home: "/",
    about: "/about",
    contact: "/contact",
}); // Object.freeze() make constat only the first layer and not childerns

type RoutesKeys = (keyof typeof routes);
type Route = (typeof routes) [RoutesKeys];

const route : Route = "/"; // get the param from html

const handleRedirect = (param: Route) => {
    // ...
}

handleRedirect(route); // "/" | "/about" | "/contact"

console.log(routes);

function binomialCoefficient(n, k) {
    return factorial(n) / (factorial(k) * factorial(n-k));
}

function factorial(n) {
    if(n < 0) n = -n;
    if(n <= 1 && n >= 0) {return 1;}
    return n * factorial(n-1);
}

let x = 90;
if(x < 0) x = -x;

let n = 6;
let k = 3;

console.log("fattoriale di: "+ x + " = " + factorial(x));
console.log("coefficiente binomiale di: " + n + " su " + k + " = " + binomialCoefficient(n,k));

/*appunti sui puntatori*/
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int array[4]; // dichiaro array
    
    int *ptr = array; // inizializzo il puntatore ad array[0]

    int* arr1 = ( int* ) malloc(sizeof(array)); // creo un puntatore alla zona in memoria allocata alla grandezza di array

	printf("%p\n\r", ptr);

    *ptr = 10;
    
    ptr++; // aumento l'indice dell'array tramite puntatore 

    *ptr += 1; // assegno all'interno della cella a cui punta ptr 1

    printf("%i, %i\r\n", array[0], array[1]);

    printf("%p\r\n", ptr);
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int main() {
    printf("Inizio\n");
    
    pid_t pid1, pid2;
    int result1, result2, result3, result4, res_child, res_final;
    int status1, status2;
    
    // numeri variabili
    int a = 9, b = 4, c = 8, d = 3, e = 5;
    
    result1 = a - b; // padre 9 - 4 = 5
    printf("%d - %d = %d\n", a, b, result1);
    
    // figlio 8 + 3 = 11
    if ((pid1 = fork()) == 0) {
        res_child = c + d;
        printf("%d + %d = %d\n", c, d, res_child);
        exit(res_child);
    } else { // padre (9-4)*(8+3) = 55
        wait(&status1);  // Usare `wait()` invece di `waitpid()`
        result2 = WEXITSTATUS(status1) * result1; // (9-4)*(8+3)
        printf("%d * %d = %d\n", WEXITSTATUS(status1), result1, result2);
    }
    
    result3 = c - d; // 8 - 3 = 5
    
    // secondo figlio 5 + 8 = 13
    if ((pid2 = fork()) == 0) {
        res_child = e + c;
        printf("%d + %d = %d\n", e, c, res_child);
        exit(res_child);
    } else { // padre 13 * 5 = 65
        wait(&status2);  // Usare `wait()` invece di `waitpid()`
        result4 = WEXITSTATUS(status2) * result3;
        printf("%d * %d = %d\n", WEXITSTATUS(status2), result3, result4);
    }
    
    res_final = result2 - result4; // 55 - 65 = -10
    printf("%d - %d = %d\n", result2, result4, res_final);
    printf("((%d-%d)*(%d+%d))-((%d-%d)*(%d+%d)) = %d\n", a, b, c, d, e, c, result2, result4, res_final);
    
    return 0;
}

/*appunti sui puntatori*/
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int array[4]; //4 x 4 byte
	printf("%lu \r\n", sizeof(array)); //%lu long integer
	                                  //(senza val < 0)

    /*------------------------------------------------------------------------*/

	//preallocazione di memoria da usare in elaborazione
	int *p1 = malloc(sizeof(*p1)); //inserisco quanta memoria sto allocando (con malloc) per p1
	int *p2 = calloc(1, sizeof(*p2)); //num celle e dimensione ogni cella e uso p2 come array
	*p1 = 10;
	*p2 = 10;
	printf("%d %d", *p1, *p2);
	
	/*------------------------------------------------------------------------*/

	int *ptrInt = (int*)array; //creo un puntatore all'array
	int *ptr = (int*)calloc(4, sizeof(*ptrInt)); //alloco la memoria
    
    printf("%lu", sizeof(*ptrInt));
    printf("%lu", sizeof(array));

    /*------------------------------------------------------------------------*/
    
    *ptrInt = array[0]; //assegnazione in memoria ad un array di interi
    ptrInt[1] = 4;  //ptrInt++ e inserisco il valore 4 
    ptrInt[2] = 6; //ptrInt++ e inserisco il valore 6
                  //(accedo alla cella dell'indirizzo)
    
    /*------------------------------------------------------------------------*/
    
    int *arr1, *arr2;
    int grandezza = 5; //da prendere in input per elaborazione
    int n = 1;
    
    arr1 = (int*)malloc(n * sizeof(int));
    if(arr1 = NULL)
    {
        //allocazione fallita
    }
    
    //popolamento
    for(int i = 0; i < grandezza; i++)
        arr1[i] = i;
    
    free(arr1); //deallocazione della memoria con parametro puntatore
    
	return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    
    std::cout << "Original numbers: ";
    for (int n : numbers) std::cout << n << " ";
    std::cout << std::endl;
    
    std::vector<int> squares;
    std::transform(numbers.begin(), numbers.end(), 
                std::back_inserter(squares),
                [](int n) { return n * n; });
    
    std::cout << "Squared numbers: ";
    for (int n : squares) std::cout << n << " ";
    std::cout << std::endl;
    
    std::cout << "Even numbers: ";
    for (int n : numbers) {
        if (n % 2 == 0) std::cout << n << " ";
    }
    std::cout << std::endl;
    
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);
    std::cout << "Sum of numbers: " << sum << std::endl;
    
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
using namespace std;

vector<int> quicksort(vector<int> arr){
    if(arr.size() <= 1){
        return arr;
    }

    int pivot = arr[0];
    vector<int> left = {};
    vector<int> right = {};

    for(int i = 1; i < arr.size(); i++){
        if(arr[i] <= pivot){
            left.push_back(arr[i]);
        }else{
            right.push_back(arr[i]);
        }
    }

    vector<int> sortedLeft = quicksort(left);
    vector<int> sortedRight = quicksort(right);

    sortedLeft.push_back(pivot);
    sortedLeft.insert(sortedLeft.end(), sortedRight.begin(), sortedRight.end());
    return sortedLeft;
}

int main() {
    vector<int> ls = {2, 1, -9, 7, 3, 0, -1, 2};
    vector<int> sorted = quicksort(ls);
    for(auto x : sorted){
        cout << x <<endl;
    }
    return 0;
}

using System;
using System.Linq.Expressions;

public class Wordle
{
    public void Run()
    {
        string[] words = File.ReadAllLines("words.txt");
        Random rand = new Random();
        String wordToGuess = words[rand.Next(words.Length)].ToUpper();
        int maxAttempt = 5;
        // Console.WriteLine(words.Length);
        System.Console.WriteLine("Guess the word");
        Console.WriteLine($"the word has {wordToGuess.Length} letters");
        String globalHint = new string('_', wordToGuess.Length);
        String hint = ShowHint(wordToGuess, globalHint);
        Console.WriteLine(hint);
        globalHint = hint;
        Console.WriteLine("Goodluck! You can ask for help with ?h");
        int addGuess = 1;
        while(maxAttempt > 0)
        {
            String userGuess = Console.ReadLine()?.ToUpper()?.Trim() ?? "";
            if(userGuess == "?H")
            {
                if(maxAttempt < 2 || addGuess >= wordToGuess.Length)
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    System.Console.WriteLine("You dont have enough attempts for help");
                    Console.ResetColor();
                    continue;
                }
                else
                {
                    String hint2 = ShowHint(wordToGuess, globalHint, addGuess);
                    Console.WriteLine(hint2);
                    globalHint = hint2;
                    addGuess++;
                    maxAttempt--;
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine($"You now have {maxAttempt} left");
                    Console.ResetColor();
                    continue;
                }
                
            }
            bool[] res = CheckWord(wordToGuess, userGuess);
            String toShow = "";
            for(int i = 0; i < wordToGuess.Length; i++)
            {
                if (res[i])
                {
                    toShow += userGuess[i];
                }
                else
                {
                    toShow += "_";
                }
            }
            if(toShow == wordToGuess)
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("Congratulations!! you got it");
                Console.WriteLine(wordToGuess);
                Console.ResetColor();
                break;
            }
            else
            {
                maxAttempt--;
                Console.WriteLine(toShow);
                if(maxAttempt <= 0)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("Game over! You have exhausted your attempts");
                    Console.ResetColor();
                    break;
                }
                Console.WriteLine($"you have {maxAttempt} left");
            }
        }
    }

    static bool[] CheckWord(string wordToGuess, string userGuess)
    {
        int len = wordToGuess.Length;
        bool[] res = new bool[len];

        int minLen = Math.Min(wordToGuess.Length, userGuess.Length);

        for (int i = 0; i < minLen; i++)
        {
            res[i] = wordToGuess[i] == userGuess[i];
        }

        return res;
    }

    static String ShowHint(string wordToGuess, string prevWord, int add = 2)
    {
        char[] prevWordArr = prevWord.ToCharArray();
        int length = wordToGuess.Length;
        char[] hint = new char[length];
        hint = prevWordArr;

        Random rnd = new Random();
        HashSet<int> revealedPositions = new HashSet<int>();
        while (revealedPositions.Count < add)
        {
            int pos = rnd.Next(length);
            if(prevWordArr[pos] != '_' && prevWordArr.Length == 0)
            {
                continue;
            }
            revealedPositions.Add(pos);
        }

        foreach (int pos in revealedPositions)
        {
            hint[pos] = wordToGuess[pos];
        }

        return new string(hint);
    }
}

/*
QUESTO CODICE NON PUO' ESSERE ESEGUITE IN FLUXA PERCHE'
LA CONSOLE NON PERMETTE DI INSERIRE INPUT, QUINDI SE SI 
PROVA AD ESEGUIRE IL CODICE DA QUI ANDRA' IN ERRORE
*/

using System;

public static class Program
{
    public static void Main(string[] args)
    {
        Get Do = new Get();

        Do.AskSubjects();
        decimal Average = Do.AskDegrees();

        Console.WriteLine($"La tua media scolastica è di {Average}");
    }

    private class Get
    {
        int SchoolSubjects;

        public void AskSubjects()
        {
            bool Success;

            Console.WriteLine("Di quante materie hai voti? ");
            Success = int.TryParse(Console.ReadLine(), out this.SchoolSubjects);

            while (!Success || this.SchoolSubjects <= 0)
            {
                Console.WriteLine("Numero inserito non valido, riprova: ");
                Success = int.TryParse(Console.ReadLine(), out this.SchoolSubjects);
            }
        }

        public decimal AskDegrees()
        {
            bool Success;
            int TempDegree;
            int Total = 0;

            for (int i = 0; i < this.SchoolSubjects; i++)
            {
                Console.WriteLine("Inserisci il voto di una materia: ");
                Success = int.TryParse(Console.ReadLine(), out TempDegree);

                while (!Success || TempDegree <= 0)
                {
                    Console.WriteLine("Numero inserito non valido, riprova: ");
                    Success = int.TryParse(Console.ReadLine(), out TempDegree);
                }

                Total += TempDegree;
            }

            decimal Average = (decimal)Total / this.SchoolSubjects;
            return Average;
        }
    }
}

#include <iostream>
using namespace std;
int main () { 
    int scelta; 
    do { 
        //system("cls"); 
        cout<<"MENU/n";
        cout<<" 1) Esercizio 1 "<<endl; 
        cout<<" 2) Esci "<<endl; 

        cin>>scelta; 
        switch(scelta) {
            case 1: 
                //es 1 ecc...
                break; 
            case 2: 
                cout<<"Fine"<<endl; 
                break; 
            default: 
                cout<<"Opzione non valida"<<endl; 
            } 
            //system("PAUSE"); (va insieme al system cls:pulisce schermo)->si puo usare su ide che lo supportano 
            } while(scelta!=2); 
            return 0; 
        }

#include <iostream>
#include <string>
#include <time.h>
#include <stdlib.h>
#define DIM 20
using namespace std;

struct s_nodo
{
	int num;
	s_nodo *pnext;
};

s_nodo* caricalista();
void stampalista(s_nodo *ptesta);
s_nodo* fusione(s_nodo *ptesta);
s_nodo* rovescialista(s_nodo *ptesta);

int main()
{
	srand(time(NULL));
	s_nodo *ptesta=new s_nodo;
	s_nodo *ptesta2=new s_nodo;
	
	ptesta=NULL;
	ptesta2=NULL;
	
	ptesta=caricalista();
	cout<<"Lista: "<<endl;
	stampalista(ptesta);
	ptesta2=fusione(ptesta);
	cout<<endl;
	cout<<"Lista >= 60: "<<endl;
	stampalista(ptesta2);
	
	ptesta=rovescialista(ptesta);
	cout<<"Lista invertita: "<<endl;
	stampalista(ptesta);
	ptesta2=rovescialista(ptesta2);
	cout<<"Lista >= 60 invertita: "<<endl;
	stampalista(ptesta2);
	

	
	return 0;
}

s_nodo* caricalista()
{
	s_nodo *ptesta=NULL;
	s_nodo *pprev=NULL;
	
	for(int i=0;i<DIM;i++)
	{
		s_nodo *ptemp=new s_nodo;
		ptemp->num=rand()%91+10;
		ptemp->pnext=NULL;
		if(pprev!=NULL)
		{
			pprev->pnext=ptemp;
		}
		else
		{
			ptesta=ptemp;
		}
		pprev=ptemp;
	}
	return ptesta;
}

void stampalista(s_nodo *ptesta)
{
	while(ptesta!=NULL)
	{
		cout<<"Numero: "<<ptesta->num<<endl;
		ptesta=ptesta->pnext;
	}
	cout<<endl;
}

s_nodo* fusione(s_nodo *ptesta)
{
    s_nodo *ptesta2=NULL;
    s_nodo *pprev=NULL;
    s_nodo *ptemp=ptesta;

    while(ptemp!=NULL)
    {
        if(ptemp->num>=60)
        {
            s_nodo *ptemp2=new s_nodo;
            ptemp2->num=ptemp->num;
            ptemp2->pnext=NULL;
            
            if(pprev != NULL)
            {
            	pprev->pnext=ptemp2;
			}
            else
            {
            	ptesta2=ptemp2;
			}
            pprev=ptemp2;
        }
        ptemp=ptemp->pnext;
    }

    return ptesta2;
}

s_nodo* rovescialista(s_nodo *ptesta)
{
	s_nodo *pprev=NULL;
	s_nodo *curr=ptesta;
    s_nodo *next=NULL;

    while(curr!=NULL)
    {
        next=curr->pnext;
        curr->pnext=pprev;
        pprev=curr;       
        curr=next;       
    }

    return pprev;
}

#include <iostream>
#include <string>
using namespace std;

int main() {
    try{
        int x = 10;
        int y = 0;
        throw 44;
        if(y == 0){
            throw runtime_error("error dividing");
        }else{
            cout << x/y;
        }
    }catch(const runtime_error& e){
        cout << e.what();
    }catch(const int x){
        cout << x;
    }
    
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <map>
using namespace std;

class Student {

    private:
        string name;
        int age;
        map<string, int> grades;

    public:
        Student(string name, int age){
            this->name = name;
            this->age = age;
        }

        void addGrade(int grade, string subName){
            grades.insert({subName, grade});
        }

        void modifyGrade(string subName, int grade){
            if(grades.count(subName) != 0){
                grades[subName] = grade;
            }
        }

        void printInfo(){
            cout << "Name: " << this->name <<endl;
            cout << "Age: " << this->age <<endl;
            if(grades.empty()){
                cout << "No grades added";
            }else{
                for(auto g : grades){
                    cout << "Grade of " << g.first << " is " << g.second <<endl; 
                }
            }

        }

        int calGrade(){
            if(grades.empty()){
                return 0;
            }
            int total = 0;
            int size = grades.size(); 
            for(auto g : grades){
                total += g.second;
            }
            return total / size;
        }
        
        void cleargrade(){
            grades.clear();
        }
};

    enum TrafficLight{
        Red,
        Yellow,
        Green
    };

int main() {
    Student s1("Gabi", 24);
    s1.addGrade(10, "IT");
    s1.modifyGrade("IT", 12);
    s1.addGrade(7, "Mate");
    s1.addGrade(8, "Sci");
    s1.printInfo();
    int cal = s1.calGrade();
    if(cal == 0){
        cout << "No grades were added";
    }else{
        cout << "Media: " << cal <<endl;
    }
    s1.cleargrade();


    TrafficLight trafficLight = Red;

    switch(trafficLight){
        case Red:
            cout << "Stop";
            break;
        case Yellow:
            cout << "Slow down";
            break;
        default:
            cout << "Go";
    }
    return 0; 
}

SELECT impiegati.nome, impiegati.cognome 
FROM impiegati
JOIN assegnazioni ON impiegati.id = assegnazioni.id
JOIN progetti ON a.idDipartimento = progetti.idDipartimento
WHERE progetti.budget > (
    SELECT AVG(progetti.budget) 
    FROM progetti
);
--------------------------------------------------------------------------------
SELECT dipartimenti.nome, COUNT(progetti.id) AS numProgetti
FROM progetti
JOIN dipartimenti ON progetti.idDipartimento = dipartimenti.id
GROUP BY d.nome
HAVING numProgetti > 3;
--------------------------------------------------------------------------------
SELECT impiegati.nome, impiegati.cognome 
FROM impiegati
JOIN assegnazioni ON impiegati.id = assegnazioni.idImpiegato
GROUP BY assegnazioni.idImpiegato
HAVING COUNT(assegnazioni.idProgetto) >= 2;
--------------------------------------------------------------------------------
SELECT * FROM impiegati AS manager
JOIN impiegati ON manager.id = impiegati.idManager
GROUP BY impiegati.idManager 
HAVING AVG(impiegati.stipendio) > 2500;
--------------------------------------------------------------------------------
SELECT * FROM progetti
WHERE progetti.id NOT IN (
    SELECT tasks.idProgetto FROM tasks
    WHERE tasks.priorità = 'Alta'
);
--------------------------------------------------------------------------------
SELECT dipartimenti.nome, SUM(assegnazioni.oreSettimanali), 
FROM assegnazioni
JOIN progetti ON assegnazioni.idProgetto = progetti.id
JOIN dipartimenti ON progetti.idDipartimento = dipartimenti.id
GROUP BY dipartimenti.nome;
--------------------------------------------------------------------------------
SELECT *
FROM impiegati
JOIN assegnazioni ON impiegati.id = assegnazioni.idImpiegato
JOIN progetti ON assegnazioni.idProgetto = progetti.id
WHERE impiegati.idDipartimento = progetti.idDipartimento;
--------------------------------------------------------------------------------
SELECT progetti.id, progetti.titolo
FROM progetti
JOIN (
    SELECT tasks.idProgetto, COUNT(tasks.id) AS numTask 
    FROM tasks
    GROUP BY tasks.idProgetto;
) AS tasksPerProgetti ON progetti.idProgetto = tasksPerProgetti.idProgetto
WHERE tasksPerProgetti.numTask = (
    SELECT MAX(num)
    FROM (
        SELECT COUNT(*) as num
        FROM tasks
        GROUP BY tasks.idProgetto
    )
);

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

int main() {
    int numbers[] = {11, 22, 11, 22, 33, 44, 44}; // 4 byte
    
    int len = sizeof(numbers) / sizeof(numbers[0]);
    int i = 0;
    // printf("%d", len);
    // for(int i = 0; i < len; ++i){
    //     printf("%d \n", numbers[i]);
    // }

    int temNumbers[len];
    // 
    for(int i = 0; i < len; ++i){
        temNumbers[i] = 0;
    } 
    // printf("%d", temNumbers[4]);
    while(i < len){
        bool skip = false;
        for(int j = 0; j < len; ++j){
            if(temNumbers[j] == numbers[i]){
                skip = true;
            }
        }
        temNumbers[i] = numbers[i];
        if(skip){
            ++i;
            skip = false;
            continue;
        }
        printf("%d \n", numbers[i]);
        ++i;
        skip = false;
    };
    return 0;
}

>++++[-<+++++++++++>]>,[>++++++[-<-------->]>+++++++++[-<<<[->+>+<<]>>[-<<+
>>]>]<<[-<+>],]<<+++++.-----.+++++.----->-->+>+<<[-<.>>>[->+>+<<]<[->>>+<<<
]>>[-<<+>>]>[->+<<<+>>]>[>>>>++++++++++<<<<[->+>>+>-[<-]<[->>+<<<<[->>>+<<<
]>]<<]>+[-<+>]>>>[-]>[-<<<<+>>>>]<<<<]<[>++++++[<++++++++>-]<-.[-]<]<<<<]

#include <iostream>
using namespace std;

int factorial(int num){
    // base case 
    if(num == 1){
        return 1;
    }
    // function call
    return num * factorial(num - 1);
}
int main() {
    cout << factorial(5) <<endl;
    return 0;
}

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

int main() {
    int numOfStudents = 0;
    printf("How many students do you have \n");
    // scanf(" %d", &numOfStudents);
    numOfStudents = 5;
    // int students[5];
    // printf("%d", sizeof(students));
    // malloc, calloc
    // sizeof(int) // 4 bytes
    // sizeof(char) // 1 byte
    // sizeof(float) // 4 bytes
    // sizeof(double) // 8 bytes
    printf("%d \n", numOfStudents * sizeof(int));
    int *ptr = malloc(numOfStudents * sizeof(*ptr)); // 20 => 5 * 4 = 20
    // int *ptr = calloc(numOfStudents, sizeof(int));
    if(ptr == NULL){
        printf("error in allocating memory");
        return 1;
    }
    // printf("%d \n", *(ptr+4));
    // ...
    for(int i = 0; i < numOfStudents; i++){
        ptr[i] = i + 10;
    }
    for(int i = 0; i < numOfStudents; i++){
        printf("%d \n", *(ptr + i));
    }
    free(ptr);
    ptr = NULL;
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    for(int i = 0; i < 10; ++i){
        for(int j = 0; j < 10; ++j){
            cout << j << endl;
        }
        cout << i << endl;
    }
    int myNumbers[5] = {10, 20, 30, 40, 50};
    for(int num : myNumbers){
        cout << num <<endl;
    }

    int i = 10;
    while(i < 10){
        cout << "i " << i <<endl;
        i++;
    }

    int j = 10;
    do{
        cout << "j " << j <<endl;
        j++;
    }while(j < 10);

    return 0;
}



  

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

void saluta(char name[]){
    printf("Ciao %s \n", name);
}

int add(int num1, int num2){
    int result = num1 + num2;
    return result;
    // printf("hello")
}

void greet(void (*callback)(char[]), char name[]){
    callback(name);
}

int main() {
    int age = 24;
    int* age2 = &age;
    age = 25;
    printf("%d", *age2);
    int res = add(12, 13);
    printf("%d", res);
    return 0;
}

import time

class BankAccount:
    def __init__(self, balance):
        self._balance = balance
        self._has_loan = False
        self.loan_taken = 0

    def deposit(self, amount):
        self._balance += amount
        return f"You now have {self._balance}"

    def check_balance(self, amount):
        return self._balance - amount

    def withdraw(self, amount):
        if self.check_balance(amount) >= 0:
            self._balance -= amount
            return "withdraw successfully"
        else:
            return "not enough balance"

    def show_balance(self):
        return self._balance
    
    def _check_if_has_loan(self):
        return self._has_loan

    def take_loan(self, amount):
        if self._has_loan:
            return "already has a loan"
        self._has_loan = True
        self._balance += amount
        self.loan_taken += amount
        return f"successfully taken loan of {amount}"
    
    def pay_loan(self, amount):
        if not self._check_if_has_loan():
            return "No loan to pay"
        if amount > self.loan_taken:
            return f"You have to pay only {self.loan_taken}"
        self.loan_taken -= amount
        if self.loan_taken == 0:
            self._has_loan = False
            return f"You have paid out your loan"
        return f"You now have {self.loan_taken} to pay"

my_acc = BankAccount(1000)
print(my_acc.show_balance())
print(my_acc.deposit(50))
print(my_acc.withdraw(1000))
print(my_acc.take_loan(100))
print(my_acc.pay_loan(1000))
print(my_acc.pay_loan(100))
print(my_acc.pay_loan(10))


def add():
    ciao = "ciao"

// Programma: Controlla se un numero è pari o dispari

// Chiede un numero all'utente
let numero = 3;

// Converte l'input in numero
numero = Number(numero);

// Controlla se è un numero valido
if (isNaN(numero)) {
  console.log("Per favore inserisci un numero valido!");
} else {
  if (numero % 2 === 0) {
    console.log("Il numero " + numero + " è pari.");
  } else {
    console.log("Il numero " + numero + " è dispari.");
  }
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <climits>
using namespace std;

class MyClass {
    
} 

int main() {

    return 0;
}



  

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        // Creazione di una lista di stringhe non ordinata
        List <string> list = new List<string>{
            new string("Fabriano"),
            new string("Bari"),
            new string("Domodossola"),
            new string("Ancona"),
            new string("Empoli"),
            new string("Civitanova"),
        };

        list.Sort(); // Ordinamento standard A-Z

        foreach(string s in list){
            Console.Write(s + ' ');
        }
    }
}

import numpy as np

b = np.array([
    [1,2,3],
    [0,3,5],
    [1,5,3]
])

print(b[1,2]);

++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>
->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.
------.--------.>>+.>++.

// JavaScript Playground
    const numbers = [1, 2, 3, 4, 5];

    // Map dei numeri al loro quadrato
    const squares = numbers.map(n => n * n);
    console.log('Original numbers:', numbers);
    console.log('Squared numbers:', squares);

    // Filtraggio dei numeri pari
    const evenNumbers = numbers.filter(n => n % 2 === 0);
    console.log('Even numbers:', evenNumbers);

    // Calcolo della somma usando reduce
    const sum = numbers.reduce((acc, curr) => acc + curr, 0);
    console.log('Sum of numbers:', sum);

fn main() {
    println!("Hello world");
}