import java.util.*;

class Main{
    static final int INF = Integer.MAX_VALUE;
   
    
    int minDistance(int[] dist,Boolean[] sptSet,int V){
        int min= INF ,min_index = -1;
        
        for(int v=0;v<V;v++){
            if(!sptSet[v] && dist[v] <= min){
                min = dist[v];
                min_index = v;
            }
        }
        return min_index;
    }
    
    void dijkistra(int[][] graph,int src,int V){
        int dist[] = new int[V];
        Boolean[] sptSet = new Boolean[V];
        
        Arrays.fill(dist,INF);
        Arrays.fill(sptSet,false);
        
        dist[src] = 0;
        
        for(int cnt=0;cnt<V-1;cnt++){
            int u= minDistance(dist,sptSet,V);
            sptSet[u] = true;
            for(int v=0;v<V;v++){
                if(!sptSet[v]&&graph[u][v]!=0&&dist[u]!=INF && dist[u]+graph[u][v]<dist[v]){
                    dist[v] = dist[u] + graph[u][v];
                }
            }
        }
        printSolution(dist,V);
    }
    void printSolution(int[] dist,int V){
        System.out.println("Vertex \t Distance fromSource");
        for(int i=0;i<V;i++){
            System.out.println(i+"\t"+dist[i]);
        }
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        
        System.out.println("Enter the number of vertices:");
        int n =sc.nextInt();
        
        System.out.println("Enter the adjacancy matrix");
        int[][] graph = new int[n][n];
        
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                graph[i][j] = sc.nextInt();
            }
        }
        
        System.out.println("Enter the source:");
        int src=sc.nextInt();
        Main obj = new Main();
        obj.dijkistra(graph,src,n);
    }
}

import java.util.Scanner;

class PrimsAlgo {

    // Function to find the vertex with the minimum key value
    private int minKey(int key[], Boolean mstSet[], int V) {
        int min = Integer.MAX_VALUE, min_index = -1;

        for (int v = 0; v < V; v++) {
            if (!mstSet[v] && key[v] < min) {
                min = key[v];
                min_index = v;
            }
        }
        return min_index;
    }

    // Function to print the MST
    void printMST(int parent[], int graph[][], int V) {
        System.out.println("Edge \tWeight");
        for (int i = 1; i < V; i++) {
            System.out.println(parent[i] + " - " + i + "\t" + graph[i][parent[i]]);
        }
    }

    // Function to implement Prim's MST algorithm
    void primMST(int graph[][], int V) {
        int parent[] = new int[V];
        int key[] = new int[V];
        Boolean mstSet[] = new Boolean[V];

        // Initialize all keys as INFINITE
        for (int i = 0; i < V; i++) {
            key[i] = Integer.MAX_VALUE;
            mstSet[i] = false;
        }

        // Make the key value of the first vertex 0 so that it is picked first
        key[0] = 0;
        parent[0] = -1;

        // Find the MST
        for (int count = 0; count < V - 1; count++) {
            // Pick the minimum key vertex from the set of vertices not yet processed
            int u = minKey(key, mstSet, V);
            mstSet[u] = true;

            // Update the key and parent values of the adjacent vertices
            for (int v = 0; v < V; v++) {
                if (graph[u][v] != 0 && !mstSet[v] && graph[u][v] < key[v]) {
                    parent[v] = u;
                    key[v] = graph[u][v];
                }
            }
        }

        // Print the constructed MST
        printMST(parent, graph, V);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Take the number of vertices as input
        System.out.print("Enter the number of vertices: ");
        int V = scanner.nextInt();

        // Create an adjacency matrix for the graph
        int[][] graph = new int[V][V];

        // Take the adjacency matrix as input from the user
        System.out.println("Enter the adjacency matrix (use 0 for no edge):");
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                graph[i][j] = scanner.nextInt();
            }
        }

        // Create an object of PrimsAlgo to calculate the MST
        PrimsAlgo t = new PrimsAlgo();
        t.primMST(graph, V);

        // Close the scanner to avoid resource leak
        scanner.close();
    }
}

import pandas as pd
from sklearn.preprocessing import LabelEncoder


data={
    'student':["deva","shankar","vamshi","barath","sohel"],
    'score':[100,90,80,67,96],
    'passorfail':["yes","yes","yes","no","yes"]
}
df=pd.DataFrame(data)
print(df)


label_encoder=LabelEncoder()
df=pd.DataFrame(data)
df['col_encoder']=label_encoder.fit_transform(df['passorfail'])
print(df)

/*output
 student  score passorfail  col_encoder
0     deva    100        yes            1
1  shankar     90        yes            1
2   vamshi     80        yes            1
3     bara     67         no            0
4    sohel     96        yes            1*/

import pandas as pd

# Sample dictionary
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [24, 27, 22],
    'City': ['New York', 'Los Angeles', 'Chicago']
}

# Convert to DataFrame
df = pd.DataFrame(data)
print(df)

public class OBSTree{
    public static void main(String[] args) {
        // Sample probabilities for keys and "dummy" nodes
         double[] P = {3, 3, 1, 1}; // Probability for each key
        double[] Q = {2, 3, 1, 1, 1}; // Dummy node probabilities

        int n = P.length;

        // Call the OBST procedure
        OBSTResult result = OBST(P, Q, n);

        // Print the cost and root matrices
        System.out.println("Cost Matrix C:");
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n; j++) {
                System.out.printf("%.2f ", result.C[i][j]);
            }
            System.out.println();
        }

        System.out.println("\nRoot Matrix R:");
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n; j++) {
                System.out.printf("%d ", result.R[i][j]);
            }
            System.out.println();
        }
    }

    public static OBSTResult OBST(double[] P, double[] Q, int n) {
        double[][] C = new double[n + 1][n + 1];
        double[][] W = new double[n + 1][n + 1];
        int[][] R = new int[n + 1][n + 1];

        // Initialize for single nodes and dummy nodes
        for (int i = 0; i <= n; i++) {
            W[i][i] = Q[i];
            C[i][i] = 0;
            R[i][i] = 0;
            if (i < n) {
                W[i][i + 1] = Q[i] + Q[i + 1] + P[i];
                C[i][i + 1] = W[i][i + 1];
                R[i][i + 1] = i + 1;
            }
        }

        // Compute the OBST for all subarrays of length >= 2
        for (int m = 2; m <= n; m++) { // Tree size
            for (int i = 0; i <= n - m; i++) {
                int j = i + m;
                W[i][j] = W[i][j - 1] + P[j - 1] + Q[j];

                // Find optimal root in range that minimizes cost
                double minCost = Double.MAX_VALUE;
                int bestRoot = -1;

                // Apply Knuth's optimization to reduce the number of root checks
                for (int k = R[i][j - 1]; k <= R[i + 1][j]; k++) {
                    double cost = C[i][k - 1] + C[k][j];
                    if (cost < minCost) {
                        minCost = cost;
                        bestRoot = k;
                    }
                }

                C[i][j] = W[i][j] + minCost;
                R[i][j] = bestRoot;
            }
        }

        // Return the computed cost and root matrices
        return new OBSTResult(C, W, R);
    }
}

// Helper class to store the results of the OBST function
class OBSTResult {
    double[][] C;
    double[][] W;
    int[][] R;

    OBSTResult(double[][] C, double[][] W, int[][] R) {
        this.C = C;
        this.W = W;
        this.R = R;
    }
}

<link href="style.css?v=1">

//
//#include <iostream> 
//using namespace std;
//
//int main() {
//    int n;
//    setlocale(LC_ALL, "");
//    cout << "Введите количество чисел: ";
//    cin >> n;
//    int* arr = new int[n];
//
//    // Ввод чисел в массив 
//    cout << "Введите " << n << " чисел:" << endl;
//    for (int i = 0; i < n; ++i) {
//        cin >> *(arr+i);
//    }
//
//    // Поиск наибольшего числа
//    int max_value = *(arr);
//
//    for (int i = 1; i < n; ++i) {
//        if (arr[i] > max_value) {
//            max_value = *(arr+i);
//        }
//    }
//
//    // Вывод результата 
//    cout << "Наибольшее число: " << max_value << endl;
//    delete[] arr;
//    return 0;
//
//}

//#include<iostream>
//#include<vector>
//#include<windows.h>
//using namespace std;
//
//int main()
//{
//    SetConsoleCP(1251);
//    SetConsoleOutputCP(1251);
//    int n; // Количествострок
//    cout << "Введите количество строк: ";
//    cin >> n;
//
//    vector<string>lines; // Вектор для хранения строк
//
//    // Ввод строк
//    cout << "Введите " << n << " строк:" << endl;
//    for (int i = 0; i < n; ++i)
//    {
//        string line;
//        cin >> line; // Считываем строку без пробелов
//
//        // Вставляем строку в отсортированное место
//        vector<string>::iterator it = lines.begin();
//        while (it != lines.end() && *it < line)
//        {
//            ++it; // Находим место для вставки
//        }
//        lines.insert(it, line); // Вставляемстроку
//    }
//
//    // Вывод результата
//    cout << "Строки в алфавитном порядке:" << endl;
//    for (vector<string>::size_type i = 0; i < lines.size(); ++i)
//    {
//        cout << lines[i] << endl;
//    }
//
//    return 0;
//}
//

#include <iostream>
#include <windows.h>
using namespace std;

void print_array_using_pointers(int r, int c, int* ptr)
{
	int i, j;
	for (i = 0; i < r; i++)
	{
		cout << "[";
		for (j = 0; j < c; j++)
		{
			cout << " " << *ptr;
			ptr = ptr + 1;
		}
		cout << " ]" << endl;
	}
	return;
}

double determinant(int m, int* p)
{
	double ans = 0, inner_sol, inner_determinant;
	int a, b, c, d;

	if ((m == 1) || (m == 2))
	{
		if (m == 1)
			ans = *p;
		else
		{
			a = *p;
			b = *(p + 1);
			c = *(p + 2);
			d = *(p + 3);
			ans = (a * d) - (b * c);
		}
	}
	else
	{
		int i, j, k, l, n, sign, basic, element;
		n = 0;
		sign = +1;
		int* q;
		q = new int[(m - 1) * (m - 1)];

		for (i = 0; i < m; i++)
		{
			l = 0;
			n = 0;
			basic = *(p + i);

			for (j = 0; j < m; j++)
			{
				for (k = 0; k < m; k++)
				{
					element = *(p + l);
					cout << element << " ";
					if ((j == 0) || (i == k));
					else
					{
						*(q + n) = element;
						n = n + 1;
					}
					l = l + 1;
				}
			}
			cout << endl << basic << " x " << endl;
			print_array_using_pointers((m - 1), (m - 1), q);

			inner_determinant = determinant(m - 1, q);
			inner_sol = sign * basic * inner_determinant;

			cout << "Знак:" << sign << "x Базис: " << basic << "x Определитель" << inner_determinant << " = " << inner_sol << endl;
			ans = ans + inner_sol;
			sign = sign * -1;
		}
		delete[] q;
	}
	return ans;
}

void initialize_array(int r, int c, int* ptr)
{
	int i, j, k;
	cout << "Вводите числа в матрицу" << endl;
	cout << "После каждого числа нажимайте Enter" << endl;

	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			cin >> k;
			*(ptr + i * c + j) = k;

		}
	}
}

int main()
{
	SetConsoleCP(1251);
	SetConsoleOutputCP(1251);


	int r, * p;
	cout << "Количество рядов: ";
	cin >> r;

	p = new int[r * r];

	initialize_array(r, r, p);
	print_array_using_pointers(r, r, p);
	double ans = determinant(r, p);

	cout << "Определитель: " << ans << endl;
	delete[] p;

	return 0;

}

display: flex; justify-content: center; align-items: center;

import java.util.*;


public class JobSequencing {

    private static void calculateMaxProfit(Job[] ar,int md) {
        
        Arrays.sort(ar,(Job a,Job b)->{
           return  b.profit-a.profit;
        });
        int profit=0;
        for(Job j:ar){
            System.out.println(j.deadline+";"+j.profit+";"+j.id);
        }
        System.out.println();
        char js[]=new char[md];
        boolean []slot=new boolean[md];
        for(int i=0;i<ar.length;i++){
            for(int j=Math.min(md-1,ar[i].deadline-1);j>=0;j--){
                if(slot[j]==false){
                    slot[j]=true;
                    profit+=ar[i].profit;
                    js[j]=ar[i].id;
                    break;
                }
            }
        }

        System.out.println("max profit is :"+profit);
        System.out.println("job sequence");
        for(char c:js){
            System.out.print(c+" ");;
        }



    }



    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("enter no of jobs:");
        int n=sc.nextInt();
        Job [] ar=new Job[n];
        char c='a';
        int md=0;
        for(int i=0;i<n;i++){
            System.out.println("enter deadline for job :"+(i+1));;
            int d=sc.nextInt();
            md=Math.max(d,md);
            System.out.println("enter profit for job :"+(i+1));;
            int p=sc.nextInt();
            Job j=new Job(c, d, p);
            c=(char)(c+1);
            ar[i]=j;
        }
        calculateMaxProfit(ar,md);
        
        
            }
        
          
}
public class Job {
    char id;
    int deadline;
    int profit;
    public Job(char id, int deadline, int profit) {
        this.id = id;
        this.deadline = deadline;
        this.profit = profit;
    }
    



}

////////////////// STRINGS and thier method////////////////////////
 
const name = "hitesh-hc";
const repoCount = 50;
 
//// string interpolation
console.log(`hello my name is ${name} and my repoCount is ${repoCount}`);
///// hello my name is hitesh and my repoCount is 50
 
 
/////string decalaration
const gamename = new String ("hitesh");
console.log(gamename);
 
 
console.log(gamename[0]);
console.log(gamename.__proto__);
console.log(gamename.length);
console.log(gamename.toUpperCase()); 
console.log(gamename.charAt(2)); 
console.log(gamename.indexOf('t')); 
 
const newString = gamename.substring(0,4); // it will show 0 to 3 index
console.log(newString);
 
const anotherString = gamename.slice(-8,4)/// picha se 0 se 4
console.log(anotherString);
 
const newStringOne = "   hitesh   ";
console.log(newStringOne);
console.log(newStringOne.trim());
 
const url ="htppp//hitesh;;;okay"
 
console.log(url.replace(';;;','-'))/// replacing 
console.log(url.includes('sundar')) //// in string or not 
 
console.log(gamename.split('-'))
 
 
 

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

#define MAX 100

// Graph representation
int arr[MAX][MAX];  // Adjacency matrix
int dfn[MAX];       // Discovery time for each node
int low[MAX];       // Lowest point reachable from each node
int num;            // Counter for discovery time
bool visited[MAX];  // Track if a vertex is visited
bool articulation[MAX]; // Track articulation points

void art(int u, int v, int n) {
    dfn[u] = low[u] = num++;
    int child = 0;
    visited[u] = true;
    
    for (int j = 0; j < n; j++) {
        if (arr[u][j] == 1) {
            if (dfn[j] == 0) { // If not visited
                child++;
                art(j, u, n);
                if (low[j] >= dfn[u]) {
                    articulation[u] = true;
                }
                low[u] = (low[u] < low[j]) ? low[u] : low[j];
            } else if (j != v) {
                low[u] = (low[u] < dfn[j]) ? low[u] : dfn[j];
            }
        }
    }
    
    // Special case for root node
    if (v == -1 && child > 1) {
        articulation[u] = true;
    }
}

void printVisited(int n) {
    printf("Articulation points: ");
    for (int i = 0; i < n; i++) {
        if (articulation[i]) {
            printf("%d ", i);
        }
    }
    printf("\n");
    
    // Print discovery times (dfn)
    printf("Discovery times: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", dfn[i] - 1); // Subtract 1 to adjust to zero-indexed vertices
    }
    printf("\n");
}

int main() {
    int n;
    printf("Enter number of vertices: ");
    scanf("%d", &n);
    
    // Initialize arrays
    for (int i = 0; i < n; i++) {
        dfn[i] = low[i] = 0;
        visited[i] = false;
        articulation[i] = false;
    }

    // Read adjacency matrix
    printf("Enter adjacency matrix:\n");
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &arr[i][j]);
        }
    }

    // Start DFS from vertex 0 (can be any vertex, usually 0 for simplicity)
    num = 1;  // Set the discovery time counter to 1
    art(0, -1, n);
    
    // Output the results
    printVisited(n);
    
    return 0;
}

import java.util.Scanner;

public class OBSTree {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Get the number of keys
        System.out.print("Enter the number of keys: ");
        int n = scanner.nextInt();

        // Input probabilities for keys (P array)
        double[] P = new double[n];
        System.out.println("Enter probabilities for the keys:");
        for (int i = 0; i < n; i++) {
            System.out.print("P[" + i + "]: ");
            P[i] = scanner.nextDouble();
        }

        // Input probabilities for dummy nodes (Q array)
        double[] Q = new double[n + 1];
        System.out.println("Enter probabilities for the dummy nodes:");
        for (int i = 0; i <= n; i++) {
            System.out.print("Q[" + i + "]: ");
            Q[i] = scanner.nextDouble();
        }

        // Call the OBST procedure
        OBSTResult result = OBST(P, Q, n);

        // Print the cost and root matrices
        System.out.println("\nCost Matrix C:");
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n; j++) {
                System.out.printf("%.2f ", result.C[i][j]);
            }
            System.out.println();
        }

        System.out.println("\nRoot Matrix R:");
        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= n; j++) {
                System.out.printf("%d ", result.R[i][j]);
            }
            System.out.println();
        }

        // Print the optimal cost
        System.out.printf("\nThe optimal cost is: %.2f\n", result.C[0][n]);
    }

    public static OBSTResult OBST(double[] P, double[] Q, int n) {
        double[][] C = new double[n + 1][n + 1];
        double[][] W = new double[n + 1][n + 1];
        int[][] R = new int[n + 1][n + 1];

        // Initialize for single nodes and dummy nodes
        for (int i = 0; i <= n; i++) {
            W[i][i] = Q[i];
            C[i][i] = 0;
            R[i][i] = 0;
            if (i < n) {
                W[i][i + 1] = Q[i] + Q[i + 1] + P[i];
                C[i][i + 1] = W[i][i + 1];
                R[i][i + 1] = i + 1;
            }
        }

        // Compute the OBST for all subarrays of length >= 2
        for (int m = 2; m <= n; m++) { // Tree size
            for (int i = 0; i <= n - m; i++) {
                int j = i + m;
                W[i][j] = W[i][j - 1] + P[j - 1] + Q[j];

                // Find optimal root in range that minimizes cost
                double minCost = Double.MAX_VALUE;
                int bestRoot = -1;

                // Apply Knuth's optimization to reduce the number of root checks
                for (int k = R[i][j - 1]; k <= R[i + 1][j]; k++) {
                    double cost = C[i][k - 1] + C[k][j];
                    if (cost < minCost) {
                        minCost = cost;
                        bestRoot = k;
                    }
                }

                C[i][j] = W[i][j] + minCost;
                R[i][j] = bestRoot;
            }
        }

        // Return the computed cost and root matrices
        return new OBSTResult(C, W, R);
    }
}

// Helper class to store the results of the OBST function
class OBSTResult {
    double[][] C;
    double[][] W;
    int[][] R;

    OBSTResult(double[][] C, double[][] W, int[][] R) {
        this.C = C;
        this.W = W;
        this.R = R;
    }
}

import java.util.Arrays;
import java.util.Scanner;

// Job class to hold information about each job.
class Job {
    int id;       // Job ID
    int profit;   // Profit of the job
    int deadline; // Deadline of the job
    
    // Constructor to initialize job details
    public Job(int id, int profit, int deadline) {
        this.id = id;
        this.profit = profit;
        this.deadline = deadline;
    }
}

// Comparator to sort jobs based on profit in descending order
class JobComparator implements java.util.Comparator<Job> {
    @Override
    public int compare(Job job1, Job job2) {
        return job2.profit - job1.profit; // Sorting in descending order of profit
    }
}

public class Main {

    // Function to perform Job Sequencing with Deadlines
    public static void jobSequencing(Job[] jobs, int n) {
        // Sort the jobs based on profit in descending order
        Arrays.sort(jobs, new JobComparator());
        
        // Find the maximum deadline to determine the size of the result array
        int maxDeadline = 0;
        for (int i = 0; i < n; i++) {
            if (jobs[i].deadline > maxDeadline) {
                maxDeadline = jobs[i].deadline;
            }
        }
        
        // Array to store the result (sequenced jobs)
        int[] result = new int[maxDeadline];
        
        // Initialize all slots as empty (-1 means no job is scheduled)
        Arrays.fill(result, -1);
        
        // Variable to track total profit
        int totalProfit = 0;
        
        // Iterate over all jobs
        for (int i = 0; i < n; i++) {
            // Find a free slot for the job (starting from the latest available slot)
            for (int j = jobs[i].deadline - 1; j >= 0; j--) {
                if (result[j] == -1) { // If the slot is free
                    result[j] = jobs[i].id; // Schedule the job
                    totalProfit += jobs[i].profit; // Add profit
                    break;
                }
            }
        }
        
        // Print the scheduled jobs and total profit
        System.out.println("Jobs scheduled in the sequence are:");
        for (int i = 0; i < maxDeadline; i++) {
            if (result[i] != -1) {
                System.out.print("Job " + result[i] + " ");
            }
        }
        System.out.println();
        System.out.println("Total Profit = " + totalProfit);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Take input for number of jobs
        System.out.print("Enter number of jobs: ");
        int n = scanner.nextInt();

        // Create an array of jobs
        Job[] jobs = new Job[n];

        // Take input for jobs (id, profit, deadline)
        System.out.println("Enter job details (ID Profit Deadline):");
        for (int i = 0; i < n; i++) {
            System.out.print("Job " + (i + 1) + ": ");
            int id = scanner.nextInt();
            int profit = scanner.nextInt();
            int deadline = scanner.nextInt();
            jobs[i] = new Job(id, profit, deadline);
        }

        // Call the job sequencing function
        jobSequencing(jobs, n);

        scanner.close();
    }
}

<script src="https://cdn.jsdelivr.net/npm/p5.capture@1.4.1/dist/p5.capture.umd.min.js"></script>

// Side Menu
    .side{
        &-menu{
            position: absolute;
            right: 0;
            top: _res(38,86);
            width: auto;
            @include _flex($dir: column);
            transition: all .3s ease-in-out;
            transform: translateX(100%);
            &.open{
                transform: translateX(0);
            }
        }
        &-logo{
            background: #000;
            padding: _res(35) _res(45);
            img{ 
                width: _res(150,300);
            }
        }
        &-nav{
            width: 100%;
            .navbar-collapse{ 
                padding: 0; 
                .navbar-nav{
                    @include _flex($dir: column);
                    >li{
                        width: 100%;
                        &:not(:last-child){
                            border-bottom: _res(3) solid $brand-primary;
                        }
                        .root-link{
                            color: #000;
                            background: #fff;
                            display: block;
                            font-size: _res(12,22);
                            font-weight: bold;
                            padding: _res(43) 0;
                            transition: all .3s ease-in-out;
                        }
                        &:hover{
                            >.root-link{
                                color: #fff;
                                background: $brand-primary;
                            }
                        }
                    }
                }
            }
        }
    }

// Side Menu Toggle
$('.header-icons .icon.menu').on('click', function(){
	$(this).toggleClass('expand-menu');
	$('.side-menu').toggleClass('open');
});

with zipfile.ZipFile(ZIP_NAME, 'w') as zipf:
       for folderName, subfolders, filenames in os.walk(DATA_PATH):
           for filename in filenames:
               filePath = os.path.join(folderName, filename)
               zipf.write(filePath, os.path.basename(filePath))

{
	"blocks": [
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": ":asx::xero: FY25 Half Year Results + Boost Days for next week | Please read! :xero::asx:"
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "Hey Sydney! It's that time a year again where we host half year results in our office and support the live call to the ASX, our Boost Days for next week will run a little differently, however we will continue to run the office as BAU as much as possible."
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Please note:*"
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": ":dot-blue:*FOH* - Front of house will be closed for the week for the results working group \n :dot-blue:*Staff Entry* - Please use the White Staff entry doors located on each side of the floor \n :dot-blue:*Anzac & Argyle* - These rooms are offline this week to also support the results working group \n :dot-blue:*Live Call* - Our Kitchen/breakout space will be closed between 10:30am - 11:30am. We will have a livestream of the call in Taronga for anyone who'd like to watch! \n :dot-blue:*Filming* - Kitchen will be closed between 10am - 10:20am Friday 15 November for a interview \n",
				"verbatim": false
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": ":star: Boost Days :star:",
				"emoji": true
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "Due to Half Year Results, our Boost Days will be changing for next week! Please see what's on below: \n  "
			}
		},
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": "Monday, 11th November :calendar-date-11:",
				"emoji": true
			}
		},
		{
			"type": "section",
			"text": {
				"type": "plain_text",
				"text": ":coffee: Café Partnership: Enjoy free coffee and café-style beverages from our partner, Elixir Sabour, which used to be called Hungry Bean.\n :breakfast: Morning Tea: Provided by Elixir Sabour from 9am in the All Hands. \n\n ",
				"emoji": true
			}
		},
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": "Tuesday, 12th November :calendar-date-12:",
				"emoji": true
			}
		},
		{
			"type": "section",
			"text": {
				"type": "plain_text",
				"text": ":coffee: Café Partnership: Café Partnership: Enjoy coffee and café-style beverages from our partner, Elixir Sabour, which used to be called Hungry Bean. \n :lunch: Lunch: Provided by Elixir Sabour from 12pm in the All Hands.",
				"emoji": true
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*:xero-unicorn: End of Year Event - A Sprinkle of Magic!* :xero-unicorn: \n\n  *🎟 RSVP Now:* Click <https://xero-wx.jomablue.com/reg/store/eoy_syd|here> to RSVP! \nMake sure you RSVP by *_Friday, 8th November 2024_*"
			}
		}
	]
}

#include <iostream>
#include <windows.h>
using namespace std;

void print_array_using_pointers(int r, int c, int* ptr)
{
	int i, j;
	for (i = 0; i < r; i++)
	{
		cout << "[";
		for (j = 0; j < c; j++)
		{
			cout << " " << *ptr;
			ptr = ptr + 1;
		}
		cout << " ]" << endl;
	}
	return;
}

double determinant(int m, int* p)
{
	double ans = 0, inner_sol, inner_determinant;
	int a, b, c, d;

	if ((m == 1) || (m == 2))
	{
		if (m == 1)
			ans = *p;
		else
		{
			a = *p;
			b = *(p + 1);
			c = *(p + 2);
			d = *(p + 3);
			ans = (a * d) - (b * c);
		}
	}
	else
	{
		int i, j, k, l, n, sign, basic, element;
		n = 0;
		sign = +1;
		int* q;
		q = new int[(m - 1) * (m - 1)];

		for (i = 0; i < m; i++)
		{
			l = 0;
			n = 0;
			basic = *(p + i);

			for (j = 0; j < m; j++)
			{
				for (k = 0; k < m; k++)
				{
					element = *(p + l);
					cout << element << " ";
					if ((j == 0) || (i == k));
					else
					{
						*(q + n) = element;
						n = n + 1;
					}
					l = l + 1;
				}
			}
			cout << endl << basic << " x " << endl;
			print_array_using_pointers((m - 1), (m - 1), q);

			inner_determinant = determinant(m - 1, q);
			inner_sol = sign * basic * inner_determinant;

			cout << "Знак:" << sign << "x Базис: " << basic << "x Определитель" << inner_determinant << " = " << inner_sol << endl;
			ans = ans + inner_sol;
			sign = sign * -1;
		}
		delete[] q;
	}
	return ans;
}

void initialize_array(int r, int c, int* ptr)
{
	int i, j, k;
	cout << "Вводите числа в матрицу" << endl;
	cout << "После каждого числа нажимайте Enter" << endl;

	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			cin >> k;
			*(ptr + i * c + j) = k;

		}
	}
}

int main()
{
	SetConsoleCP(1251);
	SetConsoleOutputCP(1251);


	int r, * p;
	cout << "Количество рядов: ";
	cin >> r;

	p = new int[r * r];

	initialize_array(r, r, p);
	print_array_using_pointers(r, r, p);
	double ans = determinant(r, p);

	cout << "Определитель: " << ans << endl;
	delete[] p;

	return 0;

}

#include <iostream>
#include <vector>
using namespace std; 
 
int main() {
    vector<int> arr = { 64, 34, 25, 12, 22, 11, 90 };
    int n = arr.size();
    bool swapped;
  
    for (int i = 0; i < n - 1; i++) {
        swapped = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
      
        // If no two elements were swapped, then break
        if (!swapped)
            break;
    }
    
    for (int num : arr)
        cout << " " << num;
}

#include <stdio.h>
#include <limits.h>

#define INF INT_MAX // Define infinity as the largest integer value

// Function to implement Prim's algorithm
int Prim(int cost[][100], int n, int t[][2]) {
    int near[100], mincost = 0;
    int i, j, k, l;

    // Initialize near[] array and the t array for storing edges in MST
    for (i = 1; i <= n; i++) {
        near[i] = 0;
    }

    // Step 1: Find the minimum cost edge to start with
    mincost = INF;
    for (i = 1; i <= n; i++) {
        for (j = i + 1; j <= n; j++) {
            if (cost[i][j] < mincost) {
                mincost = cost[i][j];
                k = i;
                l = j;
            }
        }
    }

    // Step 2: Initialize the first edge (k, l) in the MST
    t[1][0] = k;
    t[1][1] = l;

    // Step 3: Update the near[] array to store the nearest edge for each vertex
    for (i = 1; i <= n; i++) {
        if (cost[i][l] < cost[i][k]) {
            near[i] = l;
        } else {
            near[i] = k;
        }
    }
    near[k] = near[l] = 0; // Mark k and l as already part of the MST

    // Step 4: Find the remaining n - 1 edges
    for (i = 2; i <= n; i++) {
        int min_edge_cost = INF;
        // Find the vertex with minimum near cost
        for (j = 1; j <= n; j++) {
            if (near[j] != 0 && cost[j][near[j]] < min_edge_cost) {
                min_edge_cost = cost[j][near[j]];
                k = j;
                l = near[j];
            }
        }

        // Store the selected edge in MST
        t[i][0] = k;
        t[i][1] = l;

        // Add the minimum cost to the total cost of MST
        mincost += cost[k][l];

        // Mark the selected vertex (k) as part of the MST
        near[k] = 0;

        // Update the near[] array for all the remaining vertices
        for (j = 1; j <= n; j++) {
            if (near[j] != 0 && cost[j][near[j]] > cost[j][k]) {
                near[j] = k;
            }
        }
    }

    // Return the total minimum cost of the MST
    return mincost;
}

int main() {
    int cost[100][100], t[100][2], n, i, j;

    // Input the number of vertices
    printf("Enter the number of vertices: ");
    scanf("%d", &n);

    // Input the cost adjacency matrix
    printf("Enter the cost adjacency matrix:\n");
    for (i = 1; i <= n; i++) {
        for (j = 1; j <= n; j++) {
            scanf("%d", &cost[i][j]);
            if (cost[i][j] == 0) {
                cost[i][j] = INF; // No edge between i and j
            }
        }
    }

    // Call Prim's algorithm
    int mincost = Prim(cost, n, t);

    // Output the total minimum cost of the spanning tree
    printf("Minimum cost of the spanning tree: %d\n", mincost);

    // Output the edges in the minimum spanning tree
    printf("Edges in the minimum spanning tree:\n");
    for (i = 1; i < n; i++) {
        printf("Edge: (%d, %d)\n", t[i][0], t[i][1]);
    }

    return 0;
}
INPUT:
Enter the number of vertices: 5
Enter the cost adjacency matrix:
0 2 3 0 0
2 0 5 6 0
3 5 0 7 8
0 6 7 0 9
0 0 8 9 0
OUTPUT:
Minimum cost of the spanning tree: 21
Edges in the minimum spanning tree:
Edge: (1, 2)
Edge: (2, 3)
Edge: (3, 4)
Edge: (3, 5)

#include <stdio.h>
#include <limits.h>

#define INF INT_MAX

// Function to find the value of k that minimizes the cost in c[i, j]
int Find(double c[][10], int r[][10], int i, int j) {
    int min = INF, k;
    for (int m = r[i][j-1]; m <= r[i+1][j]; m++) {
        int cost = c[i][m-1] + c[m][j];
        if (cost < min) {
            min = cost;
            k = m;
        }
    }
    return k;
}

// Function to compute the optimal binary search tree
void OBST(int n, double p[], double q[], double c[][10], int r[][10], double w[][10]) {
    // Initialize arrays
    for (int i = 0; i <= n; i++) {
        w[i][i] = q[i];
        r[i][i] = 0;
        c[i][i] = 0.0;
    }

    // For trees with 1 node
    for (int i = 0; i < n; i++) {
        w[i][i+1] = q[i] + q[i+1] + p[i+1];
        r[i][i+1] = i+1;
        c[i][i+1] = q[i] + q[i+1] + p[i+1];
    }

    // Calculate cost, root, and weight for larger trees
    for (int m = 2; m <= n; m++) {
        for (int i = 0; i <= n - m; i++) {
            int j = i + m;

            w[i][j] = w[i][j-1] + p[j] + q[j];
            
            // Find the optimal root for the tree [i, j]
            int k = Find(c, r, i, j);
            
            c[i][j] = w[i][j] + c[i][k-1] + c[k][j];
            r[i][j] = k;
        }
    }

    // Output the results for the optimal binary search tree
    printf("Optimal cost: %.2f\n", c[0][n]);
    printf("Optimal root: %d\n", r[0][n]);
    for (int i = 0; i <= n; i++) {
        for (int j = i; j <= n; j++) {
            printf("c[%d][%d] = %.2f, w[%d][%d] = %.2f, r[%d][%d] = %d\n", i, j, c[i][j], i, j, w[i][j], i, j, r[i][j]);
        }
    }
}

int main() {
    int n = 4;  // Number of identifiers (for example: do, if, int, while)
    double p[] = {0, 3, 3, 1, 1};  // Probabilities of searching for the identifiers
    double q[] = {0, 2, 3, 1, 1, 1};  // Probabilities of unsuccessful searches

    double c[10][10] = {0};  // Cost matrix
    int r[10][10] = {0};  // Root matrix
    double w[10][10] = {0};  // Weight matrix

    OBST(n, p, q, c, r, w);

    return 0;
}
********************
  OUPUT

Optimal cost: 32.00
Optimal root: 2
c[0][1] = 8.00, w[0][1] = 8.00, r[0][1] = 1
c[0][2] = 19.00, w[0][2] = 12.00, r[0][2] = 1
c[0][3] = 25.00, w[0][3] = 14.00, r[0][3] = 2
c[0][4] = 32.00, w[0][4] = 16.00, r[0][4] = 2
c[1][2] = 7.00, w[1][2] = 7.00, r[1][2] = 2
c[1][3] = 12.00, w[1][3] = 9.00, r[1][3] = 2
c[1][4] = 19.00, w[1][4] = 11.00, r[1][4] = 2
c[2][3] = 3.00, w[2][3] = 3.00, r[2][3] = 3
c[2][4] = 8.00, w[2][4] = 5.00, r[2][4] = 3
c[3][4] = 3.00, w[3][4] = 3.00, r[3][4] = 4

#include <stdio.h>
#include <limits.h>
#include <stdbool.h>

#define INF INT_MAX

int minDistance(int dist[], bool sptSet[], int n) {
    int min = INF, min_index;
    for (int v = 0; v < n; v++) {
        if (sptSet[v] == false && dist[v] <= min) {
            min = dist[v];
            min_index = v;
        }
    }
    return min_index;
}

void dijkstra(int graph[][5], int dist[], bool sptSet[], int n, int src) {
    for (int i = 0; i < n; i++) {
        dist[i] = INF;
        sptSet[i] = false;
    }
    dist[src] = 0;

    for (int count = 0; count < n - 1; count++) {
        int u = minDistance(dist, sptSet, n);
        sptSet[u] = true;

        for (int v = 0; v < n; v++) {
            if (!sptSet[v] && graph[u][v] && dist[u] != INF && dist[u] + graph[u][v] < dist[v]) {
                dist[v] = dist[u] + graph[u][v];
            }
        }
    }
}

void printSolution(int dist[], int n) {
    printf("Vertex   Distance from Source\n");
    for (int i = 0; i < n; i++) {
        printf("%d \t\t %d\n", i, dist[i]);
    }
}

int main() {
    int graph[5][5] = {
        {0, 10, 0, 0, 0},
        {0, 0, 5, 0, 0},
        {0, 0, 0, 15, 0},
        {0, 0, 0, 0, 20},
        {0, 0, 0, 0, 0}
    };

    int dist[5];
    bool sptSet[5];
    int n = 5;

    dijkstra(graph, dist, sptSet, n, 0);
    printSolution(dist, n);

    return 0;
}

<html>
<head>
<title>teste de extensão</title>
  <style>
  .paratexto {
    background-color: #000000;
    border-radius: 12px;
    font-size: 28px;
    }
  </style>
  <style>
  .textoamarelo {
    color: #FFFF00;
    }
  </style>
  <style>
  body {
    background-color: #00FFFF;
    }
  </style>
</head>
<body>
<center>
 <div class= "para texto">
  <h1 class= "textoamarelo">este é um teste!</h1>
  </div>
</center>
</body>
</html>

//THIS IS SOMEWHAT WRONG ONLY PARTIALLY CORRECT

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

// Define the structure to hold item details (profit, weight, and ratio)
typedef struct {
    int profit;
    int weight;
    float ratio; // profit-to-weight ratio
} Item;

// Comparator function for sorting items by profit-to-weight ratio
int compare(const void *a, const void *b) {
    Item *item1 = (Item *)a;
    Item *item2 = (Item *)b;
    
    // Sort in decreasing order of ratio
    if (item1->ratio < item2->ratio) 
        return 1;
    else if (item1->ratio > item2->ratio) 
        return -1;
    return 0;
}

// Function to solve the fractional knapsack problem
float knapsack(int m, Item items[], int n) {
    // Sort the items in decreasing order of profit-to-weight ratio
    qsort(items, n, sizeof(Item), compare);

    float totalProfit = 0.0; // Total profit earned by including items in the knapsack
    int currentWeight = 0;   // Current weight in the knapsack

    for (int i = 0; i < n; i++) {
        if (currentWeight + items[i].weight <= m) {
            // If the item can be fully added to the knapsack
            currentWeight += items[i].weight;
            totalProfit += items[i].profit;
        } else {
            // Otherwise, take the fractional part of the item
            int remainingWeight = m - currentWeight;
            totalProfit += items[i].profit * ((float)remainingWeight / items[i].weight);
            break;  // Knapsack is full
        }
    }

    return totalProfit;
}

int main() {
    int n, m;

    // Input: number of items and knapsack capacity
    printf("Enter the number of items: ");
    scanf("%d", &n);
    printf("Enter the capacity of the knapsack: ");
    scanf("%d", &m);

    Item items[n];

    // Input: profit and weight of each item
    printf("Enter profit and weight for each item:\n");
    for (int i = 0; i < n; i++) {
        printf("Item %d - Profit: ", i + 1);
        scanf("%d", &items[i].profit);
        printf("Item %d - Weight: ", i + 1);
        scanf("%d", &items[i].weight);

        // Calculate the profit-to-weight ratio for each item
        items[i].ratio = (float)items[i].profit / items[i].weight;
    }

    // Calculate the maximum profit that can be earned
    float maxProfit = knapsack(m, items, n);
    printf("Maximum profit that can be earned: %.2f\n", maxProfit);

    return 0;
}

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

typedef struct {
    int id;      
    int deadline;
    int profit;  
} Job;

int compare(const void* a, const void* b) {
    Job* job1 = (Job*)a;
    Job* job2 = (Job*)b;
    return job2->profit - job1->profit; 

int jobSequence(Job* jobs, int n) {
    qsort(jobs, n, sizeof(Job), compare);
    
    int* jobSequence = (int*)malloc(n * sizeof(int)); 
    int* slot = (int*)malloc(n * sizeof(int)); 
    for (int i = 0; i < n; i++) {
        slot[i] = 0;
    }
    int count = 0; 
    int totalProfit = 0;

    for (int i = 0; i < n; i++) {
        for (int j = jobs[i].deadline - 1; j >= 0; j--) {
            if (slot[j] == 0) {  
                slot[j] = 1;      
                jobSequence[j] = jobs[i].id; 
                totalProfit += jobs[i].profit; 
                count++; 
                break;   
            }
        }
    }
    printf("Scheduled jobs:\n");
    for (int i = 0; i < n; i++) {
        if (slot[i] == 1) {
            printf("Job ID: %d, Profit: %d\n", jobSequence[i], jobs[i].profit);
        }
    }
    printf("Total profit: %d\n", totalProfit);

    free(jobSequence);
    free(slot);
    return count; 
}

int main() {
    int n;
    printf("Enter the number of jobs: ");
    scanf("%d", &n);
    Job* jobs = (Job*)malloc(n * sizeof(Job));
    printf("Enter job ID, deadline, profit for each job:\n");
    for (int i = 0; i < n; i++) {
        scanf("%d %d %d", &jobs[i].id, &jobs[i].deadline, &jobs[i].profit);
    }
    jobSequence(jobs, n);
    free(jobs);
    return 0;
}

import java.util.*;
public class Articulation {
private int n;
private int[][] arr;
private int[] dfn;
private int[] low;
private int num;
private Set<Integer> s;
public Articulation(int n) {
this.n = n;
arr = new int[n][n];
dfn = new int[n];
low = new int[n];
num = 1;
s = new HashSet<>();
}
public void read(Scanner scan) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
arr[i][j] = scan.nextInt();
dfn[i] = 0;
}
}
public void art(int u, int v) {
dfn[u] = num;
low[u] = num;
num++;
int child = 0;
for (int j = 0; j < n; j++) {
if (arr[u][j] == 1 && dfn[j] == 0) {
if (v == -1)
child++;
art(j, u);
if (v != -1 && low[j] >= dfn[u])
s.add(u);
low[u] = Math.min(low[u], low[j]);
} else if (arr[u][j] == 1 && j != v)
low[u] = Math.min(low[u], dfn[j]);
}
if (v == -1 && child > 1)
s.add(u);
}
public void printVisited() {
System.out.println("articulation points" + s);
for (int i = 0; i < n; i++)
System.out.print(dfn[i] - 1 + " ");
System.out.println();
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("enter no of vertices");
int n = scan.nextInt();
Articulation art = new Articulation(n);
System.out.println("adjacent matrix");
art.read(scan);
art.art(0, -1);
System.out.println("vertices");
art.printVisited();
}
}

OUTPUT:
enter no of vertices
5
adjacent matrix
0 1 1 0 0
1 0 1 0 0
1 1 0 1 0
0 0 1 0 1
0 0 0 1 0
vertices
articulation points[2, 3]
0 1 2 3 4 

#include <iostream>
#include <vector>
using namespace std; 
 
int main() { 
    int n; 
    setlocale(LC_ALL, ""); 
    cout <<"Введите количество чисел: ";
    cin >> n;
	std::vector <int> arr(n);
 
    // Ввод чисел в массив 
    cout << "Введите " << n << " чисел:" << endl; 
    for (int i = 0; i < n; ++i) { 
        cin >> arr[i]; 
    } 
 
    // Поиск наибольшего числа  
    int max_value = arr[0];              
 
    for (int i = 1; i < n; ++i) { 
        if (arr[i] > max_value) { 
            max_value = arr[i]; 
        } 
    } 
 
    // Вывод результата 
    cout << "Наибольшее число: " << max_value<< endl; 
 
    return 0;
    
}

#include <iostream> 
using namespace std; 
 
int main() { 
    int n; 
    setlocale(LC_ALL, ""); 
    cout <<"Введите количество чисел: ";
    cin >> n;
    int *arr = new int[n];
 
    // Ввод чисел в массив 
    cout << "Введите " << n << " чисел:" << endl; 
    for (int i = 0; i < n; ++i) { 
        cin >> arr[i]; 
    } 
 
    // Поиск наибольшего числа
    int max_value = arr[0];              
 
    for (int i = 1; i < n; ++i) { 
        if (arr[i] > max_value) { 
            max_value = arr[i]; 
        } 
    } 
 
    // Вывод результата 
    cout << "Наибольшее число: " << max_value<< endl; 
 	delete[] arr;
    return 0;
    
}

#include <stdio.h>

void interchange(int a[], int i, int j) {
    int temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

int partition(int a[], int p, int q) {
    int v = a[p];
    int i = p, j = q + 1;
    
    do {
        do {
            i = i + 1;
        } while (a[i] < v && i <= q);
        
        do {
            j = j - 1;
        } while (a[j] > v && j >= p);
        
        if (i < j) {
            interchange(a, i, j);
        }
    } while (i < j);

    // Swap the pivot with the element at j
    interchange(a, p, j);
    
    return j;
}

void quickSort(int a[], int p, int q) {
    if (p < q) {
        int j = partition(a, p, q);
        quickSort(a, p, j - 1);
        quickSort(a, j + 1, q);
    }
}

int main() {
    int n;
    printf("Enter Size: ");
    scanf("%d", &n);
    
    int a[n];
    
    printf("Enter elements: \n");
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    
    quickSort(a, 0, n - 1);
    
    printf("Sorted Array: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");
    
    return 0;
}

#include <iostream> 
using namespace std; 
 
int main() { 
    int n; 
    setlocale(LC_ALL, ""); 
    cout << "Введите количество чисел (не более 20): "; 
    cin >> n; 
 
    if (n > 20 || n <= 0) { 
        cout << "Некорректное количество чисел. Программа завершена." << endl; 
        return 1; 
    } 
 
    int numbers[20]; 
    // Ввод чисел в массив 
    cout << "Введите " << n << " чисел:" << endl; 
    for (int i = 0; i < n; ++i) { 
        cin >> numbers[i]; 
    } 
 
    // Поиск наибольшего числа и его индекса 
    int max_value = numbers[0];              
 
    for (int i = 1; i < n; ++i) { 
        if (numbers[i] > max_value) { 
            max_value = numbers[i]; 
        } 
    } 
 
    // Вывод результата 
    cout << "Наибольшее число: " << max_value << endl; 
 
    return 0; 

#include <stdio.h>

void merge(int a[], int b[], int low, int mid, int high) {
    int h = low, j = mid + 1, i = low;
    
    while (h <= mid && j <= high) {
        if (a[h] <= a[j]) {
            b[i] = a[h];
            h += 1;
        } else {
            b[i] = a[j];
            j += 1;
        }
        i += 1;
    }
    if (h > mid) {
        for (int k = j; k <= high; k++) {
            b[i] = a[k];
            i += 1;
        }
    } else {
        
        for (int k = h; k <= mid; k++) {
            b[i] = a[k];
            i += 1;
        }
    }
    for (int k = low; k <= high; k++) {
        a[k] = b[k];
    }
}

void mergeSort(int a[], int b[], int low, int high) {
    if (low < high) {
        int mid = (low + high) / 2;
        mergeSort(a, b, low, mid); 
        mergeSort(a, b, mid + 1, high); 
        merge(a, b, low, mid, high); 
    }
}

int main() {
    int n;
    printf("Enter Size: ");
    scanf("%d", &n);

    int a[n], b[n];
    printf("Enter Elements: ");
    for (int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }

    mergeSort(a, b, 0, n - 1);

    printf("Sorted Elements: ");
    for (int i = 0; i < n; i++) {
        printf("%d ", a[i]);
    }
    printf("\n");

    return 0;
}

class RenderUpdatesDraw(RenderClear):
    """call sprite.draw(screen) to render sprites"""
    def draw(self, surface):
        dirty = self.lostsprites
        self.lostsprites = []
        for s, r in self.spritedict.items():
            newrect = s.draw(screen) #Here's the big change
            if r is 0:
                dirty.append(newrect)
            else:
                dirty.append(newrect.union(r))
            self.spritedict[s] = newrect
        return dirty

sudo apt-get install pcscd gnome-screenshot yubikey-manager pamu2fcfg

#make config directory
mkdir -p ~/.config/Yubico

#use yubikey manager to unlock the device
ykman config set-lock-code --generate
#code = d4d2a245932d707c0d1558cb55a16a4d

#Enable Applications on USB
ykman config usb --enable-all

#Connect Security Key
pamu2fcfg > ~/.config/Yubico/u2f_keys

#

import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { ScheduleModule } from '@nestjs/schedule';
import { AccountModule } from './module/account.module';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { OrderModule } from './module/order.module';
// Removed TypeOrmModule and Order entity
import { TypeOrmModule } from '@nestjs/typeorm';
import { CtraderAccountService } from './services/exchange/cTrader/account.service';
import { CtraderBotService } from './services/exchange/cTrader/bot.service';
import { CtraderEvaluationService } from './services/exchange/cTrader/evaluation.service';
import { CtraderOrderService } from './services/exchange/cTrader/order.service';
import { CtraderConnectionService } from './services/exchange/cTrader/connection.service';
import { EvaluationController } from './controllers/evaluation.controller';
import { BotController } from './controllers/bot.controller';
import { BullModule } from '@nestjs/bull';
import { activeBotQueue } from 'config/constant';
import { ExpressAdapter } from '@nestjs/platform-express';
import { CtraderAuthService } from './services/exchange/cTrader/auth.service';
import { AuthController } from './controllers/auth.controller';
import { SpotwareService } from './services/exchange/cTrader/spotware.account.service';
import { AccountController } from './controllers/account.controller';
import { OrderController } from './controllers/order.controller';
import { OrderPollingService } from './services/exchange/cTrader/order.polling.service';
import { EvaluationBotProcess } from './services/botProcess/evaluationBot.process';
import { IOrderPollingService } from './services/Interfaces/IOrderPollingService';
import { DailyEquityModule } from './module/dailyEquity.module';

@Module({
  imports: [ 
    // Load environment variables globally
    ConfigModule.forRoot({
      isGlobal: true,
      envFilePath: '.env', // Consolidated .env file path specification
    }),
    // Removed TypeORM configuration as it's no longer needed
    ScheduleModule.forRoot(),
    AccountModule,
    // BULLMQ
    BullModule.forRoot({
      redis: {
        host: 'localhost',
        port: 6379,
      },
    }),
    BullModule.registerQueue({
      name: activeBotQueue,
      defaultJobOptions: {
        attempts: 2,
      },
    }),
  ],
  controllers: [
    AppController, 
    EvaluationController, 
    BotController, 
    AuthController, 
    AccountController, 
    OrderController,
  ],
  providers: [
    AppService,
    {
      provide: 'IAccountInterface', 
      useClass: process.env.exchange === 'CTRADER' ? CtraderAccountService : CtraderAccountService,
    },
    {
      provide: 'IBotInterface',
      useClass: process.env.exchange === 'CTRADER' ? CtraderBotService : CtraderBotService,
    },
    {
      provide: 'IBotProcessInterface',
      useClass: process.env.botType === 'Evaluation' ? EvaluationBotProcess : EvaluationBotProcess,
    },
    {
      provide: 'IEvaluationInterface',
      useClass: process.env.exchange === 'CTRADER' ? CtraderEvaluationService : CtraderEvaluationService,
    },
    {
      provide: 'IOrderInterface',
      useClass: process.env.exchange === 'CTRADER' ? CtraderOrderService : CtraderOrderService,
    },
    {
      provide: 'IConnectionInterface',
      useClass: process.env.exchange === 'CTRADER' ? CtraderConnectionService : CtraderConnectionService,
    },
    {
      provide: 'IAuthInterface',
      useClass: process.env.exchange === 'CTRADER' ? CtraderAuthService : CtraderAuthService,
    },
    {
      provide: 'IOrderPollingService',  // Added IOrderPollingService provider
      useClass:process.env.exchange === 'CTRADER' ? OrderPollingService : OrderPollingService,
    },
    SpotwareService, 
    OrderPollingService, // Explicitly added OrderPollingService in providers
    ConfigService,
  ],
})
export class AppModule {}

if (LedgerJournalTrans.AccountType == LedgerJournalACType::Cust)
{
custAccount = DimensionStorage::ledgerDimension2AccountNum(LedgerJournalTrans.LedgerDimension);
}

DimensionAttributeValueCombination::getMainAccountFromLedgerDimension(generalJournalAccountEntry.LedgerDimension);

// Sample string that represents a combination of small, medium, and large code points.
// This sample string is valid UTF-16.
// 'hello' has code points that are each below 128.
// '⛳' is a single 16-bit code units.
// '❤️' is a two 16-bit code units, U+2764 and U+FE0F (a heart and a variant).
// '🧀' is a 32-bit code point (U+1F9C0), which can also be represented as the surrogate pair of two 16-bit code units '\ud83e\uddc0'.
const validUTF16String = 'hello⛳❤️🧀';

// This will not work. It will print:
// DOMException: Failed to execute 'btoa' on 'Window': The string to be encoded contains characters outside of the Latin1 range.
try {
  const validUTF16StringEncoded = btoa(validUTF16String);
  console.log(`Encoded string: [${validUTF16StringEncoded}]`);
} catch (error) {
  console.log(error);
}

var docWidth = document.documentElement.offsetWidth;

[].forEach.call(
	document.querySelectorAll('*'),
	function (el) {
		if (el.offsetWidth > docWidth) {
			console.log(el);
		}
	}
);

#include<stdio.h>
int main(){
    // Author : Khadiza Sultana
    int n = 4;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < (i + 1); j++)
        printf("* ");
        for(int j = 0; j < 2 * (n - i - 1); j++)
        printf("  ");
        for(int j = 0; j < (i + 1); j++)
        printf("* ");
        printf("\n");
    }
    for(int i = 0; i < n; i++){
        for(int j = n; j > i; j--)
        printf("* ");
        for(int j = 0; j < 2 * i; j++)
        printf("  ");
        for(int j = n; j > i; j--)
        printf("* ");
        printf("\n");
    }
    return 0;
}

ACF KEY
b3JkZXJfaWQ9Njg2MDJ8dHlwZT1wZXJzb25hbHxkYXRlPTIwMTUtMTEtMTEgMTM6MzU6NDk=

function enqueue_bootstrap_for_elementor() {
    // Bootstrap CSS
    wp_enqueue_style('bootstrap-css', 'https://maxcdn.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css');
    
    // Bootstrap JS (ensure jQuery is loaded as a dependency)
    wp_enqueue_script('bootstrap-js', 'https://maxcdn.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js', array('jquery'), null, true);
}

// Use Elementor hook to enqueue files only when Elementor is used
add_action('elementor/frontend/after_enqueue_scripts', 'enqueue_bootstrap_for_elementor');



//Services Post Type
add_action('init', 'services_post_type_init');
function services_post_type_init()
{

    $labels = array(

        'name' => __('Services', 'post type general name', ''),
        'singular_name' => __('Services', 'post type singular name', ''),
        'add_new' => __('Add New', 'Services', ''),
        'add_new_item' => __('Add New Services', ''),
        'edit_item' => __('Edit Services', ''),
        'new_item' => __('New Services', ''),
        'view_item' => __('View Services', ''),
        'search_items' => __('Search Services', ''),
        'not_found' =>  __('No Services found', ''),
        'not_found_in_trash' => __('No Services found in Trash', ''),
        'parent_item_colon' => ''
    );
    $args = array(
        'labels' => $labels,
        'public' => true,
        'publicly_queryable' => true,
        'show_ui' => true,
        'rewrite' => true,
        'query_var' => true,
        'menu_icon' => get_stylesheet_directory_uri() . '/images/testimonials.png',
        'capability_type' => 'post',
        'hierarchical' => true,
        'public' => true,
        'has_archive' => true,
        'show_in_nav_menus' => true,
        'menu_position' => null,
        'rewrite' => array(
            'slug' => 'services',
            'with_front' => true
        ),
        'supports' => array(
            'title',
            'editor',
            'thumbnail'
        )
    );

    register_post_type('services', $args);
}


// Add Shortcode [our_services];
add_shortcode('our_services', 'codex_our_services');
function codex_our_services()
{
    ob_start();
    wp_reset_postdata();
?>

 
        <div class="row ser-content">
            <?php
            $arg = array(
                'post_type' => 'services',
                'posts_per_page' => -1,
            );
            $po = new WP_Query($arg);
            ?>
            <?php if ($po->have_posts()) : ?>

                <?php while ($po->have_posts()) : ?>
                    <?php $po->the_post(); ?>
                    <div class="col-md-4">
                        <div class="ser-body">
                                <div class="thumbnail-blog">
                                    <?php echo get_the_post_thumbnail(get_the_ID(), 'full'); ?>
                                </div>
                                <div class="content">
                                    <h3 class="title"><?php the_title(); ?></h3>
                                  <div><?php echo wp_trim_words(get_the_content(), 15, '...'); ?></div>
                                </div>
                              <div class="readmore">
                                <a href="<?php echo get_permalink() ?>">Read More</a>
                            </div>
                        </div>
                    </div>
                <?php endwhile; ?>

            <?php endif; ?>
        </div>


<?php
    wp_reset_postdata();
    return '' . ob_get_clean();
}

function enqueue_bootstrap_for_elementor() {
    // Bootstrap CSS
    wp_enqueue_style('bootstrap-css', 'https://maxcdn.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css');
    
    // Bootstrap JS (ensure jQuery is loaded as a dependency)
    wp_enqueue_script('bootstrap-js', 'https://maxcdn.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrap.min.js', array('jquery'), null, true);
}

// Use Elementor hook to enqueue files only when Elementor is used
add_action('elementor/frontend/after_enqueue_scripts', 'enqueue_bootstrap_for_elementor');

public class point{
    float x;
    float y;
    
    public point(float x,float y){
        this.x=x;
        this.y=y;
    }
    void afficher(){
        System.out.println("point("+x+","+y+")");
    }
    void deplacer(float a,float b){
        x=a;
        y=b;
    }
    float getAbscisse(){
        return this.x;
    }
    float getOrdonne(){
        return this.y;
    }
    public String toString(){
       String ch;
       ch="le point est "+ this.x +"\t"+this.y;
       return ch;
    }
    public Boolean equals(point po){
        return po!= null && po.equals(this.x) && po.equals(this.y);}
    public static void main (String []  args){
    point p=new point(19,4);
    p.afficher();
    System.out.println(p);
    p.deplacer(6,8);
    p.afficher();
    point p2=new point(6,8.0f);
    point p3=new point(4.0f, 2.0f);
    System.out.println("p est egal a p2:"+p.equals(p2));
    System.out.println("p est egal a p3:"+p.equals(p3));

   
            }
}

// HTML: make a parent div with a class of "wrap" and inside of it make 300 children div's with the class of "c"; best in chrome;

$total: 00; // total particles
3
$orb-size: 0px;

$particle-size: 2px;

$time: s; 

$base-hue: 0; // change for diff colors (10 is nice)

​
8
html, body {

  height: 100%;
10
}

​

body {

  background: black;
14
  overflow: hidden; // no scrollbars.. 

}

​

.wrap {

  position: relative;

  top: 50%;

  left: 50%;

  width: 0; 

  height: 0; 

  transform-style: preserve-3d;

  perspective: 1000px;

class compte{
    private double solde;
    public compte(float solde){
        this.solde=solde;
    }
    public double getSolde(){
        return solde;
    }
    void retirer(double ret){
        if(ret>solde){
        System.out.println("fonds insuffisants pour retirer"+ret+"d.");
        }else{
            solde-=ret;
            System.out.println("Retrait de"+ret+"deffectue.");
        }
    }
    void deposer(double dep){
        this.solde+=dep;
    }
    void transfer(compte c2,int nb){
        if(nb>solde){
        System.out.println("Fond insuffisants pour transfere"+nb+"d.");
        }else{
            retirer(nb);
            c2.deposer(nb);
        }
    }
    public static void  main (String[] args){
        compte c1=new compte(500);
        compte c2=new compte(0);
        c1.retirer(100);
        c1.deposer(200);
        c1.transfer(c2,300);
        System.out.println("compte 1="+c1.getSolde());
        System.out.println ("compte 2="+c2.getSolde());

    }
}

#include <stdio.h>

int main()
{
   int i, x;
   char str[100];

   printf("\nPlease enter a string:\t");
   gets(str);

   printf("\nPlease choose following options:\n");
   printf("1 = Encrypt the string.\n");
   printf("2 = Decrypt the string.\n");
   scanf("%d", &x);

   //using switch case statements
   switch(x)
   {
case 1:
      for(i = 0; (i < 100 && str[i] != '\0'); i++)
        str[i] = str[i] + 3; //the key for encryption is 3 that is added to ASCII value

      printf("\nEncrypted string: %s\n", str);
      break;

   case 2:
      for(i = 0; (i < 100 && str[i] != '\0'); i++)
        str[i] = str[i] - 3; //the key for encryption is 3 that is subtracted to ASCII value

      printf("\nDecrypted string: %s\n", str);
      break;

   default:
      printf("\nError\n");
   }
   return 0;
}

#include<stdio.h>
int dist[50][50],temp[50][50],n,i,j,k,x;
void dvr();
int main()
{
    printf("\nEnter the number of nodes : ");
    scanf("%d",&n);
    printf("\nEnter the distance matrix :\n");
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {   
            scanf("%d",&dist[i][j]);
            dist[i][i]=0;
            temp[i][j]=j;
        }
        printf("\n");
	}
     dvr(); 
     printf("enter value of i &j:");
     scanf("%d",&i);
	 scanf("%d",&j);   
	 printf("enter the new cost");
	 scanf("%d",&x);   
	 dist[i][j]=x;
	 printf("After update\n\n");	 	  
     dvr();
	 return 0; 
}
void dvr()
{
	for (i = 0; i < n; i++)
            for (j = 0; j < n; j++)
            	for (k = 0; k < n; k++)
                	if (dist[i][k] + dist[k][j] < dist[i][j])
                	{
                    	dist[i][j] = dist[i][k] + dist[k][j];
                    	temp[i][j] = k;
               		}
               		
	for(i=0;i<n;i++)
        {
            printf("\n\nState value for router %d is \n",i+1);
            for(j=0;j<n;j++)
                printf("\t\nnode %d via %d Distance%d",j+1,temp[i][j]+1,dist[i][j]);
        }   
    printf("\n\n");

}
 

#include<stdio.h>
int p,q,u,v,n;
int min=99,mincost=0
int t[50][2],i,j;
int parent[50],edge[50][50];
main()
{
clrscr();
printf("\n Enter the number of nodes");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("%c\t",65+i);
parent[i]=-1
}
printf("\n");
for(i=0;i<n;i++)
{
printf("%c",65+i);
for(j=0;j<n;j++)
scanf("%d",&edge[i][j]);
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
if(edge[i][j]!=99)
if(min>edge[i][j])
{

min=edge[i][j]
u=i;
v=j;
}
p=find(u);
q=find(v);
if(p!=q)
{
t[i][0]=u;
t[i][1]=v;
mincost=mincost+edge[u][v];
sunion(p,q);
}
else
t[i][0]=-1;
t[i][1]=-1;
}
min=99;
}
printf("Minimum cost is %d \n Minimum spanning tree is \n",mincost);
for(i=0;i<n;i++)
if(t[i][0]!=-1 && t[i][1]!=-1)
{
printf("%c %c %d",65+t[i][0],65+t[i][1],edge[t[i][0]] [t[i][1]])
  
printf("\n");
}
getch();
}
sunion(int I,int m)
{
parent[]=m;
}
find(int I)
{
if(parent[I]>0)
I=parent[I];
return I;
}

 #include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#define V 9

int minDistance(int dist[], bool sptSet[])
{
    // Initialize min value
    int min = INT_MAX, min_index;

    for (int i = 0; i < V; i++)
        if (sptSet[i] == false && dist[i] <= min)
            min = dist[i], min_index = i;

    return min_index;
}
void printSolution(int dist[])
{
    printf("Vertex \t\t Distance from Source\n");
    for (int i = 0; i < V; i++)
        printf("%d \t\t\t\t %d\n", i, dist[i]);
}
void dijkstra(int graph[V][V], int src)
{
    int dist[V]; 

    bool sptSet[V]; 
    for (int i = 0; i < V; i++)
        dist[i] = INT_MAX, sptSet[i] = false;

    dist[src] = 0;
    for (int count = 0; count < V - 1; count++) {
        int u = minDistance(dist, sptSet);
        sptSet[u] = true;
        for (int v = 0; v < V; v++)
            if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v])
                dist[v] = dist[u] + graph[u][v];
    }
    printSolution(dist);
}

int main()
{

    int graph[V][V] = { { 0, 4, 0, 0, 0, 0, 0, 8, 0 },
                        { 4, 0, 8, 0, 0, 0, 0, 11, 0 },
                        { 0, 8, 0, 7, 0, 4, 0, 0, 2 },
                        { 0, 0, 7, 0, 9, 14, 0, 0, 0 },
                        { 0, 0, 0, 9, 0, 10, 0, 0, 0 },
                        { 0, 0, 4, 14, 10, 0, 2, 0, 0 },
                        { 0, 0, 0, 0, 0, 2, 0, 1, 6 },
                        { 8, 11, 0, 0, 0, 0, 1, 0, 7 },
                        { 0, 0, 2, 0, 0, 0, 6, 7, 0 } };
    dijkstra(graph, 0);

    return 0;
}