CareerCup

Just make the program read characters from stdin.
exit only if a random sequence is entered.
will not hog cpu. will take a long long time to terminate :)

From "man alarm" -> " sleep(3) may be implemented using SIGALRM;"

#include <stdio.h>
 #include <signal.h>
 #include <limits.h>
 #include <unistd.h>
 
 void sighandler(int sig){
     printf("Don't be alarmed!! \n");
 }
 
 void
 sleep_alarm(unsigned int secs)
 {   
     sigset_t new, susp;
     
     signal(SIGALRM, sighandler);
     
     sigemptyset(&new);
     sigaddset(&new, SIGALRM);
     sigprocmask(SIG_BLOCK, &new, &susp);
     
     alarm(secs);
     
     sigdelset(&susp, SIGALRM);
     sigsuspend(&susp);        
 }   
 
 int main(int argc, char *argv[]){
     int i;
     for (i = 0; i <= ULLONG_MAX; i++){
         sleep_alarm (100);
     }

 }

Set thread priority to lowest possible value (still settable in user space) and have a while loop that increments a large integer and exits when integer gets big enough. This doesn't hog the CPU from other running processes and never blocks. It's depedent on OS scheduling and system load, though.

Write a code to compute a very slow growing function like the Ackerman inverse. Since this function grows slowly it will take a long time before the variable's range is over when this is over we start over again. If we do this in nested loops then we could write a very long running program.

use all available mem on the machine to store a very very large integer.
Then, starting from 0, increment this integer by 1 in each loop iteration until
we get 0xfffffff ... ffffffff at the end

as an example, if you use 4 words to represent an int,
incrementing by one can be realized as follows:

int w[4];
w[0] += 1;
w[1] += (w[0] == 0);
w[2] += (w[1] == 0);
w[3] += (w[2] == 0);

open a file write somthing very very long :) to it. close the file and read it. Once file is completely rad, terminate the program.

I will do this via a huge ASM code that involves only NOP instruction, which consumes space, is executed but does nothing.

We can make the parent process wait for child pid and start child suspended. After forking we can do sigalarm for parent and SIGCONT the child once we elapse the 'longtime'

// sigalarm proc
	static int i;
	i++;
	if( i < longtime) {
		alarm(5);
	} else { // finish by waking up child
		kill(pid, SIGCONT);
	}

        // main
        pid = fork();

        // child process
	kill(getpid(), SIGSTOP);
	return 0;
       

       // parent process
       // start timer
       signal(SIGALRM, send_event);
	alarm(5);
       // wait for child; this will complete 
       // only when child is continued
	waitpid(childpid, &status, 0);

pthread_yield may prevent to hog cpu...?

#include <pthread.h>
#include <time.h>

int main() {
    time_t t = time(NULL);
    while(time(NULL) - t < 0xFFFFFFFF){
		pthread_yield();
	}
    return 0;
}

Does this do it?
I thought of a blocking read on a resource in my process (so no system resources) with a timeout. Then I searched for some correct code... could have only generated psuedo code from memory. Don't know if I could get away with that... :-( my Google interview is coming up :0! eek!
From:
stackoverflow.com/questions/3711830/set-a-timeout-for-reading-stdin

// timeout structure passed into select
    struct timeval tv;
    // fd_set passed into select
    fd_set fds;
    // Set up the timeout.  here we can wait for any number of hours.
    tv.tv_sec = 60*60*24;
    tv.tv_usec = 0;

    // Zero out the fd_set - make sure it's pristine
    FD_ZERO(&fds);
    // Set the FD that we want to read
    FD_SET(STDIN_FILENO, &fds); //STDIN_FILENO is 0
    // select takes the last file descriptor value + 1 in the fdset to check,
    // the fdset for reads, writes, and errors.  We are only passing in reads.
    // the last parameter is the timeout.  select will return if an FD is ready or 
    // the timeout has occurred
    select(STDIN_FILENO+1, &fds, NULL, NULL, &tv);
    // return 0 if STDIN is not ready to be read.
    return FD_ISSET(STDIN_FILENO, &fds);
}

I think solution should be some program using IO (but not one like scanf) or network connection or DB connection.

e.g.
1) program that will follow this,
a) write 1 byte at a time to a file upto XYZ MB or kb
b) delete that file
c) repeat steps a, b N number of times, depending on how long you want your prog to run.

2) Keep Sending XX bytes of data to some random ip address (not internal)

3) Assuming you have some RDB connection,
create small table in database and keep inserting and deleting single record in that table.

I think solution should be some program using IO (but not one like scanf) or network connection or DB connection.

e.g.
1) program that will follow this,
a) write 1 byte at a time to a file upto XYZ MB or kb
b) delete that file
c) repeat steps a, b N number of times, depending on how long you want your prog to run.

2) Keep Sending XX bytes of data to some random ip address (not internal)

3) Assuming you have some RDB connection,
create small table in database and keep inserting and deleting single record in that table.

my idea is to write a loop for printing data through a printer like..i=10000000000000000000000000000....000 then
while(i)
{
send data to printer to print;
i--;}

writing Socket server: accept system call block for client to connect, program keeps running until the process terminates.

Write a program to open a socket and calls "accept", it terminates whenever a client connects to it..

this question will exmamine you knowledge of computer Arch and OS, here is some of my idea:
1) make your C program work as an IST for a never-happend Interrupt
2)make your C program work as an handler for a never-happend SWI entry
3)make your C program able to change his PCB to give up his CPU cycle

Well I guess this guy is in the funny mood to ask this kinda question. However, I have the humorous solution for him..

Why don't U give a code of any recursive or backtracking problem.

I would have given Tower of Hanoi with 512 disk.. Code will not take forever to finish yet it will have a great deal of time... haha

No hogging no wait no resource blocking

It is not possible to write a program that runs very long, does not sleep and does hog cpu (unless its the OS for mars curiosity rover). A paradox. Probably they were testing Operating system knowledge.

Keep on doing some I/O operations in a tight loop for a longer duration.
Is it enough ?
for(.......)
{
scanf("%d",&n);
scanf("%d",&n);
................
}

Not sure but what about coding an operating system? It is in effect a really long program and it manages resource usage as well.

How about create some threads and dead lock themselves,

before that, set a timer that come back very very long time after to kill them all?

even simple statement as follows hogs the CPU :(

while(true);

what about a while loop that does nothing, with end condition the value of a flag. And toggle the value of the flag when a timer expires (and expires after a very very long time, as requested).

Just do a while loop setting end time to tomorrow

#include <time.h>
time_t starttime,endtime;

time(&starttime);
bool doloop = true;
while (doloop) { 
   time(&endtime);   //no guarantees that time will return seconds,generally so.
   if ((endtime  - starttime) > 86400) 
       doloop = false;   
}

Take any NP class problem & run the algorithm which never going end.