Printable View
For those who like to keep your mind sharp or for those who want to test their skills in programming here is an interesting C programming bug:
This program will not print on the screen "out".. can you say why?:)Code:#include <stdio.h>
#include <unistd.h>
int main(int argc, char **argv)
{
while(1) {
fprintf(stdout, "out \t");
fprintf(stderr, "err \t");
sleep(1);
}
return 0;
}
It's not a bug!Quote:
Originally Posted by ralu.
standard out is buffered output, and that buffer is only flushed when:
a) it's full
b) you call fflush()
c) you print a \n
QuantumPete
edit:
Try this to illustrate:
Code:#include <stdio.h>
#include <unistd.h>
int main(int argc, char **argv)
{
int num = 5;
while(num--) {
fprintf(stdout, "out \t");
fprintf(stderr, "err \t");
sleep(1);
}
fprintf (stdout, "\n");
return 0;
}
And of course, it's all depending on the implementation of the C library. Sure, stderr is DEFINED as unbuffered, whilst stdout is buffered, but there is nothing saying that stdout has to have a buffer bigger than 1 character.
--
Mats
Here it is another interesting problem:
Code:#include <stdio.h>
int main(int argc, char **argv)
{
int i;
double num = 0.0;
for(i = 0; i < 10; i++)
num = num + 0.1;
if(num == 1.0)
printf("num == 1.0\n");
else
printf("num != 1.0\n");
return 0;
}
It's not interesting, it's a known fact of 0.1 being one of many numbers that can't be stored PRECISELY in the standard binary floating point formats. It becomes 0.09999999999999999999999 when you translate it back to decimal (the number of nines depend on the length of the binary format, and the actual printout with lots of digits may show some "random" values at the end, depending how the bits at the end match up with the digits printed).
Obviously, adding 0.09999999... together ten times leaves you with a number similar to 0.9999999... which is not precisely 1.0, so a comparison on a bit-level will see them as different numbers, even if a rounded printout will not!
--
Mats
Well, no. It's not an interesting problem, it's a floating point inaccuracy, which every programmer should be aware of. Just like buffered stdout. These are not hidden issues that you might never need to know about. This is stuff that anyone who seriously develops software in C has to know!Quote:
Originally Posted by ralu.
QuantumPete
matsp, QuantumPete i was not expecting the pb to be interesting for you, cause i know it's not... But on this forum are many newbies for whom this is interesting: the result is not what they expect it to be.
Maybe this you'll find a little more interesting:
Code:void send(register char *to, register char *from, register int count)
{
register int num = (count + 7) / 8;
switch(count % 8){
case 0: do { *to++ = *from++;
case 7: *to++ = *from++;
case 6: *to++ = *from++;
case 5: *to++ = *from++;
case 4: *to++ = *from++;
case 3: *to++ = *from++;
case 2: *to++ = *from++;
case 1: *to++ = *from++;
} while( --num > 0);
}
Duff's Device? You'll have to do better than that ;)Quote:
Originally Posted by ralu.
QuantumPete
Old "trying to be clever with memcpy thing" using case-labels inside the loop.
Yes, it's pretty clever, but if num is fairly large, it would make more sense to check if to and from are aligned, and cast the pointers to a larger type pointer (e.g. long), then copy larger blocks.
The use of register in modern compilers is at best a no-op, and if the compiler obeys you, may lead to less good register usage than if you do not give a register keyword. In essense: If you have not measured that register gives better performance, do not use it.
--
Mats
For 0.9999... with a finite sequence of digits (as in our machines), this is true. But mathematically speaking, 0.999... is really the same as 1. Here's the proof:Quote:
adding 0.09999999... together ten times leaves you with a number similar to 0.9999999... which is not precisely 1.0
1 = 3 * (1/3) = 0.999...
Dividing by 10 yields that 0.1 is the same as 0.09999...
The fact that 10*.1 != 1. is not due to rounding errors (there's no rounding involved here) but because the machine can only represent a finite number of decimal places.
Greets,
Philip
While I agree with your statement, I don't like the proof much..Quote:
Originally Posted by Snafuist
I've seen an imho better proof, here's more or less how it goes:
a = 0.99999...
10*a - a = 9.99999... - 0.99999... = 9
10*a - a = 9*a
9*a = 9
a = 1
You are right. My version is rather a hint, while yours might actually be considered a real proof.Quote:
While I agree with your statement, I don't like the proof much..
Greets,
Philip
How about this for a puzzle. What does the following print out on your console and more importantly, why?
QuantumPeteCode:#include <stdio.h>
int main (void)
{
int n = 0;
for (n = 0; n <= 1; ++n)
{
printf ("%d", n);
fork();
}
return 0;
}
Did you mean the amended code above? As your code won't compile...Quote:
Originally Posted by QuantumPete
And I have a fair idea what it will print... ;)
--
Mats
Yes, sorry, I've corrected my post. So used to using i as an iterator ;)Quote:
Originally Posted by matsp
Anyone want to venture a guess?
QuantumPete
(Although it could be 101 - since there is nothing determining which of the two threads run first, and thus which order the output is, child or parent).Code:011
--
Mats
Nope, neither of those is correct. ;)Quote:
Originally Posted by matsp
QuantumPete
If you flush the output, it's 011. If you don't, it's undefined ;). So your code is undefined.Quote:
Originally Posted by QuantumPete
only thing certain (apart from death and taxes! :devil:) is that the code spawns four distinct processess. The unbuffered output is:
and buffered output is:Code:01010101 /* Unbuffered */
Code:0
1
1
If u ran the program as it is you get:
If the output is redirected to a file, the same result is obtained.Code:01010101
If you put a \n after "%d" you get:
If the output is redirected to a file, this is obtained:Code:0
1
1
Code:0
1
0
1
0
1
The output which goes to a terminal is line buffered, if the output contains a newline then the buffer is flushed. If the line is longer than the buffer, it will be flushed sooner.
The output which goes to a file is fully buffered. This means that it gets flushed only when the buffer gets full even if there are "\n" in the output.
fork() creates a new process by duplicating the calling process; this implies that the data space of the parent process is copied to the data space of the child process. The data space includes the un-flushed buffers.
The output depends on when the output is flushed.
If it's after one character, the output is 011
If it's after two characters, the output is 0101
If it's after three characters or termination, the output is 01010101.
So it may really be any of those.
I've found this programming puzzle questions on a site && i thought to share them with you all:
Q1 Write a "Hello World" program in 'C' without using a semicolon.
Q2 Write a C++ program without using any loop (if, for, while etc) to
print numbers from 1 to 100 and 100 to 1;
Q3 C/C++ : Exchange two numbers without using a temporary variable.
Q4 C/C++ : Find if the given number is a power of 2.
Q5 C/C++ : Multiply x by 7 without using multiplication (*) operator.
Q6 C/C++ : Write a function in different ways that will return f(7) =
4 and f(4) = 7
Q7 Remove duplicates in array
Q8 Finding if there is any loop inside linked list.
Q9 Remove duplicates in an no key access database without using an
array
Q10 Write a program whose printed output is an exact copy of the
source. Needless to say, merely echoing the actual source file is not
allowed.
Q11 From a 'pool' of numbers (four '1's, four '2's .... four '6's),
each player selects a number and adds it to the total. Once a number
is used, it must be removed from the pool. The winner is the person
whose number makes the total equal 31 exactly.
Q12 Swap two numbers without using a third variable.
Given an array (group) of numbers write all the possible sub groups of
this group.
Q14 Convert (integer) number in binary without loops.
I only bothered to do the quine :P. Quite easy tasks, but I like the self-printing programs. I wrote this one before, so I redid what I memorized:
Code:#define A(x)#x;x
a=A(main(){printf("#define A(x)#x;x\na=A(%s)",a);})
Note that C99 doesn't require "return" explicitly:Quote:
Originally Posted by ralu.
Code:#include <stdio.h>
int main()
{
if(printf("Hello World!\n")) { }
}
Quote:
Q2 Write a C++ program without using any loop (if, for, while etc) to
print numbers from 1 to 100 and 100 to 1;
Code:cout << "1 2 3 4 ... 99 100" << endl;
cout << "100 99 ... 4 3 2 1" << endl;
Note that you may not abbreviate the following:Quote:
Q3 C/C++ : Exchange two numbers without using a temporary variable.
Code:int a, b;
a ^= b;
b ^= a;
a ^= b;
Bit twiddling or simply the following:Quote:
Q4 C/C++ : Find if the given number is a power of 2.
Code:log2(x) == floor(log2(x))
Quote:
Q5 C/C++ : Multiply x by 7 without using multiplication (*) operator.
Code:x = x+x+x+x+x+x+x;
/* or */
x = (x<<3) - x;
Quote:
Q6 C/C++ : Write a function in different ways that will return f(7) = 4 and f(4) = 7
Code:/* the obvious approach or this one: */
int f(int x)
{
return x ^ 3;
}
Where's the puzzle?Code:Q7 Remove duplicates in array
Haire-and-Tortoise approach / Classic Floyd's Cycle Finding Algorithm: Two pointers "slow" and "fast" pointing to the first element. "slow" advances one element per iteration, "fast" advances two. If slow == fast before the end is reached, the list contains a cycle.Quote:
Q8 Finding if there is any loop inside linked list.
See Q7.Quote:
Q9 Remove duplicates in an no key access database without using an array
Or better: write a program in C that prints a program in Perl that prints the original C program. Once done, this is easily extended to an arbitrary number of steps.Quote:
Q10 Write a program whose printed output is an exact copy of the source. Needless to say, merely echoing the actual source file is not allowed.
Too much overhead. Any volunteers? ;)Quote:
Q11 From a 'pool' of numbers (four '1's, four '2's .... four '6's),
each player selects a number and adds it to the total. Once a number
is used, it must be removed from the pool. The winner is the person
whose number makes the total equal 31 exactly.
Solved in Q3.Quote:
Q12 Swap two numbers without using a third variable.
Where's the puzzle?Quote:
Given an array (group) of numbers write all the possible sub groups of this group.
Quote:
Q14 Convert (integer) number in binary without loops.
Code:x;
Greets,
Philip
> Or better: write a program in C that prints a program in Perl that prints the original C program. Once done, this is easily extended to an arbitrary number of steps.
Copy that...
About the bit twiddling in the power of 2 question:Code:#define A(x)#x;x
a=A(main(){printf("print %c#define A(x)#x;x\na=A(%s)%c;",39,a,39);})
bool power_of_two(unsigned int n) { return n && (n & (n-1)) == 0; }
As to why the output is 01010101 when it's buffered; fork() duplicates the stdout buffer in the child process and their exit is equivalent to calling fflush(stdout) in each of the four distinct processes. That's why the buffer containing "01" is printed out 4 times. When stdout is flushed, the same program prints out 011.Quote:
Originally Posted by QuantumPete