#include <stdio.h>

int main() {
    int n, m, i, j, k;
    n = 5;                         // Number of processes
    m = 3;                         // Number of resources
    int alloc[5][3] = {{0, 1, 0},  // Allocation Matrix
                       {2, 0, 0},
                       {3, 0, 2},
                       {2, 1, 1},
                       {0, 0, 2}};
    int max[5][3] = {{7, 5, 3},    // MAX Matrix
                     {3, 2, 2},
                     {9, 0, 2},
                     {2, 2, 2},
                     {4, 3, 3}};
    int avail[3] = {3, 3, 2};       // Available Resources
    int f[n], ans[n], ind = 0;
    for (k = 0; k < n; k++) {
        f[k] = 0;                  // Initialize all processes as unfinished
    }
    int need[n][m];

    // Calculate Need Matrix
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++)
            need[i][j] = max[i][j] - alloc[i][j];
    }

    // Safety Algorithm
    int y = 0;
    for (k = 0; k < 5; k++) {       // Repeat until all processes are checked
        for (i = 0; i < n; i++) {   // Loop through each process
            if (f[i] == 0) {        // Check if the process is not finished
                int flag = 0;
                for (j = 0; j < m; j++) {
                    // Check if all resource needs of the process can be satisfied with available resources
                    if (need[i][j] > avail[j]) {
                        flag = 1;   // If any resource need exceeds available resources, set flag to 1
                        break;
                    }
                }
                if (flag == 0) {     // If all resource needs can be satisfied
                    ans[ind++] = i; // Add process to safe sequence
                    // Update available resources by adding allocated resources of the process
                    for (y = 0; y < m; y++)
                        avail[y] += alloc[i][y];
                    f[i] = 1;       // Mark process as finished
                }
            }
        }
    }

    // Safety Check
    int flag = 1;
    for (int i = 0; i < n; i++) {
        if (f[i] == 0) {    // If any process is not finished
            flag = 0;       // Set flag to 0 indicating system is not in a safe state
            printf("The following system is not safe");
            break;
        }
    }

    // Output
    if (flag == 1) {        // If system is in a safe state
        printf("Following is the SAFE Sequence\n");
        for (i = 0; i < n - 1; i++)
            printf(" P%d ->", ans[i]);
        printf(" P%d", ans[n - 1]);
    }
    return (0);
}

05-12 20:08:56.722   185   185 E ClassHook: java.lang.IllegalArgumentException: Couldn't build method proxy for Landroid/app/Notification;.<init>(Landroid/content/Context;ILjava/lang/CharSequence;JLjava/lang/CharSequence;Ljava/lang/CharSequence;Landroid/content/Intent;)V

05-12 20:08:56.695   185   185 I ClassHook: android.app.AppOpsManagerHook attachMethod opToPermission(I)Ljava/lang/String;

05-12 20:08:56.524   381   414 D libEGL  : loaded /vendor/lib/egl/libGLES_vc4.so

05-12 20:08:56.086   174   387 V BrcmCamera: bufferProcessingThread: start

05-12 20:08:55.971   174   360 V BrcmCamera: setPreviewWindowInternal: been passed no window as the ANativeWindow

05-12 20:08:55.386   182   342 D brcm-tv-hlp: [tv_hotplug_helper_thread]: starting hotplug helper

$app = requir_once __DIR__.'/../bootstrap/app.php';

$app = require_once __DIR__.'/../bootstrap/app.php';

import java.util.Arrays;

public class PriorityQueue {
    private int capacity = 10;
    private int size = 0;
    private int[] items = new int[capacity];

    // Helper methods for parent, left child, and right child indices
    private int parentIndex(int index) {
        return (index - 1) / 2;
    }

    private int leftChildIndex(int index) {
        return 2 * index + 1;
    }

    private int rightChildIndex(int index) {
        return 2 * index + 2;
    }

    // Helper method to ensure capacity
    private void ensureCapacity() {
        if (size == capacity) {
            capacity *= 2;
            items = Arrays.copyOf(items, capacity);
        }
    }

    // Method to swap two elements in the array
    private void swap(int index1, int index2) {
        int temp = items[index1];
        items[index1] = items[index2];
        items[index2] = temp;
    }

    // Method to maintain heap property by bubbling up
    private void heapifyUp() {
        int index = size - 1;
        while (index > 0 && items[index] > items[parentIndex(index)]) {
            swap(index, parentIndex(index));
            index = parentIndex(index);
        }
    }

    // Method to maintain heap property by bubbling down
    private void heapifyDown() {
        int index = 0;
        while (leftChildIndex(index) < size) {
            int largerChildIndex = leftChildIndex(index);
            if (rightChildIndex(index) < size && items[rightChildIndex(index)] > items[largerChildIndex]) {
                largerChildIndex = rightChildIndex(index);
            }
            if (items[index] > items[largerChildIndex]) {
                break;
            } else {
                swap(index, largerChildIndex);
            }
            index = largerChildIndex;
        }
    }

    // Method to add an element to the priority queue
    public void add(int item) {
        ensureCapacity();
        items[size] = item;
        size++;
        heapifyUp();
    }

    // Method to remove and return the maximum element from the priority queue
    public int remove() {
        if (size == 0) {
            throw new IllegalStateException("Priority queue is empty");
        }
        int maxItem = items[0];
        items[0] = items[size - 1];
        size--;
        heapifyDown();
        return maxItem;
    }

    // Method to return the maximum element from the priority queue without removing it
    public int peek() {
        if (size == 0) {
            throw new IllegalStateException("Priority queue is empty");
        }
        return items[0];
    }

    // Method to check if the priority queue is empty
    public boolean isEmpty() {
        return size == 0;
    }

    // Method to return the size of the priority queue
    public int size() {
        return size;
    }

    // Method to print the elements of the priority queue
    public void print() {
        for (int i = 0; i < size; i++) {
            System.out.print(items[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        PriorityQueue pq = new PriorityQueue();
        pq.add(5);
        pq.add(10);
        pq.add(3);
        pq.add(7);
        pq.add(1);
        pq.add(8);

        System.out.println("Priority Queue elements:");
        pq.print();

        System.out.println("Removing maximum element: " + pq.remove());
        System.out.println("Priority Queue elements after removal:");
        pq.print();
    }
}

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

#define ReadEnd  0
#define WriteEnd 1

void report_and_exit(const char* msg) {
  perror(msg);
  exit(-1);
}

int main() {
  int pipeFDs[2];
  char buf;
  const char* msg = "Nature's first green is gold\n";

  if (pipe(pipeFDs) < 0) report_and_exit("pipeFD");
  pid_t cpid = fork();
  if (cpid < 0) report_and_exit("fork");

  if (0 == cpid) {
    close(pipeFDs[WriteEnd]);

    while (read(pipeFDs[ReadEnd], &buf, 1) > 0)
      write(STDOUT_FILENO, &buf, sizeof(buf));

    close(pipeFDs[ReadEnd]);
    _exit(0);
  }
  else {
    close(pipeFDs[ReadEnd]);

    write(pipeFDs[WriteEnd], msg, strlen(msg));
    close(pipeFDs[WriteEnd]);

    wait(NULL);
    exit(0);
  }
  return 0;
}

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#include "queue.h"

void report_and_exit(const char* msg) {
  perror(msg);
  exit(-1);
}

int main() {
  key_t key = ftok(PathName, ProjectId);
  if (key < 0) report_and_exit("couldn't get key...");

  int qid = msgget(key, 0666 | IPC_CREAT);
  if (qid < 0) report_and_exit("couldn't get queue id...");

  char* payloads[] = {"msg1", "msg2", "msg3", "msg4", "msg5", "msg6"};
  int types[] = {1, 1, 2, 2, 3, 3};
  int i;
  for (i = 0; i < MsgCount; i++) {

    queuedMessage msg;
    msg.type = types[i];
    strcpy(msg.payload, payloads[i]);

   
    msgsnd(qid, &msg, sizeof(msg), IPC_NOWAIT);
    printf("%s sent as type %i\n", msg.payload, (int) msg.type);
  }
  return 0;
}
#include <stdio.h>

#include <sys/ipc.h>

#include <sys/msg.h>

#include <stdlib.h>

#include "queue.h"



void report_and_exit(const char* msg) {

  perror(msg);

  exit(-1);

}



int main() {

  key_t key= ftok(PathName, ProjectId);

  if (key < 0) report_and_exit("key not gotten...");



  int qid = msgget(key, 0666 | IPC_CREAT); 

  if (qid < 0) report_and_exit("no access to queue...");



  int types[] = {3, 1, 2, 1, 3, 2};

  int i;

  for (i = 0; i < MsgCount; i++) {

    queuedMessage msg; 

    if (msgrcv(qid, &msg, sizeof(msg), types[i], MSG_NOERROR | IPC_NOWAIT) < 0)

      puts("msgrcv trouble...");

    printf("%s received as type %i\n", msg.payload, (int) msg.type);

  }





  if (msgctl(qid, IPC_RMID, NULL) < 0)  

    report_and_exit("trouble removing queue...");



  return 0;

}

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main()
{
    
    key_t key = ftok("shmfile", 65);

    
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);


char* str = (char*)shmat(shmid, (void*)0, 0);

    printf("Write Data: ");
    fgets(str, 1024, stdin);

    printf("Data written in memory: %s\n", str);

    
    shmdt(str);

    return 0;
}

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main()
{

    key_t key = ftok("shmfile", 65);

    
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);

   
    char* str = (char*)shmat(shmid, (void*)0, 0);

    printf("Data read from memory: %s\n", str);

    
    shmdt(str);


    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

<video width="320" height="240" controls>
<source src="movie.mp4" type="video/mp4">
<source src="movie.ogg" type="video/ogg">
Your browser does not support the video tag.
</video>

import java.util.*;

public class LinearProbing<T> {
    private static final int DEFAULT_TABLE_SIZE = 101;
    private HashEntry<T>[] array;
    private int currentSize;

    public LinearProbing() { this(DEFAULT_TABLE_SIZE); }

    public LinearProbing(int size) {
        array = new HashEntry[size];
        currentSize = 0;
    }

    public boolean contains(T element) { return array[findPos(element)] != null; }

    private int findPos(T element) {
        int currentPos = myhash(element);
        int offset = 1;
        while (array[currentPos] != null && !array[currentPos].element.equals(element)) {
            currentPos += offset;
            offset++;
            currentPos %= array.length;
        }
        return currentPos;
    }

    public void insert(T element) { array[findPos(element)] = new HashEntry<>(element, true); }

    public void remove(T element) { array[findPos(element)].isActive = false; }

    private int myhash(T element) {
        int hashValue = element.hashCode() % array.length;
        return hashValue < 0 ? hashValue + array.length : hashValue;
    }

    private static class HashEntry<T> {
        public T element;
        public boolean isActive;

        public HashEntry(T e, boolean i) { element = e; isActive = i; }
    }

    public void showAll() {
        for (HashEntry each : array)
            System.out.print((each != null ? each.element : "None") + " ");
    }

    public static void main(String[] args) {
        LinearProbing<Integer> sc = new LinearProbing<>(10);
        sc.insert(89); sc.insert(18); sc.insert(49); sc.insert(58); sc.insert(69);
        sc.showAll();
    }
}

import java.util.*;
import java.util.stream.*;
public class Main{
    public static void main(String[] args)
    {
        ArrayList<Integer> al=new ArrayList<>();
        al.add(7);
        al.add(90);
        al.add(4);
        al.add(18);
        al.add(3);
        System.out.println("List : "+al);
      Stream<Double> stm=al.stream().map(n->Math.sqrt(n));
      stm.forEach(n->System.out.println(n+" "));
    }
}

import java.util.*;
import java.util.stream.*;
public class Main{
    public static void main(String[] args)
    {
        ArrayList<Integer> al=new ArrayList<>();
        al.add(7);
        al.add(90);
        al.add(4);
        al.add(18);
        al.add(3);
        System.out.println("List : "+al);
    
     Optional<Integer> sum=al.stream().reduce((x,y)->(x+y));
     if(sum.isPresent())
     System.out.println(" sum :"+sum.get());
     sum=al.stream().reduce((x,y)->(x*y));
     if(sum.isPresent())
     {
         System.out.println("product : "+sum.get());
     }
    }
}

import java.util.*;
import java.util.stream.*;
public class Main{
    public static void main(String[] args)
    {
        ArrayList<Integer> al=new ArrayList<>();
        al.add(7);
        al.add(90);
        al.add(4);
        al.add(18);
        al.add(3);
        System.out.println("List : "+al);
      Stream<Integer> stm=al.stream().filter(n->n%2==0);
      stm.forEach(n->System.out.println(n+" "));
      List<Integer> listeven=al.stream().filter(n->n%2==1).collect(Collectors.toList());
      System.out.println("List even"+listeven);
      Set<Integer> odd=al.stream().filter(n->n%2==1).collect(Collectors.toSet());
      System.out.println("set odd"+odd);
      
    }
}

import java.util.*;
import java.util.stream.*;
public class Main{
    public static void main(String[] args)
    {
        ArrayList<Integer> al=new ArrayList<>();
        al.add(7);
        al.add(90);
        al.add(4);
        al.add(18);
        al.add(3);
        System.out.println("List : "+al);
       Stream<Integer> stm=al.stream();
       Optional<Integer> least=stm.min(Integer::compare);
       if(least.isPresent())
       System.out.println("least : "+least.get());
       stm=al.stream();
        Optional<Integer> high=stm.max(Integer::compare);
        if(high.isPresent())
       System.out.println("least : "+high.get());
       stm=al.stream();
       System.out.println("Count : "+stm.count());
       stm=al.stream();
       stm=al.stream().sorted();
       stm.forEach(n->System.out.println(n+" "));
       System.out.println("even numbers");
       stm=al.stream().filter(n->n%2==0);
       stm.forEach(n->System.out.println(n+"  "));
       System.out.println("Number of odd");
       stm=al.stream().filter(n->n%2==1).filter(n->n>5);
       stm.forEach(n->System.out.println(n+"  "));
    }
}

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python Debugger: FastAPI",
            "type": "debugpy",
            "request": "launch",
            "module": "uvicorn",
            "args": [
                "app:app",
                "--reload",
                "--port", "8000" 
            ],
            "jinja": true,
            "cwd": "${workspaceFolder}/src"  
        }
    ]
}

SELECT a.Contact_Email
FROM (
        SELECT b.Contact_Email
        FROM [OAG_Profile_Expansion_Master] b
        WHERE 1 = 1
        AND LOWER(
            RIGHT (
                b.Contact_Email,
                LEN(b.Contact_Email) - CHARINDEX('@', b.Contact_Email)
            )
        ) IN (
            SELECT LOWER(x.Domain)
            FROM ent.[Dealer Domains] x
    )
) a
 
UNION ALL
SELECT a.Contact_Email
FROM (
    SELECT b.Contact_Email
    FROM [OAG_Profile_Expansion_Master] b
    WHERE 1 = 1
    AND LOWER(
        RIGHT (
            b.Contact_Email,
            LEN(b.Contact_Email) - CHARINDEX('@', b.Contact_Email)
            )
        ) IN (
            SELECT LOWER(x.Domain)
            FROM ent.[Cat_Agency_Domains] x
    )
) a
 
UNION ALL
SELECT a.Contact_Email
FROM (
    SELECT b.Contact_Email
    FROM [OAG_Profile_Expansion_Master] b
    WHERE 1 = 1
    AND LOWER(
        RIGHT (
            b.Contact_Email,
            LEN(b.Contact_Email) - CHARINDEX('@', b.Contact_Email)
            )
        ) IN (
            SELECT LOWER(x.Domain)
            FROM ent.[Competitor Domains] x
    )
) a

#include <stdio.h>

int main() {
    int n, i, j, temp, time = 0, count, completed = 0, sum_wait = 0, sum_turnaround = 0, start;
    float avg_wait, avg_turnaround;
    int at[10], bt[10], p[10]; // Arrays for arrival times, burst times, and process numbers

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

    // Input arrival times and burst times for each process
    for (i = 0; i < n; i++) {
        printf("Enter the arrival time and burst time for process %d: ", i + 1);
        scanf("%d%d", &at[i], &bt[i]);
        p[i] = i + 1;
    }

    // Sort processes by arrival times, and then by burst times
    for (i = 0; i < n - 1; i++) {
        for (j = i + 1; j < n; j++) {
            if (at[i] > at[j] || (at[i] == at[j] && bt[i] > bt[j])) {
                temp = at[i];
                at[i] = at[j];
                at[j] = temp;
                temp = bt[i];
                bt[i] = bt[j];
                bt[j] = temp;
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }

    printf("\nProcess\tAT\tBT\tWT\tTAT\n");

    // Main loop to calculate waiting times and turnaround times
    while (completed < n) {
        count = 0;
        for (i = completed; i < n; i++) {
            if (at[i] <= time) {
                count++;
            } else {
                break;
            }
        }

        // Sort the ready processes by burst time
        if (count > 1) {
            for (i = completed; i < completed + count - 1; i++) {
                for (j = i + 1; j < completed + count; j++) {
                    if (bt[i] > bt[j]) {
                        temp = at[i];
                        at[i] = at[j];
                        at[j] = temp;
                        temp = bt[i];
                        bt[i] = bt[j];
                        bt[j] = temp;
                        temp = p[i];
                        p[i] = p[j];
                        p[j] = temp;
                    }
                }
            }
        }

        start = time;
        time += bt[completed];
        printf("P[%d]\t%d\t%d\t%d\t%d\n", p[completed], at[completed], bt[completed], time - at[completed] - bt[completed], time - at[completed]);
        sum_wait += time - at[completed] - bt[completed];
        sum_turnaround += time - at[completed];
        completed++;
    }

    avg_wait = (float)sum_wait / (float)n;
    avg_turnaround = (float)sum_turnaround / (float)n;

    printf("Average waiting time is %.2f\n", avg_wait);
    printf("Average turnaround time is %.2f\n", avg_turnaround);

    return 0;
}

#include <stdio.h>

#define MAX_PROCESSES 100

typedef struct {
    int id;         // Process ID
    int arrival;    // Arrival time
    int burst;      // Burst time
    int remaining;  // Remaining time
    int finish;     // Finish time
    int waiting;    // Waiting time
    int turnaround; // Turnaround time
} Process;

int main() {
    int n;
    Process processes[MAX_PROCESSES];

    printf("Enter number of processes: ");
    scanf("%d", &n);

    for (int i = 0; i < n; i++) {
        processes[i].id = i + 1;
        printf("Enter arrival time and burst time for process %d: ", i + 1);
        scanf("%d %d", &processes[i].arrival, &processes[i].burst);
    }

    int currentTime = 0, completed = 0, shortest = 0;
    int minRemaining = 10000;
    int finishTime;
    int found = 0;

    // Initialize remaining times
    for (int i = 0; i < n; i++) {
        processes[i].remaining = processes[i].burst;
    }

    while (completed != n) {
        // Find process with minimum remaining time at current time
        for (int i = 0; i < n; i++) {
            if (processes[i].arrival <= currentTime && processes[i].remaining < minRemaining && processes[i].remaining > 0) {
                minRemaining = processes[i].remaining;
                shortest = i;
                found = 1;
            }
        }

        if (!found) {
            currentTime++;
            continue;
        }

        // Decrement remaining time
        processes[shortest].remaining--;

        // Update minimum remaining time
        minRemaining = processes[shortest].remaining;
        if (minRemaining == 0) {
            minRemaining = 10000;
        }

        // If a process gets completely executed
        if (processes[shortest].remaining == 0) {
            completed++;
            found = 0;
            finishTime = currentTime + 1;
            processes[shortest].finish = finishTime;
            processes[shortest].waiting = finishTime - processes[shortest].burst - processes[shortest].arrival;
            if (processes[shortest].waiting < 0) {
                processes[shortest].waiting = 0;
            }
            processes[shortest].turnaround = processes[shortest].waiting + processes[shortest].burst;
        }
        currentTime++;
    }
     float totalWaiting = 0, totalTurnaround = 0;

    printf("\nPID\tArrival\tBurst\tFinish\tWaiting\tTurnaround\n");
    for (int i = 0; i < n; i++) {
        totalWaiting += processes[i].waiting;
        totalTurnaround += processes[i].turnaround;
        printf("%d\t%d\t%d\t%d\t%d\t%d\n",
               processes[i].id,
               processes[i].arrival,
               processes[i].burst,
               processes[i].finish,
               processes[i].waiting,
               processes[i].turnaround);
    }

    printf("\nAverage Waiting Time: %.2f\n", totalWaiting / n);
    printf("Average Turnaround Time: %.2f\n", totalTurnaround / n);

    return 0;
}

#include <stdio.h>

int main() {
    int n, tq, i, total_time = 0, time = 0, flag = 0;
    int bt[10], rem_bt[10], wt[10], tat[10]; // Burst times, remaining burst times, waiting times, turnaround times
    float avg_wt = 0, avg_tat = 0;

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

    printf("Enter the burst time for each process:\n");
    for (i = 0; i < n; i++) {
        printf("P[%d]: ", i + 1);
        scanf("%d", &bt[i]);
        rem_bt[i] = bt[i]; // Initialize remaining burst time as burst time
    }

    printf("Enter the time quantum: ");
    scanf("%d", &tq);

    while (1) {
        flag = 0;
        for (i = 0; i < n; i++) {
            if (rem_bt[i] > 0) {
                flag = 1; // There is a pending process

                if (rem_bt[i] > tq) {
                    time += tq;
                    rem_bt[i] -= tq;
                } else {
                    time += rem_bt[i];
                    wt[i] = time - bt[i]; // Waiting time is current time minus burst time
                    rem_bt[i] = 0;
                }
            }
        }
        
        if (flag == 0) // All processes are done
            break;
    }

    printf("\nProcess\tBT\tWT\tTAT\n");
    for (i = 0; i < n; i++) {
        tat[i] = bt[i] + wt[i]; // Turnaround time is burst time plus waiting time
        avg_wt += wt[i];
        avg_tat += tat[i];
        printf("P[%d]\t%d\t%d\t%d\n", i + 1, bt[i], wt[i], tat[i]);
    }

    avg_wt /= n;
    avg_tat /= n;

    printf("\nAverage Waiting Time: %.2f", avg_wt);
    printf("\nAverage Turnaround Time: %.2f", avg_tat);

    return 0;
}

#include <stdio.h>

int main() {
    int n, i, j, temp, sum_wait = 0, sum_turnaround = 0;
    float avg_wait, avg_turnaround;
    int priority[20], bt[20], wt[20], tat[20];

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

    // Input burst times and priorities for each process
    printf("Enter burst times and priorities for each process:\n");
    for (i = 0; i < n; i++) {
        printf("Process %d: ", i + 1);
        scanf("%d%d", &bt[i], &priority[i]);
    }

    // Sort processes based on priority (ascending order)
    for (i = 0; i < n - 1; i++) {
        for (j = i + 1; j < n; j++) {
            if (priority[i] > priority[j]) {
                temp = priority[i];
                priority[i] = priority[j];
                priority[j] = temp;
                temp = bt[i];
                bt[i] = bt[j];
                bt[j] = temp;
            }
        }
    }

    // Calculate waiting time for each process
    wt[0] = 0; // Waiting time for first process is zero
    for (i = 1; i < n; i++) {
        wt[i] = wt[i - 1] + bt[i - 1];
        sum_wait += wt[i];
    }

    // Calculate turnaround time for each process
    for (i = 0; i < n; i++) {
        tat[i] = wt[i] + bt[i];
        sum_turnaround += tat[i];
    }

    // Calculate average waiting time and average turnaround time
    avg_wait = (float)sum_wait / n;
    avg_turnaround = (float)sum_turnaround / n;

    // Print process details
    printf("\nProcess\tBT\tPriority\tWT\tTAT\n");
    for (i = 0; i < n; i++) {
        printf("P%d\t%d\t%d\t\t%d\t%d\n", i + 1, bt[i], priority[i], wt[i], tat[i]);
    }

    // Print average waiting time and average turnaround time
    printf("\nAverage Waiting Time: %.2f\n", avg_wait);
    printf("Average Turnaround Time: %.2f\n", avg_turnaround);

    return 0;
}

#include <stdio.h>
int main() {
    int n, m, i, j, k;

    // Get the number of processes and resources from the user
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    printf("Enter the number of resources: ");
    scanf("%d", &m);

    int alloc[n][m], max[n][m], avail[m];

    // Get the Allocation Matrix from the user
    printf("Enter the Allocation Matrix:\n");
    for (i = 0; i < n; i++) {
        printf("Process %d:\n", i);
        for (j = 0; j < m; j++) {
            scanf("%d", &alloc[i][j]);
        }
    }

    // Get the Maximum Matrix from the user
    printf("Enter the Maximum Matrix:\n");
    for (i = 0; i < n; i++) {
        printf("Process %d:\n", i);
        for (j = 0; j < m; j++) {
            scanf("%d", &max[i][j]);
        }
    }

    // Get the Available Resources from the user
    printf("Enter the Available Resources:\n");
    for (i = 0; i < m; i++) {
        scanf("%d", &avail[i]);
    }

    int f[n], ans[n], ind = 0;
    for (k = 0; k < n; k++) {
        f[k] = 0;
    }

    int need[n][m];
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++) {
            need[i][j] = max[i][j] - alloc[i][j];
        }
    }

    int y = 0;
    for (k = 0; k < n; k++) {
        for (i = 0; i < n; i++) {
            if (f[i] == 0) {
                int flag = 0;
                for (j = 0; j < m; j++) {
                    if (need[i][j] > avail[j]) {
                        flag = 1;
                        break;
                    }
                }

                if (flag == 0) {
                    ans[ind++] = i;
                    for (y = 0; y < m; y++) {
                        avail[y] += alloc[i][y];
                    }
                    f[i] = 1;
                }
            }
        }
    }

    int flag = 1;
    for (i = 0; i < n; i++) {
        if (f[i] == 0) {
            flag = 0;
            printf("The system is not in a safe state.\n");
            break;
        }
    }

    if (flag == 1) {
        printf("The system is in a safe state.\nSafe sequence is: ");
        for (i = 0; i < n - 1; i++) {
            printf("P%d -> ", ans[i]);
        }
        printf("P%d\n", ans[n - 1]);
    }

    return 0;
}

#include<stdio.h>
int mutex=1,full=0,empty=3,x=0;
main()
{
   int n;
   void producer();
   void consumer();
   int wait(int);
   int signal(int);
   printf("\n 1.Producer  \n 2.Consumer \n 3.Exit");
   while(1)
   {
      printf("\n Enter your choice:");
      scanf("%d",&n);
      switch(n)
      {
         case 1:
                 if((mutex==1)&&(empty!=0))
                    producer();
                 else
                    printf("Buffer is full");
     break;
         case 2:
             if((mutex==1)&&(full!=0))
    consumer();
    else
        printf("Buffer is empty");
       break;
         case 3:
    exit(0);
    break;
      }
   }
}
int wait(int s)
{
   return (--s);
}
int signal(int s)
{
   return(++s);
}
void producer()
{
   mutex=wait(mutex);
   full=signal(full);
   empty=wait(empty);
   x++;
   printf("\n Producer produces the item %d",x);
   mutex=signal(mutex);
}
void consumer()
{
   mutex=wait(mutex);
   full=wait(full);
   empty=signal(empty);
   printf("\n Consumer consumes item %d",x);
   x--;
   mutex=signal(mutex);
}

#include<stdio.h>
#include<conio.h>
int main()
{
int i, j, k, f, pf=0, count=0, rs[25], m[10], n;
printf("\n Enter the length of reference string -- ");
scanf("%d",&n);
printf("\n Enter the reference string -- ");
 for(i=0;i<n;i++)
scanf("%d",&rs[i]);
 printf("\n Enter no. of frames -- ");
 scanf("%d",&f);
for(i=0;i<f;i++)
m[i]=-1;

printf("\n The Page Replacement Process is -- \n");
 for(i=0;i<n;i++)
{
for(k=0;k<f;k++)
{
  if(m[k]==rs[i])
  break;

}
if(k==f)
{
m[count++]=rs[i];
pf++;

}

for(j=0;j<f;j++)
printf("\t%d",m[j]);
if(k==f)
printf("\tPF No. %d",pf);
printf("\n");
if(count==f)
count=0;
}
printf("\n The number of Page Faults using FIFO are %d",pf);
getch();
}

#include<stdio.h>
#include<conio.h>
void main()
{
int i, j , k, min, rs[25], m[10], count[10], flag[25], n, f, pf=0, next=1;
//clrscr();
printf("Enter the length of reference string -- ");
 scanf("%d",&n);
printf("Enter the reference string -- ");
 for(i=0;i<n;i++)
{
scanf("%d",&rs[i]);
flag[i]=0;
}
printf("Enter the number of frames -- ");
 scanf("%d",&f);
for(i=0;i<f;i++)

{
count[i]=0;
m[i]=-1;
}
printf("\nThe Page Replacement process is -- \n");
 for(i=0;i<n;i++)
{
for(j=0;j<f;j++)
{
if(m[j]==rs[i])
{
flag[i]=1;
count[j]=next;
 next++;
}

}
if(flag[i]==0)
{

if(i<f)
{  m[i]=rs[i];
   count[i]=next;
   next++;
 }
else
{ min=0;
for(j=1;j<f;j++)
if(count[min] > count[j])
  min=j;

m[min]=rs[i];
 count[min]=next;
  next++;


}
pf++;
}

for(j=0;j<f;j++)
printf("%d\t", m[j]);
 if(flag[i]==0)
//printf("PF No. -- %d" , pf);
 printf("\n");
}
printf("\nThe number of page faults using LRU are %d",pf);
 getch();
}

#include <stdio.h>

int main() {
    int frames, pages, i, j, page_faults = 0, flag = 0, pos = 0;
    
    printf("Enter the number of frames: ");
    scanf("%d", &frames);
    
    printf("Enter the number of pages: ");
    scanf("%d", &pages);
    
    int frame[frames], page[pages];
    int temp[frames];
    
    for (i = 0; i < frames; i++) {
        frame[i] = -1;
    }
    
    printf("Enter reference string: ");
    for (i = 0; i < pages; i++) {
        scanf("%d", &page[i]);
    }
    
    for (i = 0; i < pages; i++) {
        flag = 0;
        for (j = 0; j < frames; j++) {
            if (frame[j] == page[i]) {
                flag = 1;
                break;
            }
        }
        
        if (flag == 0) {
            if (pos < frames) {
                frame[pos++] = page[i];
            } else {
                int farthest = 0;
                for (j = 0; j < frames; j++) {
                    temp[j] = -1;
                    for (int k = i + 1; k < pages; k++) {
                        if (frame[j] == page[k]) {
                            temp[j] = k;
                            break;
                        }
                    }
                    if (temp[j] == -1) {
                        farthest = j;
                        break;
                    } else {
                        if (temp[j] > temp[farthest] || (temp[j] == temp[farthest] && j < farthest)) {
                            farthest = j;
                        }
                    }
                }
                frame[farthest] = page[i];
                page_faults++;
            }
        }
    }
    
    printf("Total Page Faults: %d\n", page_faults);
    
    return 0;
}

var gr = new GlideRecord('change_request');
gr.addQuery('state', '-1');
gr.addQuery('number', 'CHG0030780');
gr.query();
while(gr.next()) {
    gr.state=3;
    gr.close_code='successful';
    gr.close_notes='Closing this change manually due to known error';
    gr.setWorkflow(false);
    gr.autoSysFields(false);
    gr.update();
}

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        if ( amount == 0 ) return 0;

        int m[amount+1];
        m[0]=0;
        for (int i = 1; i <=amount; ++i) {
            m[i]=INT_MAX;
            for (auto it:coins){
                if ( it<=i && m[i-it]!=INT_MAX){
                    m[i]=min(m[i],1+m[i-it]);

                }
            }
             
        }
        if (m[amount]==INT_MAX) return -1;
        return m[amount];
    }
};

class Solution {
public:
    vector<string> commonChars(vector<string>& words) {
        int words_size = words.size();
        vector<int> commonCharacterCounts(26), currentCharacterCounts(26);
        vector<string> result;

        // Initialize commonCharacterCounts with the characters from the first
        // word
        for (char& ch : words[0]) {
            commonCharacterCounts[ch - 'a']++;
        }

        for (int i = 1; i < words_size; i++) {
            fill(currentCharacterCounts.begin(), currentCharacterCounts.end(),
                 0);

            // Count characters in the current word
            for (char& ch : words[i]) {
                currentCharacterCounts[ch - 'a']++;
            }

            // Update the common character counts to keep the minimum counts
            for (int letter = 0; letter < 26; letter++) {
                commonCharacterCounts[letter] =
                    min(commonCharacterCounts[letter],
                        currentCharacterCounts[letter]);
            }
        }

        // Collect the common characters based on the final counts
        for (int letter = 0; letter < 26; letter++) {
            for (int commonCount = 0;
                 commonCount < commonCharacterCounts[letter]; commonCount++) {
                result.push_back(string(1, letter + 'a'));
            }
        }

        return result;
    }
};

def is_sorted (l1):
    return all(l1[i]<=l1[i+1]for i in range (len(l1)-1))
n=int(input("enter n"))
l=[]
print("enter x")
for i in range(n):
    x=int(input())
    l.append(x)
z=is_sorted(l)
print(z)

$('.technology-all__img').each(function () {
	var randomColor = Math.random() < 0.5 ? '#f8f8f8' : 'transparent'; // Randomly choose between 	  two colors
	$(this).css('background', randomColor);
});

class Solution {
public:
    int climbStairs(int n) {
        if (n == 0 || n == 1) {
            return 1;
        }

        vector<int> dp(n+1);
        dp[0] = dp[1] = 1;
        
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
};

public function exportUserSummary($workflow_id, Request $request)
{
$isValid = self::handleValidateUrl($workflow_id);
if ($isValid !== true) {
return $isValid;
}
$search_start_date = $request->start_date;
$search_end_date = $request->end_date;
$search_limit = $request->limit ?: 100;
$search_page = $request->page ?: 1;

$search_offset = ($search_page - 1) * $search_limit;

// Fetch user list

$rawList = SasageHelper::$companyObj->fetch_users($search_limit, $search_offset);
$userList = collect($rawList)->map(function ($obj) {
return collect($obj)->except(SasageHelper::$userHiddenProps);
});

// Fetch tracking data for all users
$trackingObj = new \Sasage\Tracking(SasageHelper::$sasageAuthentication);

$types = ['shoot', 'measure', 'data_input', 'confirm', 'sasage'];
$trackingList = [];
$fetchFailed = false;

foreach ($types as $type) {
$tempTrackingList = [];
$results = $trackingObj->fetch_user_daily_tracking($workflow_id, $type, $search_start_date, $search_end_date, -1, -1);
if (isset($results['errors'])) {
$fetchFailed = true;
break;
}
$tempTrackingList = array_merge($tempTrackingList, $results);
$trackingList = array_merge($trackingList, $tempTrackingList);
}
if ($fetchFailed) {
// Fetch failed
return response()->json([
'message' => 'Failed to fetch tracking.',
], 500);
}

// Init user summary props
foreach ($userList as $userIndex => $user) {
foreach ($types as $type) {
$user[$type . '_duration'] = 0;
$user[$type . '_total'] = 0;
$userList[$userIndex] = $user;
}
}

// Mapping all data in tracking list to user by user.id and tracking.created_by
foreach ($trackingList as $tracking) {
foreach ($userList as $userIndex => $user) {
if ($user['id'] === $tracking['created_by']) {
$user[$tracking['type'] . '_duration'] = $tracking['duration'];
$user[$tracking['type'] . '_total'] = count($tracking['product_ids']);
$userList[$userIndex] = $user;
}
}
}

// Create CSV file
$filename = "user_summary_{$workflow_id}_" . date('Ymd_His') . ".csv";
$handle = fopen($filename, 'w');
$header = [
'username',
'averageDuration',
'averageShootDuration',
'averageMeasureDuration',
'averageDataInputDuration',
'averageConfirmDuration'
];
fputcsv($handle, $header);

foreach ($userList as $user) {
fputcsv($handle, [
$user['username'],
$user['sasage_duration'],
$user['shoot_duration'],
$user['measure_duration'],
$user['data_input_duration'],
$user['confirm_duration'],
]);
}

fclose($handle);

return response()->download($filename);
}

(function firstPaintRemote() {
  // form rawGit proxy url
  var ghUrl = 'bahmutov/code-snippets/master/first-paint.js';
  var rawUrl = 'https://rawgit.com/' + ghUrl;
  // download and run the script
  var head = document.getElementsByTagName('head')[0];
  var script = document.createElement('script');
  script.type = 'text/javascript';
  script.src = rawUrl;
  head.appendChild(script);
}());

import React from 'react';

class MessageWithEvent extends React.Component {
   constructor(props) {
      super(props);

      this.logEventToConsole = this.logEventToConsole.bind();
   }
   logEventToConsole(e) {
      console.log(e.target.innerHTML);
   }
   render() {
      return (
         <div onClick={this.logEventToConsole}>
            <p>Hello {this.props.name}!</p>
         </div>
      );
   }
}
export default MessageWithEvent;

2 conflicts:
* `filter`: [dplyr]
* `lag`   : [dplyr]

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIM031dG965B0k/1d93L/pqTDiz7mRIDp19oz/WwFhpxB wendy.beaulac@finalsite.com

  UTC_DateTimeZone = DateTimeZone.UtcNow(),
  UTC_Date         = Date.From(UTC_DateTimeZone), 
  StartSummerTime  = Date.StartOfWeek(#date(Date.Year(UTC_Date), 3, 12), Day.Sunday),
  StartWinterTime  = Date.StartOfWeek(#date(Date.Year(UTC_Date), 11, 5), Day.Sunday),
                                      
  #"Added DTS OFFSET" = Table.AddColumn(#"Renamed columns 1", "DTS Offset", each if Date.From([createdon]) >= StartSummerTime and Date.From([createdon]) < StartWinterTime then 1 else 0),
  #"Added TIME ADJUST" = Table.AddColumn(#"Added DTS OFFSET", "Time Zone Adjustment", each if [Site_Name] = "CA" then 8 else if [Site_Name] = "TX" then 6 else if [Site_Name] = "TN" then 6 else 5, type any),

sudo -i
#pw
apt install curl ca-certificates -y
curl https://repo.waydro.id | sudo bash



#if that command fails run:
curl https://repo.waydro.id | sudo bash



#Now that the waydroid program is primed for installation, install it with:
apt install waydroid
apt update



#launch the Waydroid application. Install launch setting all default, except "Android type" which is set to gapps. 
#Click "Download", let android image download, click Done 



#To end waydroid session command is:
waydroid session stop



#To install apk file from host user's "Downloads" folder:
waydroid app install ~/Downloads/file_name_here.apk



#Verify app installation with:
waydroid app list



#Remove a app package
waydroid app remove packageName



##SHARE FILES BETWEEN HOST AND ANDROID IMAGE:
sudo mount --bind ~/Documents/vboxshare/ ~/.local/share/waydroid/data/media/0/Documents/share
##REPLACE ~/Documents/vboxshare - 'vboxshare' sub-folder in Ubuntu host
##REPLACE ~/.local/share/waydroid/data/media/0/Documents/share – ‘share’ sub-folder of Documents in Android. or Create directorys with matching names in each machine




###UNINSTALL WAYDROID###
waydroid session stop
sudo waydroid container stop
sudo apt remove --autoremove waydroid



#Remove leftover files and configurations and IF YOU DO NOT WISH TO REINSTALL WAYDROID RUN LAST COMMAND:
sudo rm -rf /var/lib/waydroid ~/aydroid ~/.share/waydroid ~/.local/share/applications/*waydroid* ~/.local/share/waydroid

sudo rm /etc/apt/sources.list.d/waydroid.list /usr/share/keyrings/waydroid.gpg

<script>
// Get all object elements
const objectElements = document.querySelectorAll('.relation-block object');

// Iterate over each object element
objectElements.forEach(objectElement => {
    // Listen for the load event on each object element
    objectElement.addEventListener('load', function() {
        // Get the SVG document inside the object element
        const svgDoc = objectElement.contentDocument;

        // Check if the SVG document is accessible
        if (svgDoc) {
            // Get all path elements inside the SVG document
            const pathElements = svgDoc.querySelectorAll('path');

            // Change the fill color of each path element to red
            pathElements.forEach(path => {
                path.style.fill = '#0c71c3';
            });
        } else {
            console.error('SVG document not accessible');
        }
    });
});

</script>

<a class="active [&.active]:bg-blue-400 bg-red-400">
Blue when active
</a>

function remove_pricing_post_type() {
    // Check if the custom post type exists before trying to unregister it
    if (post_type_exists('pricing')) {
        unregister_post_type('pricing');
    }
}
add_action('init', 'remove_pricing_post_type', 20); // The priority 20 ensures it runs after the custom post type is registered