#include<stdio.h>
#include <fcntl.h>
int main()
{
  int fd, sz;
  char *c = (char *) calloc(100, sizeof(char));

  fd = open("f1.txt", O_RDONLY);
  if (fd = = -1)
   {
   perror("r1");
   exit(1);
   }
  sz = read(fd, c, 10);
  printf("called read(% d, c, 10).  returned that" " %d bytes  were read.\n", fd, sz);
  c[sz] = '\0';
  printf("Those bytes are as follows: % s\n", c);
  return 0;
}

#include<stdio.h>
#include <fcntl.h>
Int main( )
{
  int sz;
 
  int fd = open("f1.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
  if (fd ==-1)
  {
     perror("r1");
     exit(1);
  }

  sz = write(fd, "hello linux", strlen("hello linux"));

  printf("called write(%d, \"hello linux\", %d). It returned %d\n", fd, strlen("hello linux"), sz);

  close(fd);
  return 0;
}

#include<stdio.h>
#include <fcntl.h>
int main()
{
    int fd1 = open("f1.txt", O_RDONLY);
    if (fd1 = = -1)
    {
	perror("c1");
	exit(1);
    }
    printf("opened the fd = % d\n", fd1);

    // Using close system Call
    if (close(fd1) = = -1)
    {
	perror("c1");
	exit(1);
    }
    printf("closed the fd.\n");
    return 0;
}

#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
 
int main()
{
        int file=0;
        if((file=open("testfile.txt",O_RDONLY)) < -1)
                return 1;
 
        char buffer[19];
        if(read(file,buffer,19) != 19)  return 1;
        printf("%s\n",buffer);
 
        if(lseek(file,10,SEEK_SET) < 0) return 1;
 
        if(read(file,buffer,19) != 19)  return 1;
        printf("%s\n",buffer);
 
        return 0;
}

#include<stdio.h>
int n,nf;
int in[100];
int p[50];
int hit=0;
int i,j,k;
int pgfaultcnt=0;

void getData()
{
    printf("\nEnter length of page reference sequence:");
    scanf("%d",&n);
    printf("\nEnter the page reference sequence:");
    for(i=0; i<n; i++)
        scanf("%d",&in[i]);
    printf("\nEnter no of frames:");
    scanf("%d",&nf);
}

void initialize()
{
    pgfaultcnt=0;
    for(i=0; i<nf; i++)
        p[i]=9999;
}

int isHit(int data)
{
    hit=0;
    for(j=0; j<nf; j++)
    {
        if(p[j]==data)
        {
            hit=1;
            break;
        }

    }

    return hit;
}
    
void lru()
{
    initialize();

    int least[50];
    for(i=0; i<n; i++)
    {

        printf("\nFor %d :",in[i]);

        if(isHit(in[i])==0)
        {

            for(j=0; j<nf; j++)
            {
                int pg=p[j];
                int found=0;
                for(k=i-1; k>=0; k--)
                {
                    if(pg==in[k])
                    {
                        least[j]=k;
                        found=1;
                        break;
                    }
                    else
                        found=0;
                }
                if(!found)
                    least[j]=-9999;
            }
            int min=9999;
            int repindex;
            for(j=0; j<nf; j++)
            {
                if(least[j]<min)
                {
                    min=least[j];
                    repindex=j;
                }
            }
            p[repindex]=in[i];
            pgfaultcnt++;

            for (k=0; k<nf; k++)
                if(p[k]!=9999)
                    printf(" %d",p[k]);
        }
        else
            printf("No page fault!");
    }
    printf("\nTotal no of page faults:%d",pgfaultcnt);
}


int main()
{
    getData();
    lru();
}

#include<stdio.h>

int size, base[100], limit[100], offset, flag, n;

int main() {
    printf("enter size of physical memory:");
    scanf("%d", &size);
    printf("enter no of segments:");
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        printf("enter limit of segment %d\n", i);
        scanf("%d", &limit[i]);
        if (limit[i] > size) {
            printf("\nlimit should not exceed physical memory\n");
            i--;
            continue;
        }
    }
    for (int i = 0; i < n; i++) {
        printf("enter base address of segment %d\n", i);
        scanf("%d", &base[i]);
        if (base[i] > size) {
            printf("\nbase address should not exceed physical memory\n");
            i--;
            continue;
        }
    }

    printf("segno\t\tbase\t\tlimit\n");
    for (int i = 0; i < n; i++) {
        printf("%d\t\t\t%d\t\t\t%d\n", i, base[i], limit[i]);
    }

    for (int i = 0; i < n; i++) {
        printf("seg %d occupied physical memory from %d to %d\n", i, base[i], base[i] + limit[i] - 1);
    }

    do {
        int j;
        printf("enter segment no");
        scanf("%d", &j);
        printf("enter offset");
        scanf("%d", &offset);
        printf("phy address %d\n", base[j] + offset);
        printf("to continue enter 1 else 0");
        scanf("%d", &flag);
    } while (flag != 0);

    return 0;
}

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

int in[100], p[20], n, nf;

void getData();

void getData() {
    printf("enter number of seq:");
    scanf("%d", &n);
    printf("enter seq:");
    for (int i = 0; i < n; i++) {
        scanf("%d", &in[i]);
    }
    printf("enter no of frames:");
    scanf("%d", &nf);
}

int isHit(int x) {
    for (int i = 0; i < nf; i++) {
        if (x == p[i])
            return 1;
    }
    return 0;
}

void display() {
    printf("status:\n");
    for (int i = 0; i < nf; i++)
        if (p[i] != 9999)
            printf("%d ", p[i]);
    printf("\n");
}

void fifo() {
    int pgfault = 0;
    for (int i = 0; i < nf; i++)
        p[i] = 9999;

    for (int i = 0; i < n; i++) {
        printf("for %d\n", in[i]);
        if (isHit(in[i]) == 0) {
            int k;
            for (k = 0; k < nf - 1; k++)
                p[k] = p[k + 1];
            p[k] = in[i];
            pgfault++;
            display();
        } else {
            printf("page fault does not exist\n");
        }
    }
    printf("no of pgfaults:%d", pgfault);
}

int main() {
    getData();
    fifo();
}

#include<stdio.h>
int n,nf;
int in[100];
int p[50];
int hit=0;
int i,j,k;
int pgfaultcnt=0;

void getData()
{
    printf("\nEnter length of page reference sequence:");
    scanf("%d",&n);
    printf("\nEnter the page reference sequence:");
    for(i=0; i<n; i++)
        scanf("%d",&in[i]);
    printf("\nEnter no of frames:");
    scanf("%d",&nf);
}

int isHit(int data)
{
    hit=0;
    for(j=0; j<nf; j++)
    {
        if(p[j]==data)
        {
            hit=1;
            break;
        }

    }

    return hit;
}

void dispPages()
{
    for (k=0; k<nf; k++)
        if(p[k]!=9999)
            printf(" %d",p[k]);
}

void optimal()
{
    pgfaultcnt=0;
    for(i=0; i<nf; i++)
        p[i]=9999;
    
    int near[50];
    for(i=0; i<n; i++)
    {

        printf("\nFor %d :",in[i]);

        if(isHit(in[i])==0)
        {

            for(j=0; j<nf; j++)
            {
                int pg=p[j];
                int found=0;
                for(k=i; k<n; k++)
                {
                    if(pg==in[k])
                    {
                        near[j]=k;
                        found=1;
                        break;
                    }
                    else
                        found=0;
                }
                if(!found)
                    near[j]=9999;
            }
            int max=-9999;
            int repindex;
            for(j=0; j<nf; j++)
            {
                if(near[j]>max)
                {
                    max=near[j];
                    repindex=j;
                }
            }
            p[repindex]=in[i];
            pgfaultcnt++;

            dispPages();
        }
        else
            printf("No page fault");
    }
    printf("\nTotal no of page faults:%d",pgfaultcnt);  
}   

int main()
{
    getData();
    optimal();
}

*SYSTEM CALLS PROGRAMS*

Write()

#include<unistd.h>

int main()

{

	write(1,”Hello”,5)

}

read()

#include<unistd.h>

int main()

{

Char b[30];

read(0,b,10);

write(1,b,10);

}

Open 

#include <stdio.h>

#include <fcntl.h>

#include <unistd.h>

int main() {

    int fd;

    char *filename = "example.txt";

    

    // Open the file for reading and writing, create if it doesn't exist

    fd = open(filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);

    printf("File opened successfully!\n");

    

    // Close the file

    close(fd);

    printf("File closed successfully!\n");

    

    return 0;

}

lseek

#include <stdio.h>

#include <fcntl.h>

#include <unistd.h>

int main() {

    int fd;

    off_t offset;

    // Open the file for reading

    fd = open("example.txt", O_RDONLY);

    

    // Move the file offset to a specific position (e.g., 100 bytes from the beginning)

    offset = lseek(fd, 100, SEEK_SET);

    

    // Close the file

    close(fd);

    

    return 0;

}

stat. This information includes details such as file size, permissions, inode number, timestamps, and more.

#include <stdio.h>

#include <sys/stat.h>

int main() {

    const char *filename = "example.txt";

    struct stat file_stat;

    // Call the stat system call to retrieve information about the file

    stat(filename, &file_stat);

    // Display file information

    printf("File Size: %ld bytes\n", file_stat.st_size);

    printf("File Permissions: %o\n", file_stat.st_mode & 0777);

    printf("Inode Number: %ld\n", file_stat.st_ino);

    return 0;

}

Open the current directory, Read directory entries

#include <stdio.h>

#include <dirent.h>

int main() {

    DIR *dir;

    struct dirent *entry;

    // Open the current directory

    dir = opendir(".");

    if (dir == NULL) {

        perror("opendir");

        return 1;

    }

    // Read directory entries

    while ((entry = readdir(dir)) != NULL) {

        printf("%s\n", entry->d_name);

    }

    // Close the directory

    closedir(dir);

    return 0;

}

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#define FIFO_NAME "myfifo"

int main() {

    int fd;

    char *message = "Hello from writer process!";

    

    // Create the FIFO if it does not exist

    if (mkfifo(FIFO_NAME, 0666) == -1) {

        perror("mkfifo");

        exit(EXIT_FAILURE);

    }

    // Open the FIFO for writing

    fd = open(FIFO_NAME, O_WRONLY);

    if (fd == -1) {

        perror("open");

        exit(EXIT_FAILURE);

    }

    // Write the message to the FIFO

    if (write(fd, message, strlen(message) + 1) == -1) {

        perror("write");

        close(fd);

        exit(EXIT_FAILURE);

    }

    printf("Writer: Wrote message to FIFO.\n");

    

    // Close the FIFO

    close(fd);

    return 0;

}

#include <stdio.h>

#include <unistd.h>

#include <string.h>

int main() {

    int fd[2]; // Array to hold the two ends of the pipe: fd[0] for reading, fd[1] for writing

    pid_t pid;

    char writeMessage[] = "Hello from parent process!";

    char readMessage[100];

    // Create the pipe

    if (pipe(fd) == -1) {

        perror("pipe failed");

        return 1;

    }

    // Fork a child process

    pid = fork();

    if (pid < 0) {

        perror("fork failed");

        return 1;

    } else if (pid > 0) {

        // Parent process

        close(fd[0]); // Close the reading end of the pipe in the parent

        // Write a message to the pipe

        write(fd[1], writeMessage, strlen(writeMessage) + 1);

        close(fd[1]); // Close the writing end of the pipe after writing

        // Wait for child process to finish

        wait(NULL);

    } else {

        // Child process

        close(fd[1]); // Close the writing end of the pipe in the child

        // Read the message from the pipe

        read(fd[0], readMessage, sizeof(readMessage));

        printf("Child process received: %s\n", readMessage);

        close(fd[0]); // Close the reading end of the pipe after reading

    }

return 0;

}

Why we love Cookies
We use cookies to try and give you a better experience in Freshdesk.

You can learn more about what kind of cookies we use, why, and how from our Privacy Policy. If you hate cookies, or are just on a diet, you can disable them altogether too. Just note that the Freshdesk service is pretty big on some cookies (we love the choco-chip ones), and some portions of Freshdesk may not work properly if you disable cookies.

We’ll also assume you agree to the way we use cookies and are ok with it as described in our Privacy Policy, unless you choose to disable them altogether through your browser.

#include <stdio.h>
int main() {
    int n, total_waiting_time = 0, total_turnaround_time = 0;
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    int arrival_time[n], burst_time[n], waiting_time[n], turnaround_time[n], temp;
    for (int i = 0; i < n; i++) {
        printf("Enter arrival time and burst time for process %d: ", i + 1);
        scanf("%d %d", &arrival_time[i], &burst_time[i]);
    }
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (burst_time[j] > burst_time[j + 1]) {
                temp = burst_time[j];
                burst_time[j] = burst_time[j + 1];
                burst_time[j + 1] = temp;

                temp = arrival_time[j];
                arrival_time[j] = arrival_time[j + 1];
                arrival_time[j + 1] = temp;
            }
        }
    }
 printf("Process\tWaiting Time\tTurnaround Time\n");
    int current_time = 0;
    for (int i = 0; i < n; i++) {
        waiting_time[i] = current_time - arrival_time[i] < 0 ? 0 : current_time - arrival_time[i];
        turnaround_time[i] = waiting_time[i] + burst_time[i];
        total_waiting_time += waiting_time[i];
        total_turnaround_time += turnaround_time[i];
        printf("%d\t%d\t\t%d\n", i + 1, waiting_time[i], turnaround_time[i]);
        current_time += burst_time[i];
    }
    printf("Average Waiting Time: %.2f\n", (float)total_waiting_time / n);
    printf("Average Turnaround Time: %.2f\n", (float)total_turnaround_time / n);
    return 0;
}

#include <stdio.h>
int main() {
    int n, total_waiting_time = 0, total_turnaround_time = 0;
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    int arrival_time[n], burst_time[n], waiting_time[n], turnaround_time[n];
    for (int i = 0; i < n; i++) {
        printf("Enter arrival time and burst time for process %d: ", i + 1);
        scanf("%d %d", &arrival_time[i], &burst_time[i]);
    }
    printf("Process\tarrivaltime\tbursttime\tWaiting Time\tTurnaround Time\n");
    int current_time = 0;
    for (int i = 0; i < n; i++) {
        waiting_time[i] = current_time - arrival_time[i] < 0 ? 0 : current_time - arrival_time[i];
        turnaround_time[i] = waiting_time[i] + burst_time[i];
        total_waiting_time += waiting_time[i];
        total_turnaround_time += turnaround_time[i];
        printf("%d\t\t\t%d\t\t\t%d\t\t\t%d\t\t\t\t%d\n",arrival_time[i],burst_time[i], i + 1, waiting_time[i], turnaround_time[i]);
        current_time += burst_time[i];
    }
    printf("Average Waiting Time: %.2f\n", (float)total_waiting_time / n);
    printf("Average Turnaround Time: %.2f\n", (float)total_turnaround_time / n);
    return 0;
}

const XLSX = require("xlsx");
const fs = require("fs");
const path = require("path");

const filePath = "3Status.xlsx"; //File path of excel

const workbook = XLSX.readFile(filePath);
const worksheet = workbook.Sheets["Sheet0"];
const data = XLSX.utils.sheet_to_json(worksheet);
const folderPath = "test"; //File path of git TCs
const filePaths = [];

function getFilePaths(directory) {
  const items = fs.readdirSync(directory);
  for (const item of items) {
    const itemPath = path.join(directory, item);
    if (fs.statSync(itemPath).isDirectory()) {
      getFilePaths(itemPath);
    } else {
      filePaths.push(itemPath);
    }
  }
}
getFilePaths(folderPath);
function newProc(filePaths, keyword) {
  let flag1 = false;
  for (const singlePath of filePaths) {
    const fileContent = fs.readFileSync(singlePath, "utf-8");
    //console.log("fileContent is ", fileContent)
    if (fileContent.includes(keyword)) {
      flag1 = true;
      //console.log(`Keyword '${keyword}' found in file: ${singlePath}`);
    }
  }
  return flag1;
}
let notAutomated = [];
for (const i of data) {
  let flag = false;
  let check = newProc(filePaths, i["TestRail Id"]);
  //console.log("check is ", check)
  if (check == false) {
    notAutomated.push(i["TestRail Id"]);
    //console.log(`${i["TestRail Id"]} is not automated`)
  }
}
console.log(`notAutomated TCs are `, notAutomated);
console.log("No.of notAutomated are ", notAutomated.length);

//Storing the notAutomated ones in the excel file
const values = ["NonAutomatedTestRailIds", ...notAutomated];
const workbook1 = XLSX.utils.book_new();
const worksheet1 = XLSX.utils.aoa_to_sheet([]);
values.forEach((value, index) => {
  const cellAddress = XLSX.utils.encode_cell({ c: 0, r: index }); // column 0, row index
  worksheet1[cellAddress] = { v: value };
});
worksheet1["!ref"] = XLSX.utils.encode_range({
  s: { c: 0, r: 0 },
  e: { c: 0, r: values.length - 1 },
});
XLSX.utils.book_append_sheet(workbook1, worksheet1, "Sheet1");
XLSX.writeFile(workbook1, "NonAutomatedTestRailIdsFile.xlsx");

methodName

optional

import java.util.*;
public class HeapSort {
    public static void heapSort(Integer[] array){
        buildMaxHeap(array);

        for(int i=array.length-1;i>0;i--){
            swap(array,0,i);
            maxHeapify(array,i,0);
        }
    }
    public static void buildMaxHeap(Integer[] array){
        int n=array.length;
        for(int i=n/2-1;i>=0;i--){
            maxHeapify(array,n,i);
        }
    }
    private static void maxHeapify(Integer[] array,int heapsize,int rootindex){
        int largest=rootindex;
        int leftchild=2*rootindex+1;
        int rightchild=2*rootindex+2;

        if(leftchild<heapsize && array[leftchild]>array[largest]){
            largest=leftchild;
        }
        if(rightchild<heapsize && array[rightchild]>array[largest]){
            largest=rightchild;
        }
        if(largest!=rootindex){
            swap(array,rootindex,largest);

            maxHeapify(array, heapsize, rootindex);
        }
    }
    private static void swap(Integer[] array,int i,int j){
        int temp=array[i];
        array[i]=array[j];
        array[j]=temp;
    }
    public static void main(String args[]){
        Integer[] array={12,11,13,5,6,7};
        System.out.println("Original array:"+Arrays.toString(array));

        heapSort(array);

        System.out.println("Sorted array:"+Arrays.toString(array));
    }
}

// C Program for Message Queue (Reader Process) 
#include <stdio.h> 
#include <sys/ipc.h> 
#include <sys/msg.h> 

// structure for message queue 
struct mesg_buffer { 
	long mesg_type; 
	char mesg_text[100]; 
} message; 

int main() 
{ 
	key_t key; 
	int msgid; 

	// ftok to generate unique key 
	key = ftok("progfile", 65); 

	// msgget creates a message queue 
	// and returns identifier 
	msgid = msgget(key, 0666 | IPC_CREAT); 

	// msgrcv to receive message 
	msgrcv(msgid, &message, sizeof(message), 1, 0); 

	// display the message 
	printf("Data Received is : %s \n", 
					message.mesg_text); 

	// to destroy the message queue 
	msgctl(msgid, IPC_RMID, NULL); 

	return 0; 
} 

// C Program for Message Queue (Writer Process) 
#include <stdio.h> 
#include <sys/ipc.h> 
#include <sys/msg.h> 
#define MAX 10 

// structure for message queue 
struct mesg_buffer { 
	long mesg_type; 
	char mesg_text[100]; 
} message; 

int main() 
{ 
	key_t key; 
	int msgid; 

	// ftok to generate unique key 
	key = ftok("progfile", 65); 

	// msgget creates a message queue 
	// and returns identifier 
	msgid = msgget(key, 0666 | IPC_CREAT); 
	message.mesg_type = 1; 

	printf("Write Data : "); 
	fgets(message.mesg_text,MAX,stdin); 

	// msgsnd to send message 
	msgsnd(msgid, &message, sizeof(message), 0); 

	// display the message 
	printf("Data send is : %s \n", message.mesg_text); 

	return 0; 
} 

#include<stdio.h>  
#include<stdlib.h>  
#include<unistd.h>  
#include<sys/shm.h>  
#include<string.h>  
int main()  
{  
int i;  
void *shared_memory;  
char buff[100];  
int shmid;  
shmid=shmget((key_t)2345, 1024, 0666|IPC_CREAT);   
//creates shared memory segment with key 2345, having size 1024 bytes. IPC_CREAT is used to create the shared segment if it does not exist. 0666 are the permissions on the shared segment  
printf("Key of shared memory is %d\n",shmid);  
shared_memory=shmat(shmid,NULL,0);   
//process attached to shared memory segment  
printf("Process attached at %p\n",shared_memory);   
//this prints the address where the segment is attached with this process  
printf("Enter some data to write to shared memory\n");  
read(0,buff,100); //get some input from user  
strcpy(shared_memory,buff); //data written to shared memory  
printf("You wrote : %s\n",(char *)shared_memory);  
}  

#include<stdio.h>  
#include<stdlib.h>  
#include<unistd.h>  
#include<sys/shm.h>  
#include<string.h>  
int main()  
{  
int i;  
void *shared_memory;  
char buff[100];  
int shmid;  
shmid=shmget((key_t)2345, 1024, 0666);  
printf("Key of shared memory is %d\n",shmid);  
shared_memory=shmat(shmid,NULL,0); //process attached to shared memory segment  
printf("Process attached at %p\n",shared_memory);  
printf("Data read from shared memory is : %s\n",(char *)shared_memory);  
}  

/*** Insert into tablet + mobile CSS for ROW ***/
display:flex;
flex-wrap:wrap;

/*** Insert into tablet + mobile CSS for the second COLUMN ***/
order:-1;

#include<stdio.h>
int n;
int main()
{
int seq[30],fr[5],pos[5],find,flag,max,i,j,m,k,t,s;
int count=1,pf=0,p=0;
float pfr;
printf("Enter maximum limit of the sequence: ");
scanf("%d",&max);
printf("\nEnter the sequence: ");
 for(i=0;i<max;i++)
scanf("%d",&seq[i]);
 printf("\nEnter no. of frames: ");
 scanf("%d",&n);
fr[0]=seq[0];
pf++;
printf("%d\t",fr[0]);
i=1;
while(count<n)
{
flag=1; p++;
for(j=0;j<i;j++)
{
if(seq[i]==seq[j]) flag=0;
}
if(flag!=0)
{
 fr[count]=seq[i];
 printf("%d\t",fr[count]);
 count++;
pf++;

}
i++;
}
 
printf("\n");
for(i=p;i<max;i++)
{
flag=1;
for(j=0;j<n;j++)
{
if(seq[i]==fr[j])
flag=0;
}
if(flag!=0)

{
for(j=0;j<n;j++)
{
m=fr[j];
for(k=i;k<max;k++)
{
if(seq[k]==m)
{
    pos[j]=k;
     break;

 }
else
pos[j]=1;

}
}
for(k=0;k<n;k++)
{
if(pos[k]==1)
flag=0;
}
if(flag!=0)
s=findmax(pos);
 if(flag==0)
{
for(k=0;k<n;k++)
{
if(pos[k]==1)
{
s=k;
 break;
}
}
}
fr[s]=seq[i];
for(k=0;k<n;k++)
printf("%d\t",fr[k]);
pf++;
printf("\n");
}
}
pfr=(float)pf/(float)max;
printf("\nThe no. of page faults are %d",pf);
printf("\nPage fault rate %f",pfr);
getch();
}
int findmax(int a[])
{
int max,i,k=0;
max=a[0];
for(i=0;i<n;i++)
{
if(max<a[i])
{
  max=a[i];
   k=i;
}
}
return k;
}

#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>
#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<stdlib.h>
int mutex=1,full=0,empty=3,x=0;
int 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("\nEnter 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("Producer produces the item %d\n",x);
   mutex=signal(mutex);
}
void consumer()
{
   mutex=wait(mutex);
   full=wait(full);
   empty=signal(empty);
   printf("Consumer consumes item %d\n",x);
   x--;
   mutex=signal(mutex);
}

#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 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, 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, 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>

#define MAX_PROCESSES 100
#define INF 100000 // A large number to represent infinity

int main() {
    int n;
    int pid[MAX_PROCESSES], arrival[MAX_PROCESSES], burst[MAX_PROCESSES], remaining[MAX_PROCESSES];
    int wait[MAX_PROCESSES], turn[MAX_PROCESSES], completion[MAX_PROCESSES];

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

    // Input arrival time and burst time for each process
    for (int i = 0; i < n; i++) {
        pid[i] = i + 1;
        printf("Enter arrival time for process %d: ", pid[i]);
        scanf("%d", &arrival[i]);
        printf("Enter burst time for process %d: ", pid[i]);
        scanf("%d", &burst[i]);
        remaining[i] = burst[i]; // Initially, remaining time is equal to burst time
    }

    int currentTime = 0, completed = 0;
    int shortest, minRemaining;

    while (completed != n) {
        shortest = -1;
        minRemaining = INF;

        // Find the process with the shortest remaining time among the processes that have arrived
        for (int i = 0; i < n; i++) {
            if (arrival[i] <= currentTime && remaining[i] > 0 && remaining[i] < minRemaining) {
                minRemaining = remaining[i];
                shortest = i;
            }
        }

        if (shortest == -1) {
            currentTime++;
        } else {
            remaining[shortest]--;
            currentTime++;

            if (remaining[shortest] == 0) {
                completed++;
                completion[shortest] = currentTime;
                turn[shortest] = completion[shortest] - arrival[shortest];
                wait[shortest] = turn[shortest] - burst[shortest];
            }
        }
    }

    // Print process information
    printf("PID\tArrival Time\tBurst Time\tWaiting Time\tTurnaround Time\tCompletion Time\n");
    for (int i = 0; i < n; i++) {
        printf("%d\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n",
               pid[i], arrival[i], burst[i], wait[i], turn[i], completion[i]);
    }

    // Calculate and print average waiting and turnaround times
    float totalWait = 0, totalTurnaround = 0;
    for (int i = 0; i < n; i++) {
        totalWait += wait[i];
        totalTurnaround += turn[i];
    }

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

    return 0;
}

#include <stdio.h>

#define MAX_PROCESSES 100

int main() {
    int n;
    int burst[MAX_PROCESSES], wait[MAX_PROCESSES], turn[MAX_PROCESSES], arrival[MAX_PROCESSES], pid[MAX_PROCESSES];
    int completion[MAX_PROCESSES], isCompleted[MAX_PROCESSES] = {0};

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

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

    int currentTime = 0, completed = 0;
    while (completed != n) {
        int shortest = -1;
        int minBurst = 100000; // A large number to represent infinity

        // Find process with shortest burst time among the processes that have arrived
        for (int i = 0; i < n; i++) {
            if (arrival[i] <= currentTime && !isCompleted[i] && burst[i] < minBurst) {
                minBurst = burst[i];
                shortest = i;
            }
        }

        if (shortest == -1) {
            currentTime++;
        } else {
            currentTime += burst[shortest];
            completion[shortest] = currentTime;
            turn[shortest] = completion[shortest] - arrival[shortest];
            wait[shortest] = turn[shortest] - burst[shortest];
            isCompleted[shortest] = 1;
            completed++;
        }
    }

    // Print process information
    printf("PID\tArrival Time\tBurst Time\tWaiting Time\tTurnaround Time\tCompletion Time\n");
    for (int i = 0; i < n; i++) {
        printf("%d\t%d\t\t%d\t\t%d\t\t%d\t\t%d\n", pid[i], arrival[i], burst[i], wait[i], turn[i], completion[i]);
    }

    // Calculate and print average waiting and turnaround times
    float totalWait = 0, totalTurnaround = 0;
    for (int i = 0; i < n; i++) {
        totalWait += wait[i];
        totalTurnaround += turn[i];
    }

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

    return 0;
}

#include <stdio.h>

int main(void) {
    int n, at[10], bt[10], ct[10], tat[10], wt[10], sum, i, j, k;
    float totaltat = 0, totalwt = 0;

    // Prompt user to enter the number of processors
    printf("Enter No of processors: ");
    scanf("%d", &n);

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

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

    // Initialization of the first sum to the arrival time of the first process
    sum = at[0];

    // Calculation of completion times for each processor
    for(j = 0; j < n; j++) {
        sum = sum + bt[j];  // Increment sum by the burst time
        ct[j] = sum;        // Set completion time for the current process
    }

    // Calculation of turn around time
    for(k = 0; k < n; k++) {
        tat[k] = ct[k] - at[k];    // Turnaround time is completion time minus arrival time
        totaltat = totaltat + tat[k];  // Accumulate total turnaround time
    }

    // Calculation of waiting time
    for(i = 0; i < n; i++) {
        wt[i] = tat[i] - bt[i];    // Waiting time is turnaround time minus burst time
        totalwt = totalwt + wt[i]; // Accumulate total waiting time
    }

    // Print the results
    printf("Process\tAT\tBT\tCT\tTAT\tWT\n");
    for(i = 0; i < n; i++) {
        printf("\nP%d\t%d\t%d\t%d\t%d\t%d\t\n", i + 1, at[i], bt[i], ct[i], tat[i], wt[i]);
    }

    // Print average turnaround time and average waiting time
    printf("average of turn around time: %0.1f\n", totaltat / n);
    printf("average of waiting time: %0.1f\n", totalwt / n);

    return 0;
}

Hi,
I am trying to find the sum of a variable from 1440 files using cdo enssum. But I am getting this error regarding too many files open. What is the max no of supported files?
Using v1.9.7.


ulimit -n 1024
Or any other value, just keep the value greater than your no of files

I'm trying to merge NetCDF files with ncrcat:

ncrcat drycblles.default.000* drycblles.default.nc
This works fine, unless some files have overlapping times, in which case I get time records like this:

t = 0, 300, 600, 900, 1200, 1500, 1800, 2100, 2400, 2700, 3000, 3300, 3600,
3900, 4200, 4500, 4800, 5100, 5400, 5700, 6000, 6300, 6600, 6900, 7200,
3900, 4200, 4500, 4800, 5100, 5400, 5700, 6000, 6300, 6600, 6900, 7200, ...

CDO has an option to remove duplicate records with e.g.

export SKIP_SAME_TIME=1

Example INFO already used
_________________________
Id,QuoteNumber,Account__r.Name,Opportunity.ID_opportunit__c	CreatedDate
0Q0SW000000aXK20AM 00142736 E.ON ENERGIA SPA Opportunity OPP-306625	2024-05-24T12:09:00.00
_________________________
1 Select an Domestico Client (ex.Ehsan)
2 Generate Opporunity 
3 Populate correct Installazione Indirizzo
4 Create Quote
5 Select the desired Offer and products
6 Populate desired MOP and inside the correct Fatturazione Indirizzo
7 While reaching Completato Step, Change the Account on the Opportunity level with the B2B one (Eon Energia)
where link is : https://eon-likes-customers.lightning.force.com/lightning/r/Account/001D0000018wNCxIAM/view?ws=%2Flightning%2Fr%2FQuote%2F0Q0SW000000aXK20AM%2Fview
8 DONT FORGET change the OIts 
SELECT Id, Cod_Voce_Fatturabile__c,vlocity_cmt__OneTimeCharge__c
FROM OrderItem      
where Order.OrderNumber = '00277954'

craft.app.fields.fieldByHandle('workTimeMode')

"_components/accordion.twig"

{% macro header(collapseId, title, textClass) %}
...
{% endmacro %}
 
 ----------------------------------------------------
 "_entry/types/content/jobs/jobs.twig"
 
 {% import '_components/accordion.twig' as accordion %}
 ...
 ...
 ...
 {{ accordion.header(collapseId, 'Pensum', 'jobs__selected-filter-label') }}
 

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

#define SHM_SIZE 1024  // Size of shared memory segment

int main() {
    int shmid;
    key_t key;
    char *shm, *s;

    // Generate the same unique key used by the other program
    key = ftok(".", 'a');

    // Locate the shared memory segment
    shmid = shmget(key, SHM_SIZE, 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(1);
    }

    // Attach the shared memory segment
    shm = shmat(shmid, NULL, 0);
    if (shm == (char *) -1) {
        perror("shmat");
        exit(1);
    }

    // Read from the shared memory segment
    for (s = shm; *s != '\0'; s++) {
        putchar(*s);
    }
    putchar('\n');

    // Signal to the other process that we've finished reading
    *shm = '*';

    // Detach the shared memory segment
    if (shmdt(shm) == -1) {
        perror("shmdt");
        exit(1);
    }

    return 0;
}

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

#define SHM_SIZE 1024  // Size of shared memory segment

int main() {
    int shmid;
    key_t key;
    char *shm, *s;

    // Generate a unique key for the shared memory segment
    key = ftok(".", 'a');

    // Create the shared memory segment
    shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(1);
    }

    // Attach the shared memory segment
    shm = shmat(shmid, NULL, 0);
    if (shm == (char *) -1) {
        perror("shmat");
        exit(1);
    }

    // Write to the shared memory segment
    s = shm;
    for (char c = 'a'; c <= 'z'; c++) {
        *s++ = c;
    }
    *s = '\0'; // Null-terminate the string

    // Wait for the other process to read the data
    while (*shm != '*') {
        sleep(1);
    }

    // Detach the shared memory segment
    if (shmdt(shm) == -1) {
        perror("shmdt");
        exit(1);
    }

    // Delete the shared memory segment
    if (shmctl(shmid, IPC_RMID, NULL) == -1) {
        perror("shmctl");
        exit(1);
    }

    return 0;
}

vector<int> Primrlist()
{
    isPrime[0]=isPrime[1]=false;
    for(int i=0;i<N;++i)
    {
        if(isPrime[i]==true)
        {
            for(int j=2*i;j<=N;j+=i)
            isPrime[j]=0;
        }
    }
    return isPrime;
}

python -m venv myenv 
source myenv/bin/activate  
deactivate  

Listings of tutoring services, online courses, test preparation, and educational services to support learners of all levels. 

du -hs /tmp ~/.[!.]* ~/* | sort -h