from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
 
# Load the Iris dataset
data = load_iris()
X = data.data  # Features
 
# Initialize the KMeans model with 3 clusters (since there are 3 species in the Iris dataset)
kmeans = KMeans(n_clusters=3, random_state=42)
 
# Fit the model to the data
kmeans.fit(X)
 
# Predict the cluster labels
y_pred = kmeans.predict(X)
 
# Create a DataFrame for visualization
df = pd.DataFrame(X, columns=data.feature_names)
df['Cluster'] = y_pred
 
# Plot the clusters (using only the first two features for simplicity)
plt.figure(figsize=(8, 6))
sns.scatterplot(data=df, x=data.feature_names[0], y=data.feature_names[1], hue='Cluster')#, palette='viridis', s=100)
plt.title('K-Means Clustering on Iris Dataset (2D)')
plt.xlabel(data.feature_names[0])
plt.ylabel(data.feature_names[1])
plt.show()
 
# Print the cluster centers
print("Cluster Centers (Centroids):")
print(kmeans.cluster_centers_)

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, confusion_matrix,classification_report

# Step 1: Load Iris dataset
file_path = "/content/iris.csv"  # Replace with the actual file path
iris_data = pd.read_csv(file_path)

# Separate features (X) and target (y)
X = iris_data.drop(["Species"], axis=1)  # Drop unnecessary columns
y = iris_data["Species"]

# Step 2: Split the dataset
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Step 3: Apply StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.fit_transform(X_test)

# Step 4: Load KNN model
knn = KNeighborsClassifier(n_neighbors=5)  # Default k=5

# Step 5: Train the model and make predictions
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)

# Step 6: Evaluate the model
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
classification_report=classification_report(y_test,y_pred)

# Display results
print("Accuracy Score:", accuracy)
print("Confusion Matrix:\n", conf_matrix)
print("Confusion Matrix:\n", classification_report)

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

    static boolean flag = false;

    static void printSubsetSum(int i, int n, int[] set, int targetSum, List<Integer> subset) {
        if (targetSum == 0) {
            flag = true;
            System.out.print("[ ");
            for (int j = 0; j < subset.size(); j++) {
                System.out.print(subset.get(j) + " ");
            }
            System.out.print("]");
            return;
        }

        if (i == n) {
            return;
        }

        printSubsetSum(i + 1, n, set, targetSum, subset);   

        if (set[i] <= targetSum) {
            subset.add(set[i]);
            printSubsetSum(i + 1, n, set, targetSum - set[i], subset);
            subset.remove(subset.size() - 1);
        }
    }

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

        System.out.print("Enter the number of elements in the set: ");
        int n = sc.nextInt();

        int[] set = new int[n];
        System.out.println("Enter the elements of the set:");
        for (int i = 0; i < n; i++) {
            set[i] = sc.nextInt();
        }

        System.out.print("Enter the target sum: ");
        int targetSum = sc.nextInt();

        List<Integer> subset = new ArrayList<>();
        System.out.println("Subsets with the given sum:");
        printSubsetSum(0, n, set, targetSum, subset);

        if (!flag) {
            System.out.println("No subset with the given sum exists.");
        }
    }
}

import java.sql.*;

public class ScrollableResultSetExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/your_database";
        String username = "root"; 
        String password = "your_password";

        try {
            Connection connection = DriverManager.getConnection(url, username, password);

            String query = "SELECT * FROM your_table";
            Statement statement = connection.createStatement(
                    ResultSet.TYPE_SCROLL_INSENSITIVE, 
                    ResultSet.CONCUR_READ_ONLY);
            
            ResultSet resultSet = statement.executeQuery(query);
            
            if (resultSet.last()) {
                System.out.println(resultSet.getString("column_name"));
            }

            if (resultSet.first()) {
                System.out.println(resultSet.getString("column_name"));
            }

            resultSet.close();
            statement.close();
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

import java.util.*;

public class SumOfSubsets {

    // Function to find all subsets whose sum equals the target sum
    public static void findSubsets(int[] set, int n, int targetSum) {
        List<Integer> currentSubset = new ArrayList<>();
        backtrack(set, n, targetSum, 0, currentSubset);
    }

    // Backtracking function to find the subsets
    private static void backtrack(int[] set, int n, int targetSum, int index, List<Integer> currentSubset) {
        // Base case: if we've considered all elements
        if (index == n) {
            int sum = 0;
            for (int num : currentSubset) {
                sum += num;
            }

            // If the sum of the current subset equals the target, print it
            if (sum == targetSum) {
                System.out.println(currentSubset);
            }
            return;
        }

        // Include the current element
        currentSubset.add(set[index]);
        // Recur with the element included
        backtrack(set, n, targetSum, index + 1, currentSubset);

        // Exclude the current element
        currentSubset.remove(currentSubset.size() - 1);
        // Recur with the element excluded
        backtrack(set, n, targetSum, index + 1, currentSubset);
    }

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

        // Input the number of elements in the set and the target sum
        System.out.print("Enter the number of elements in the set: ");
        int n = scanner.nextInt();

        int[] set = new int[n];
        
        System.out.println("Enter the elements of the set: ");
        for (int i = 0; i < n; i++) {
            set[i] = scanner.nextInt();
        }

        System.out.print("Enter the target sum: ");
        int targetSum = scanner.nextInt();

        // Find and print the subsets whose sum equals the target sum
        System.out.println("Subsets whose sum equals " + targetSum + ":");
        findSubsets(set, n, targetSum);

        scanner.close();
    }
}

import java.io.*;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.parsers.SAXParser;
import org.xml.sax.helpers.DefaultHandler;

public class XMLValidation {
    public static void main(String[] args) {
        try {
            // Prompt user for XML file name
            System.out.println("Enter the XML file name:");
            String filename = new BufferedReader(new InputStreamReader(System.in)).readLine();
            File file = new File(filename);

            // Check if the file exists
            if (file.exists()) {
                validateXML(file);
            } else {
                System.out.println("File not found.");
            }
        } catch (IOException e) {
            System.out.println("Error reading input: " + e.getMessage());
        }
    }

    private static void validateXML(File file) {
        try {
            // Initialize the SAX parser
            SAXParserFactory.newInstance().newSAXParser().parse(file, new DefaultHandler());
            System.out.println(file.getName() + " is valid XML.");
        } catch (Exception e) {
            System.out.println(file.getName() + " is not valid XML.");
        }
    }
}


hello.xml
<?xml version="1.0" encoding="UTF-8"?>
<library>
    <book>
        <title>Java Programming</title>
        <author>John Doe</author>
    </book>
    <book>
        <title>XML Development</title>
        <author>Jane Smith</author>
    </book>
</library>

import java.util.Scanner;
 
class PrimsAlgorithm {
    private static int V;
 
    int minKey(int key[], boolean mstSet[]) {
        int min = Integer.MAX_VALUE, minIndex = -1;
        for (int v = 0; v < V; v++) {
            if (!mstSet[v] && key[v] < min) {
                min = key[v];
                minIndex = v;
            }
        }
        return minIndex;
    }
 
    void printMST(int parent[], int graph[][]) {
        int totalCost = 0;
        System.out.println("Edge \tWeight");
        for (int i = 1; i < V; i++) {
            System.out.println(parent[i] + " - " + i + "\t" + graph[i][parent[i]]);
            totalCost += graph[i][parent[i]];
        }
        System.out.println("Total cost of the MST: " + totalCost);
    }
 
    void primMST(int graph[][]) {
        int parent[] = new int[V];
        int key[] = new int[V];
        boolean mstSet[] = new boolean[V];
 
        for (int i = 0; i < V; i++) {
            key[i] = Integer.MAX_VALUE;
            mstSet[i] = false;
        }
 
        key[0] = 0;
        parent[0] = -1;
 
        for (int count = 0; count < V - 1; count++) {
            int u = minKey(key, mstSet);
            mstSet[u] = true;
 
            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];
                }
            }
        }
 
        printMST(parent, graph);
    }
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
 
        System.out.print("Enter the number of vertices: ");
        V = scanner.nextInt();
 
        int[][] graph = new int[V][V];
 
        System.out.println("Enter the adjacency matrix (enter 0 if there is no edge between two vertices):");
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                graph[i][j] = scanner.nextInt();
            }
        }
 
        PrimsAlgorithm t = new PrimsAlgorithm();
        t.primMST(graph);
 
        scanner.close();
    }
}
/*2 0 6 0
2 0 3 8 5
0 3 0 0 7
6 8 0 0 9
0 5 7 9 0
Edge 	Weight
0 - 1	2
1 - 2	3
0 - 3	6
1 - 4	5
Total cost of the MST: 16

public class QuickSort {

    // Function to perform quick sort
    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            // Find the pivot element such that elements smaller than pivot are on the left
            // and elements greater than pivot are on the right
            int pivotIndex = partition(array, low, high);
            
            // Recursively sort the elements on the left of the pivot
            quickSort(array, low, pivotIndex - 1);
            
            // Recursively sort the elements on the right of the pivot
            quickSort(array, pivotIndex + 1, high);
        }
    }

    // Partition the array and return the pivot index
    public static int partition(int[] array, int low, int high) {
        int pivot = array[high]; // Choosing the pivot element
        int i = (low - 1);       // Index of the smaller element

        for (int j = low; j < high; j++) {
            // If the current element is smaller than or equal to the pivot
            if (array[j] <= pivot) {
                i++;
                // Swap array[i] and array[j]
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }

        // Swap array[i + 1] and array[high] (or pivot)
        int temp = array[i + 1];
        array[i + 1] = array[high];
        array[high] = temp;

        return i + 1;
    }

    public static void main(String[] args) {
        int[] array = { 10, 7, 8, 9, 1, 5 };
        int n = array.length;

        quickSort(array, 0, n - 1);

        System.out.println("Sorted array:");
        for (int value : array) {
            System.out.print(value + " ");
        }
    }
}

import java.util.Scanner;
 
public class SumOfSubsets {
 
    static void sumOfSub(int[] weights, int[] x, int s, int k, int r, int m) {
    // Include the current element
    x[k] = 1;
    if (s + weights[k] == m) {
        // If the sum matches the target, print the solution vector
        printSolutionVector(x, k);
    } 
    // Check if including the current element and the next one keeps the sum within bounds
    else if (k + 1 < weights.length && s + weights[k] + weights[k + 1] <= m) {
        sumOfSub(weights, x, s + weights[k], k + 1, r - weights[k], m);
    }

    // Exclude the current element and check if further exploration is valid
    if ((s + r - weights[k] >= m) && (k + 1 < weights.length && s + weights[k + 1] <= m)) {
        x[k] = 0;
        sumOfSub(weights, x, s, k + 1, r - weights[k], m);
    }
}

 
    static void printSolutionVector(int[] x, int k) {
        System.out.print("Solution Vector: ");
        for (int i = 0; i <=k; i++) {
            System.out.print(x[i] + " ");
        }
        System.out.println();
    }
 
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
 
        System.out.print("Enter the number of elements in the set: ");
        int n = scanner.nextInt();
 
        int[] weights = new int[n];
 
        System.out.println("Enter the elements of the set (in non-decreasing order): ");
        for (int i = 0; i < n; i++) {
            weights[i] = scanner.nextInt();
        }
 
        System.out.print("Enter the target sum (m): ");
        int m = scanner.nextInt();
 
        int[] x = new int[n];
        int r = 0;
        for (int weight : weights) {
            r += weight;
        }
 
        System.out.println("Solution Vectors with sum " + m + ":");
        sumOfSub(weights, x, 0, 0, r, m);
 
        scanner.close();
    }
}

import java.util.Scanner;

public class OptimalBSTUserInput {

    // Function to construct and return the cost of the optimal BST
    public static int optimalBST(int[] keys, int[] freq, int n) {
        int[][] cost = new int[n][n];

        // Base case: cost when the tree contains only one key
        for (int i = 0; i < n; i++) {
            cost[i][i] = freq[i];
        }

        // Compute the cost for chains of length 2 to n
        for (int length = 2; length <= n; length++) {
            for (int i = 0; i <= n - length; i++) {
                int j = i + length - 1;
                cost[i][j] = Integer.MAX_VALUE;

                // Try making each key in keys[i...j] the root
                for (int r = i; r <= j; r++) {
                    int leftCost = (r > i) ? cost[i][r - 1] : 0;
                    int rightCost = (r < j) ? cost[r + 1][j] : 0;
                    int rootCost = leftCost + rightCost + sum(freq, i, j);

                    if (rootCost < cost[i][j]) {
                        cost[i][j] = rootCost;
                    }
                }
            }
        }
        return cost[0][n - 1];
    }

    // Utility function to calculate the sum of frequencies from i to j
    private static int sum(int[] freq, int i, int j) {
        int total = 0;
        for (int k = i; k <= j; k++) {
            total += freq[k];
        }
        return total;
    }

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

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

        // Input keys
        int[] keys = new int[n];
        System.out.println("Enter the keys in sorted order:");
        for (int i = 0; i < n; i++) {
            keys[i] = scanner.nextInt();
        }

        // Input frequencies
        int[] freq = new int[n];
        System.out.println("Enter the frequencies of the keys:");
        for (int i = 0; i < n; i++) {
            freq[i] = scanner.nextInt();
        }

        // Calculate and print the cost of the optimal BST
        int cost = optimalBST(keys, freq, n);
        System.out.println("Cost of Optimal BST: " + cost);

        scanner.close();
    }
}

import java.util.Scanner;

public class SumOfSubsets {

    static void sumOfSub(int[] weights, int[] x, int s, int k, int r, int m) {
        x[k] = 1;
        if (s + weights[k] == m) {
            printSolutionVector(x, k);
        } else if (s + weights[k] + (k + 1 < weights.length ? weights[k + 1] : 0) <= m) {
            sumOfSub(weights, x, s + weights[k], k + 1, r - weights[k], m);
        }

        if ((s + r - weights[k] >= m) && (s + (k + 1 < weights.length ? weights[k + 1] : 0) <= m)) {
            x[k] = 0;
            sumOfSub(weights, x, s, k + 1, r - weights[k], m);
        }
    }

    static void printSolutionVector(int[] x, int k) {
        System.out.print("Solution Vector: ");
        for (int i = 0; i <= k; i++) {
            System.out.print(x[i] + " ");
        }
        System.out.println();
    }

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

        System.out.print("Enter the number of elements in the set: ");
        int n = scanner.nextInt();

        int[] weights = new int[n];

        System.out.println("Enter the elements of the set (in non-decreasing order): ");
        for (int i = 0; i < n; i++) {
            weights[i] = scanner.nextInt();
        }

        System.out.print("Enter the target sum (m): ");
        int m = scanner.nextInt();

        int[] x = new int[n];
        int r = 0;
        for (int weight : weights) {
            r += weight;
        }

        System.out.println("Solution Vectors with sum " + m + ":");
        sumOfSub(weights, x, 0, 0, r, m);

        scanner.close();
    }
}







SumOfSub(s, k, r)
{
    // Generate left child
    x[k] = 1
    if (s + w[k] == m) then
        write(x[1 : k]) // Subset found
    else if (s + w[k] + w[k + 1] <= m) then
        SumOfSub(s + w[k], k + 1, r - w[k])
 
    // Generate right child and evaluate conditions
    if ((s + r - w[k] >= m) and (s + w[k + 1] <= m)) then
    {
        x[k] = 0
        SumOfSub(s, k + 1, r - w[k])
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Enemy : MonoBehaviour
{   
    public float speed;
    public Vector3 moveOffset;
    private Vector3 targetPos;
    private Vector3 startPos;

    // Start is called before the first frame update
    void Start()
    {
        startPos = transform.position;
        targetPos = startPos;
    }

    // Update is called once per frame
    void Update()
    {
        transform.position = Vector3.MoveTowards(transform.position, targetPos, speed * Time.deltaTime);

        if(transform.position == targetPos)
        {
            if(targetPos == startPos)
            {
                targetPos = startPos + moveOffset;
            }
            else
            {
                targetPos = startPos;
            }
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class CameraFollow : MonoBehaviour
{   
    public Transform target;
    public Vector3 offset;
    // Update is called once per frame
    void Update()
    {
        transform.position = target.position + offset;
    }
}

[ {
    "$match" : {
      "startDate" : {
        "$gte" : {
          "$date" : "2024-09-10T07:14:37.02Z"
        },
        "$lte" : {
          "$date" : "2024-10-10T07:14:37.02Z"
        }
      }
    }
  }, {
    "$lookup" : {
      "from" : "participant",
      "localField" : "userId",
      "foreignField" : "_id",
      "as" : "participantData"
    }
  }, {
    "$unwind" : "$participantData"
  }, {
    "$match" : {
      "participantData.userStatus" : {
        "$ne" : "TEST"
      }
    }
  }, {
    "$match" : {
      "$and" : [ {
        "participantData.email" : {
          "$not" : {
            "$regularExpression" : {
              "pattern" : "deleted",
              "options" : ""
            }
          }
        }
      }, {
        "participantData.email" : {
          "$not" : {
            "$regularExpression" : {
              "pattern" : "@smit\\.fit$",
              "options" : ""
            }
          }
        }
      } ]
    }
  }, {
    "$lookup" : {
      "from" : "participantBaselineAndFollowupData",
      "localField" : "userId",
      "foreignField" : "participantId",
      "as" : "baselineData"
    }
  }, {
    "$unwind" : "$baselineData"
  }, {
    "$project" : {
      "subscriptionId" : "$_id",
      "programEndDate" : "$endDate",
      "baselineId" : "$baselineData._id",
      "userId" : 1,
      "startDate" : 1,
      "programStartDate" : "$baselineData.programStartDate",
      "planCode1" : "$subscriptionPlan.programCode",
      "journeyStatus" : "$journeyTrackerObject.status",
      "planCode2" : "$baselineData.programCode",
      "followUps" : "$baselineData.followUps"
    }
  }, {
    "$match" : {
      "$and" : [ {
        "$expr" : {
          "$and" : [ {
            "$eq" : [ "$planCode1", "$planCode2" ]
          }, {
            "$eq" : [ "$startDate", "$programStartDate" ]
          } ]
        }
      } ]
    }
  }, {
    "$group" : {
      "_id" : {
        "userId" : "$userId",
        "startDate" : "$startDate",
        "planCode1" : "$planCode1"
      },
      "programEndDate" : {
        "$last" : "$programEndDate"
      },
      "userId" : {
        "$last" : "$userId"
      },
      "baselineId" : {
        "$last" : "$baselineId"
      },
      "programStartDate" : {
        "$last" : "$programStartDate"
      },
      "subscriptionId" : {
        "$last" : "$subscriptionId"
      },
      "journeyStatus" : {
        "$last" : "$journeyStatus"
      },
      "followUps" : {
        "$last" : "$followUps"
      }
    }
  } ]

import re

def extract_nf_data(text,pattern):
  match = re.search(pattern, text)
  if match:
    return match.groups()
  else:
    return 'not found'

text = _json.message_body
pattern_keys = r"ccm=(\d+)&nf=(\d+)&cod=([\w\d]+)"
pattern_provider=r"Razão Social: (.*)\n"

ccm,nf,cod=extract_nf_data(text,pattern_keys)
provider=extract_nf_data(text,pattern_provider)[0]

response = {'ccm':ccm,'nf':nf,'cod':cod,'provider':provider}

return response

function delayPromise(ms) {
  return new Promise(
    (resolve) => setTimeout(resolve, ms)
  );
}

$ sudo tar -zxvf ftusbnet-*.tar.gz -C /opt

invoke-command -ComputerName Server1 -ScriptBlock {$MyProgs = Get-ItemProperty 'HKLM:SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\*'; $MyProgs += Get-ItemProperty 'HKLM:SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*' ; $MyProgs.DisplayName | sort -Unique

$Directory = 'D:\Users\Public\Public.Language\Pronounce it Perfectly in Spanish 2e\Pronounce it Perfectly in Spanish 2e.Down.Load'
$Shell = New-Object -ComObject Shell.Application
$Folder = $Shell.Namespace($Directory)

1..512 | ForEach-Object {
    $prop = $Folder.GetDetailsOf($null, $_)
                
    if($prop){
        [PSCustomObject] @{
            Number   = $_
            Property = $prop
        }
    }
}

$MediaFiles = '*.mp3', '*.wav', '*.wma'
$Directory = 'D:\Users\Public\Public.Language\Pronounce it Perfectly in Spanish 2e\Pronounce it Perfectly in Spanish 2e.Down.Load'

$Shell = New-Object -ComObject Shell.Application

foreach($type in $MediaFiles){
    $sample = Get-ChildItem -Path $Directory -Recurse -Include $type | Select-Object -First 1
    
    if($sample){
        $sample | ForEach-Object {
            $Folder = $Shell.Namespace($_.DirectoryName)
            $File = $Folder.ParseName($_.Name)

            1..512 | ForEach-Object {
                $value = $Folder.GetDetailsOf($file, $_)
                
                if($value){
                    [PSCustomObject] @{
                        File     = $sample.FullName
                        Number   = $_
                        Property = $Folder.GetDetailsOf($null, $_)
                        Value    = $value
                    }
                }
            }
        }
    }
}

public class MergeSort {

    // Function to perform merge sort
    public static void mergeSort(int[] array, int left, int right) {
        if (left < right) {
            // Find the middle point to divide the array into two halves
            int middle = (left + right) / 2;

            // Recursively sort the first and second halves
            mergeSort(array, left, middle);
            mergeSort(array, middle + 1, right);

            // Merge the sorted halves
            merge(array, left, middle, right);
        }
    }

    // Function to merge two halves
    public static void merge(int[] array, int left, int middle, int right) {
        // Sizes of the two subarrays to merge
        int n1 = middle - left + 1;
        int n2 = right - middle;

        // Temporary arrays
        int[] leftArray = new int[n1];
        int[] rightArray = new int[n2];

        // Copy data to temporary arrays
        for (int i = 0; i < n1; i++)
            leftArray[i] = array[left + i];
        for (int j = 0; j < n2; j++)
            rightArray[j] = array[middle + 1 + j];

        // Initial indexes of the subarrays
        int i = 0, j = 0;
        int k = left; // Initial index of merged subarray

        // Merge the temp arrays back into the original array
        while (i < n1 && j < n2) {
            if (leftArray[i] <= rightArray[j]) {
                array[k] = leftArray[i];
                i++;
            } else {
                array[k] = rightArray[j];
                j++;
            }
            k++;
        }

        // Copy remaining elements of leftArray, if any
        while (i < n1) {
            array[k] = leftArray[i];
            i++;
            k++;
        }

        // Copy remaining elements of rightArray, if any
        while (j < n2) {
            array[k] = rightArray[j];
            j++;
            k++;
        }
    }

    public static void main(String[] args) {
        int[] array = { 12, 11, 13, 5, 6, 7 };
        int n = array.length;

        mergeSort(array, 0, n - 1);

        System.out.println("Sorted array:");
        for (int value : array) {
            System.out.print(value + " ");
        }
    }
}

public class QuickSort {

    // Function to perform quick sort
    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            // Find the pivot element such that elements smaller than pivot are on the left
            // and elements greater than pivot are on the right
            int pivotIndex = partition(array, low, high);
            
            // Recursively sort the elements on the left of the pivot
            quickSort(array, low, pivotIndex - 1);
            
            // Recursively sort the elements on the right of the pivot
            quickSort(array, pivotIndex + 1, high);
        }
    }

    // Partition the array and return the pivot index
    public static int partition(int[] array, int low, int high) {
        int pivot = array[high]; // Choosing the pivot element
        int i = (low - 1);       // Index of the smaller element

        for (int j = low; j < high; j++) {
            // If the current element is smaller than or equal to the pivot
            if (array[j] <= pivot) {
                i++;
                // Swap array[i] and array[j]
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }

        // Swap array[i + 1] and array[high] (or pivot)
        int temp = array[i + 1];
        array[i + 1] = array[high];
        array[high] = temp;

        return i + 1;
    }

    public static void main(String[] args) {
        int[] array = { 10, 7, 8, 9, 1, 5 };
        int n = array.length;

        quickSort(array, 0, n - 1);

        System.out.println("Sorted array:");
        for (int value : array) {
            System.out.print(value + " ");
        }
    }
}

https://community.dynamics.com/blogs/post/?postid=13c7e857-9992-ef11-ac20-7c1e525a7593

allowEditFieldsOnFormDS_W(dirPartyTable_ds, false);
dirPartyTable_ds.object(fieldNum(DirPartyTable, KnownAs)).allowEdit(true);

<!DOCTYPE html>
<html lang-"en">
 <head>
<meta charset="UTF-8">
<meta name-"viewport" content="width=device-width, initial-scale=1.0">
<title>Responsive Bootstrap Layout</title>
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
<link rel-"stylesheet"href="styles.css">
</head>
<body>
<header class="bg-primary text-white text-center py-4">
<h1>My Awesome Web Page</h1></header>
<main class-"container my-4">
<section class="row">
<div class="col-md-3 mb-4">
 <div class-"card text-center bg-success text-white h-100">
<div class-"card-body">
  Item 1
</div>
</div>
</div>
 <div class="col-md-3 mb-4">
 <div class-"card text-center bg-success text-white h-100">
<div class-"card-body">
Item 2</div>
</div></div>
<div class="col-md-3 mb-4“>
<div class-"card text-center bg-success text-white h-100">
<div class="card-body">
Item 3</div>
</div></div>
 
<div class="col-md-3 mb-4">
<div class-"card text-center bg-success text-white h-100">
<div class-"card-body">
Item 4</div>
<div></div>
</section>
<section class="d-flex justify-content-between">
<div class="flex-fill mx-2">
<div class="card text-center bg-info text-white h-100">
<div class="card-body">
Flex Item 1</div>
</div>
</div>
<div class="flex-fill mx-2">
<div class="card text-center bg-info text-white h-100">
<div class="card-body">
Flex Item 2</div>
</div>
</div>
<div class="flex-fill mx-2">
<div class="card text-center bg-info text-white h-100">
<div class="card-body">
Flex Item 3
</div>
</div>
</div>
</section></main>
<footer class-"bg-dark text-white text-center py-3">
<p>&copy; 2024 My website</p></footer>:
cscript src="https://code.jquery.com/jquery-3.5.1.slim.min.js"></script>
<script src-"https://cdn.jsdelivr.net/npm/@popperjs/core@2.5.3/dist/umd/popper.min.js"></script><script src="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/js/bootstrag.min.js"></script></body>
</html>





.card{
transition: transform.0.3s, background-color 0.3s;
}
.card:hover{
transform: scale(1.05);
}
.bg-success {
background-color：□#28a745 !important;
}
.bg-info {
background-color：■#17a2b8 !important;
}

#include<stdio.h>
//Author : Khadiza Sultana
void dectohex(int n){
    if(n == 0) return;
    dectohex(n / 16);
    int rem = n % 16;
    if(rem < 10) printf("%d", rem);
    else printf("%c", rem - 10 + 'A');
}
int main(){
    printf("Enter a number : ");
    scanf("%d", &num);
    printf("Hexadecimal representation of %d : ", num);
    dectohex(num);
    printf("\n");
    return 0;
}

Demo Nike Agent Workflow

// Author : Khadiza Sultana
#include<stdbool.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define NUM_SUITS 4
#define NUM_RANKS 13

int main(){
    bool in_hand[NUM_SUITS][NUM_RANKS] = {false};
    int num_cards, rank, suit;
    const char rank_code[] = {'2', '3', '4', '5', '6', '7', '8', '9', 't', 'j', 'q', 'k', 'a'};
    const char suit_code[] = {'c', 'd', 'h', 's'};
    srand((unsigned) time(NULL));
    printf("Enter number of cards in hand : ");
    scanf("%d", &num_cards);
    printf("Your hand : ");
    while(num_cards > 0){
        suit = rand() % NUM_SUITS;
        rank = rand() % NUM_RANKS;
        if(! in_hand[suit][rank]){
            in_hand[suit][rank] = true;
            num_cards--;
            printf("%c%c ", rank_code[rank], suit_code[suit]);
        }
    }
    printf("\n");
    return 0;
}

npm install @valtown/sdk

import { example1 } from "https://esm.town/v/stevekrouse/example1";

<?php
/**
 * Gravity Perks // Hide Perks from Plugins Page
 * https://gravitywiz.com/documentation/
 */
add_filter( 'all_plugins', function( $plugins ) {

	if ( ! is_callable( 'get_current_screen' ) || get_current_screen()->id !== 'plugins' ) {
		return $plugins;
	}

	$filtered_plugins = array();

	foreach ( $plugins as $slug => $plugin ) {
		if ( ! wp_validate_boolean( rgar( $plugin, 'Perk' ) ) ) {
			$filtered_plugins[ $slug ] = $plugin;
		}
	}

	return $filtered_plugins;
} );

import time
import requests
from threading import Thread
from colorama import Fore, Style
from queue import Queue

def measure_ttfb(url, site_name, color, ttfb_queue):
    while True:
        start_time = time.perf_counter()
        response = requests.get(url)
        end_time = time.perf_counter()

        ttfb = end_time - start_time
        ttfb_ms = ttfb * 1000
        print(f"{color}{site_name}: TTFB: {ttfb_ms:.2f} ms{Style.RESET_ALL}")
        ttfb_queue.put((site_name, ttfb_ms))
        time.sleep(interval)

def main():
    sites = [
        ("https://wordpress-193052-4604364.cloudwaysapps.com/wp-admin", "Staging", Fore.GREEN),
        ("https://contentsnare.com/wp-admin", "Production", Fore.BLUE),
        ("https://mythic-abyss-71810.wp1.site/wp-admin/", "Cloud Nine Web", Fore.CYAN),
    ]
    global interval
    interval = 5  # Interval in seconds

    ttfb_queue = Queue()

    threads = []
    for site in sites:
        url, site_name, color = site
        thread = Thread(target=measure_ttfb, args=(url, site_name, color, ttfb_queue))
        threads.append(thread)
        thread.start()

    while True:
        ttfb_values = []
        for _ in range(len(sites)):
            site_name, ttfb_ms = ttfb_queue.get()
            ttfb_values.append((site_name, ttfb_ms))

        lowest_ttfb = min(ttfb_values, key=lambda x: x[1])
        lowest_site, lowest_ttfb_value = lowest_ttfb

        for site_name, ttfb_ms in ttfb_values:
            color = next((site[2] for site in sites if site[1] == site_name), None)
            print(f"{color}{site_name}: TTFB: {ttfb_ms:.2f} ms{Style.RESET_ALL}")

        lowest_color = next((site[2] for site in sites if site[1] == lowest_site), None)
        print(f"{lowest_color}{Style.BRIGHT}**{lowest_site}: TTFB: {lowest_ttfb_value:.2f} ms**{Style.RESET_ALL}")
        print("-" * 50)
        time.sleep(interval)

if __name__ == "__main__":
    main()

import os
import requests
from bs4 import BeautifulSoup
from urllib.parse import urlparse, urljoin
import xml.etree.ElementTree as ET

# Constants
SITEMAP_URL = 'https://ultimaterides.com/post-sitemap1.xml'
OLD_DOMAIN = 'old.ultimaterides.com'
NEW_DOMAIN = 'ultimaterides.com'
BASE_DOWNLOAD_DIR = './downloaded_images'  # Change this to your desired directory

def check_image(url):
    try:
        response = requests.head(url)
        return response.status_code == 200
    except requests.RequestException:
        return False

def download_image(url, save_path):
    try:
        response = requests.get(url, stream=True)
        if response.status_code == 200:
            os.makedirs(os.path.dirname(save_path), exist_ok=True)
            with open(save_path, 'wb') as file:
                for chunk in response.iter_content(1024):
                    file.write(chunk)
            print(f"Downloaded: {url} to {os.path.abspath(save_path)}")
        else:
            print(f"Failed to download: {url}, status code: {response.status_code}")
    except requests.RequestException as e:
        print(f"Error downloading {url}: {e}")

def find_and_fix_images(blog_post_url):
    response = requests.get(blog_post_url)
    soup = BeautifulSoup(response.content, 'html.parser')
    
    images = soup.find_all('img')
    for img in images:
        img_url = img.get('src')
        if not img_url:
            continue
        
        if NEW_DOMAIN in img_url and not check_image(img_url):
            old_img_url = img_url.replace(NEW_DOMAIN, OLD_DOMAIN)
            if check_image(old_img_url):
                parsed_url = urlparse(img_url)
                save_path = os.path.join(BASE_DOWNLOAD_DIR, parsed_url.path.lstrip('/'))
                download_image(old_img_url, save_path)
            else:
                print(f"Image not found on old domain: {old_img_url}")
        else:
            print(f"Image found: {img_url} or Image is not broken")

def get_post_urls(sitemap_url):
    response = requests.get(sitemap_url)
    root = ET.fromstring(response.content)
    namespaces = {'ns': 'http://www.sitemaps.org/schemas/sitemap/0.9'}
    urls = [elem.text for elem in root.findall('.//ns:loc', namespaces)]
    return urls

def main():
    post_urls = get_post_urls(SITEMAP_URL)
    for post_url in post_urls:
        print(f"Checking blog post: {post_url}")
        find_and_fix_images(post_url)

if __name__ == '__main__':
    main()

/* Instead of using 100vh, use the following */
height: calc(var(--vh, 1vh) * 100);

<script>
document.addEventListener("DOMContentLoaded", () => {
    // Get the initial viewport height
    const initialVh = window.innerHeight * 0.01;
    // Set the value in the --vh custom property to the root of the document
    document.documentElement.style.setProperty('--vh', `${initialVh}px`);
});
</script>

@media(max-width: 500px){
	//Select the map parent element
	.map-parent{
		position: relative;
	}
	//For the map
  #OSM-map{
      height: 100%;
      width: 100%;
      position: absolute;
      top: 0;
      left: 0;
  }
}

// Calculate bounds

var bounds = new L.LatLngBounds();
locations.forEach(function(location) {
    bounds.extend([location.lat, location.lng]);
});

// Set center to the midpoint of the bounds

var centerLatLng = bounds.getCenter();

var map = L.map('OSM-map', mapOptions).setView(centerLatLng, 1);

// Adjust the map to fit all markers within the bounds

map.fitBounds(bounds);

// Zoom out a bit more by decreasing the zoom level

map.setZoom(map.getZoom() - 1); // Decrease zoom level by 1

const deepClone = (obj: any) => {
	if (obj === null) return null;
  let clone = { ...obj };

  Object.keys(clone).forEach(
	  (key) =>
      (clone[key] = typeof obj[key] === "object" ? deepClone(obj[key]) : obj[key])
   );
	 return Array.isArray(obj) && obj.length
	   ? (clone.length = obj.length) && Array.from(clone)
	   : Array.isArray(obj)
     ? Array.from(obj)
     : clone;
};

function calculateDaysBetweenDates(begin, end) {

// Author : Khadiza Sultana
#include<stdio.h>
#include<stdbool.h>
int main(){
    bool digit_seen[10] = {false};
    int digit;
    long n;
    printf("Enter a number : ");
    scanf("%ld", &n);
    while(n > 0){
        digit = n % 10;
        if(digit_seen[digit])
           break;
        digit_seen[digit] = true;
        n /= 10;
    }
    if(n > 0){
        printf("Repeated digit \n");
    }
    else{
        printf("No repeated digit \n");
    }
    return 0;
}

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
    <title>Student Details</title>
</head>
<body>
    <h2>Welcome to the Student Portal</h2>
    
    <%
        // Get the request parameters
        String name = request.getParameter("name");
        String age = request.getParameter("age");
        
        // Check if the parameters are available
        if (name != null && age != null) {
            // Display the student details along with a welcome message
            out.println("<p>Hello, " + name + "! Welcome to the portal.</p>");
            out.println("<p>Your Age: " + age + " years old.</p>");
        } else {
            // If no parameters are passed, display an error message
            out.println("<p>Error: Missing student details.</p>");
        }
    %>
</body>
</html>


<!DOCTYPE html>
<html>
<head>
    <title>Student Details Form</title>
</head>
<body>
    <h2>Enter Your Details</h2>
    <form action="request.jsp" method="post">
        Name: <input type="text" name="name" required><br>
        Age: <input type="number" name="age" required><br>
        <input type="submit" value="Submit">
    </form>
</body>
</html>

/////////************** GRAPHS IN ADC++ **********////////////////
 
/// graphs are combination of nodes and edges 
// nodes = entity in which data is stored
// edges = connecting line which connect the nodes 
// degree = no of edges connected
 
 
 
////// types of graphs
 
// undirected graph = arrow will not be provided ... (v---u == u--v)
 
// directed graph = arrow will  be provided ... (v---u != u--v)
 
// they're two type of degree in directed 
// indegree = edges coming inside  my way  
// outdegree = edges coming out of  way  
 
// wieghted graph = theyre are wieghted writeen on edges(like numbers) default wieght is 1 
 
/// path = squence of nodes reaching (nodes written will not repeat)
 
// cyclic graph = when we create a path in which we reach the node which we written in previous order also. (like a-b-c-d and we d-a this cyclic graph)
 
/// TYPES OF REPRESENATATION 
 
/// i) adjacency matrix 
///  in this 2d matrix is made....
/// space complexity = O(n^2)
 
/// ii) adjacency list 
// in this we write the node connected with one and another in the form of list.
 
 
 
#include <iostream>
#include <unordered_map>
#include <list>
template <typename T>
using namespace std;
 
class graph {
public:
    unordered_map<T, list<T>> adj; // here we mapping a number with another number 
 
    void addEdge(T u, T v, bool direction) { // u and v are edges and bool for undirected and directed graph 
        // direction = 0 -> undirected graph
        // direction = 1 -> directed graph
 
        // creating an edge from u to v 
        adj[u].push_back(v); // created 
        if (direction == 0) { // checking directed or undirected 
            adj[v].push_back(u); // corrected from push.back to push_back
        }
    }
 
    void printAdjList() { // Removed the duplicate declaration
        for (auto i : adj) {
            cout << i.first << " -> ";
            for (auto j : i.second) {
                cout << j << ", ";
            }
            cout << endl; // Move to the next line after printing the list for a node
        }
    }
};
 
int main() {
    int n;
    cout << "Enter the number of nodes: " << endl;
    cin >> n;
 
    int m;
    cout << "Enter the number of edges: " << endl;
    cin >> m;
 
    graph g;
 
    for (int i = 0; i < m; i++) {
        int u, v;
        cout << "Enter edge (u v): "; // Prompt for edge input
        cin >> u >> v;
 
        // Ask the user for the type of graph
        int direction;
        cout << "Is the graph directed (1) or undirected (0)? ";
        cin >> direction;
 
        // creation of graph based on user input
        g.addEdge(u, v, direction);
    }
 
    // printing graph 
    g.printAdjList();
 
    return 0;
}
 
 
 
 
 
 

import tensorflow as tf
 
# 定义模型输入
images = tf.keras.Input(shape=(224, 224, 3))
 
# 使用卷积神经网络提取图像特征
x = tf.keras.layers.Conv2D(32, (3, 3), activation='relu')(images)
x = tf.keras.layers.MaxPooling2D((2, 2))(x)
x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu')(x)
x = tf.keras.layers.MaxPooling2D((2, 2))(x)
x = tf.keras.layers.Flatten()(x)
 
# 使用循环神经网络分析驾驶员的行为序列
x = tf.keras.layers.LSTM(128)(x)
 
# 输出驾驶员的行为类别
outputs = tf.keras.layers.Dense(5, activation='softmax')(x)
 
# 创建模型
model = tf.keras.Model(inputs=images, outputs=outputs)
 
# 编译模型
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
 
# 训练模型
model.fit(train_data, train_labels, epochs=10)
 
# 测试模型
model.evaluate(test_data, test_labels)

 <%@ page language="java" contentType="text/html; charset=UTF-8" 
pageEncoding="UTF-8"%>
<%@ page import="java.sql.Connection, java.sql.DriverManager, 
java.sql.PreparedStatement, java.sql.ResultSet" %>
<!DOCTYPE html>
<html>
<head>
 <title>Database Connectivity Example</title>
</head>
<body>
 <h2>User List</h2>
 <%
 // Database credentials
 String jdbcUrl = "jdbc:mysql://localhost:3306/mydb";
 String jdbcUsername = "root"; // replace with your database username
 String jdbcPassword = "password"; // replace with your database password
 
 // Database connection and query execution
 Connection conn = null;
 PreparedStatement stmt = null;
 ResultSet rs = null;
 
 try {
 
 Class.forName("com.mysql.cj.jdbc.Driver");
 
 conn = DriverManager.getConnection(jdbcUrl, jdbcUsername, jdbcPassword);
   // Prepare SQL query
 String sql = "SELECT * FROM users";
 stmt = conn.prepareStatement(sql);
 
 // Execute query
 rs = stmt.executeQuery();
 
 // Display results
 %>
 <table border="1">
 <tr>
 <th>ID</th>
 <th>Name</th>
 <th>Email</th>
 </tr>
 <%
 while (rs.next()) {
 %>
 <tr>
 <td><%= rs.getInt("id") %></td>
 <td><%= rs.getString("name") %></td>
 <td><%= rs.getString("email") %></td>
 </tr>
 <%
 }
 %>
 </table>
 <%
   } catch (Exception e) {
 out.println("Database connection error: " + e.getMessage());
 }
finally { 
 if (rs != null) 
try { 
rs.close();
} 
catch (Exception e) { }
 if (stmt != null) 
try { stmt.close();
} 
catch (Exception e) { /* ignored */ }
 if (conn != null)
try {
conn.close();
} 
catch (Exception e) { /* ignored */ }
 }
 %>
</body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ page import="java.sql., javax.sql." %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<%
		Connection conn =null;
		PreparedStatement stmt = null;
		try{
			int id = Integer.parseInt(request.getParameter("id"));
			String name  = request.getParameter("name");
			String position = request.getParameter("position");
			float salary  = Float.parseFloat(request.getParameter("salary"));
			 Class.forName("com.mysql.cj.jdbc.Driver");
			 conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/Vijaya","root","Saimanish@2004");
			 String sql = "INSERT INTO employees (id,name,position,salary) VALUES (?, ?, ?, ?)";
			 stmt = conn.prepareStatement(sql);
			 stmt.setInt(1,id);
			 stmt.setString(2, name);
			 stmt.setString(3, position);
			 stmt.setFloat(4, salary);
			int rows = stmt.executeUpdate();
			if (rows > 0) {
                out.println("<p>Employee row inserted successfully!</p>");
            } else {
                out.println("<p>Error: Employee row cannot be inserted.</p>");
            }
		} catch (Exception e) {
         out.println("Error: " + e.getMessage());
		}
	%>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<form action="update.jsp" method="post"><br>
	Id:<input type="text" name="id" required><br>
	Name:<input type="text" name="name" required><br>
	Position:<input type="text" name="position" required><br>
	Salary:<input type="text" name="salary" required><br>
	Submit:<input type="submit"><br>
	</form>
</body>
</html>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<form action="insert.jsp" method="post">
	Id:<input type="text" name="id" required><br>
	Salary:<input type="text" name="salary" required><br>
	Submit:<input type="submit"><br>
	</form>
</body>
</html>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ page import="java.sql., javax.sql." %>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<%
		Connection conn =null;
		PreparedStatement stmt = null;
		try{
			int id = Integer.parseInt(request.getParameter("id"));
			float salary  = Float.parseFloat(request.getParameter("salary"));
			 Class.forName("com.mysql.cj.jdbc.Driver");
			 conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/Vijaya","root","Saimanish@2004");
			 String sql = "update employees set salary=? where id=?";
			 stmt = conn.prepareStatement(sql);
			 stmt.setFloat(1, salary);
			 stmt.setInt(2,id);
			int rows = stmt.executeUpdate();
			if (rows > 0) {
                out.println("<p>Employee row updated successfully!</p>");
            } else {
                out.println("<p>Error: Employee row cannot be updated.</p>");
            }
		} catch (Exception e) {
         out.println("Error: " + e.getMessage());
		}
	%>
</body>
</html>