Challenge Q's


#1

I could use some help on the challenge Q’s.

Part 1 says to write a program that shows you how much a float “consumes”.

Here is what I came up with:

#include <stdio.h>

float *ptr;

int main(int argc, const char * argv[])
{

int i = 17;
int *addressOfI = &i;
printf("i stores its value at %p\n", addressOfI);
*addressOfI = 89;
printf("Now i is %d\n", i);
printf("An int is %zu bytes\n", sizeof(i));
printf("A pointer is %zu bytes\n", sizeof(addressOfI));

printf(“A float is %zu bytes\n”, sizeof(float));
//This tells me the the float is 4 bytes. Is this correct? Is this the same as consuming?

return 0;

}

Part 2 ask about the limits for the short :

I had to look up on google but here what I came across, the smallest is -32767 while the largest is 32767. Then, the largest # an unsigned short can store would be 65535.

This is where I got the information:

http://stackoverflow.com/questions/589575/size-of-int-long-etc

signed char: -127 to 127 (note, not -128 to 127; this accommodates 1's-complement platforms)
unsigned char: 0 to 255
"plain" char: -127 to 127 or 0 to 255 (depends on default char signedness)
signed short: -32767 to 32767
unsigned short: 0 to 65535
signed int: -32767 to 32767
unsigned int: 0 to 65535
signed long: -2147483647 to 2147483647
unsigned long: 0 to 4294967295
signed long long: -9223372036854775807 to 9223372036854775807
unsigned long long: 0 to 18446744073709551615

I would just like to confirm these are correct since there weren’t any post on these challenges.


#2

I came up with this

#include <stdio.h>

int main(int argc, const char * argv[])
{
int ranger = 0;
int value = 1;
for (int place = 1; place < 16; place ++) {
ranger = ranger + value;
value =2;
}
printf(“The largest value a short can hold is %d\nThe smallest is %d\n”, ranger,-ranger);
printf(“The largest value an unsigned short can hold is %d\n”, ranger
2 +1);
return 0;
}

Output

The largest value a short can hold is 32767
The smallest is -32767
The largest value an unsigned short can hold is 65535
Program ended with exit code: 0

And as far as the first one, it looks correct.


#3

The smallest is even smaller: it is -32768, not -32767.

...
short v = 0x7fff;
printf ("short - largest: %d\n", v);

v = 0x8000;   // negative numbers are represented in twos complement
printf ("short - smallest: %d\n", v);
...
short - largest: 32767
short - smallest: -32768

#4

Here is the lazy way out that I found…

#include <limits.h> // <- need to include this for SHRT_MIN, SHRT_MAX, USHRT_MAX

//First challenge
printf(“Size in bytes of a float is %zu\n”, sizeof(float);

//Second challenge
printf(“Minimum value of a signed short is %d\n”, SHRT_MIN);
printf(“Maximum value of a signed short is %d\n”, SHRT_MAX);
printf(“Maximum value of a unsigned short is %d\n”, USHRT_MAX);


#5

Looking at previous posts, I may have reinvented the wheel. Here was my attempt at solving Challenge 2 programatically:

[code]#include <stdio.h>
#include <math.h>

int bytesToBits(bytes){
return bytes * 8;
}

float unsignedMax(bits){
return pow(2, bits);
}

float signedMin(bits){
return (-1) * pow(2, (bits-1));
}

float signedMax(bits){
return (pow(2, bits-1)-1);
}

int main(int argc, const char * argv[])
{
printf(“The range of an unsigned short is from 0 to %.0f\n”, unsignedMax(bytesToBits(sizeof(short))));
printf(“The range of a signed short is from %.0f to %.0f\n”, signedMin(bytesToBits(sizeof(short))), signedMax(bytesToBits(sizeof(short))));
}[/code]


#6

I think I will simply use the SHRT_MIN, SHRT_MAX, USHRT_MAX solution :wink:


#7

The book doesn’t give us any SHRT_MIN, SHRT_MAX, USHRT_MAX yet. So i decided to make the challenge upon the information i got.
Here’s my solution:

[b]#include <stdio.h>

int main(int argc, const char * argv[])
{
short x = 0;
while (x > -1) {
x++;
}
x–;
printf(“The largest value of short is %d.\n”, x);
x = 0;
while (x < 1) {
x–;
}
x++;
printf(“The smallest value of short is %d.\n”, x);
unsigned short y = 1;
while (y > 0) {
y++;
}
y–;
printf(“The largest value of unsigned short is %d.\n”, y);
return 0;
}[/b]

And that’s what we got:

The largest value of short is 32767.
The smallest value of short is -32768.
The largest value of unsigned short is 65535.
Program ended with exit code: 0


#8

Very similar to your solution:

[code]#include <stdio.h>

int main(int argc, const char * argv[])
{
// Declare a variable X of type short and assign a value 0
short x = 0;
// Create a while loop, conditional statement: 'while x is greater than -1’
while (x > -1) {
// Increment x by 1
x++;
// Print the value of x after each increment
printf("%d\n", x);

/* It's a long output but displays what happens when the number is reached at its maximum value, 32768 - it starts back from minimum value, -32768. */
}
return 0;

}
[/code]


#9

[quote=“SaidNunaev”]The book doesn’t give us any SHRT_MIN, SHRT_MAX, USHRT_MAX yet. So i decided to make the challenge upon the information i got.
Here’s my solution:

[b]#include <stdio.h>

int main(int argc, const char * argv[])
{
short x = 0;
while (x > -1) {
x++;
}
x–;
printf(“The largest value of short is %d.\n”, x);
x = 0;
while (x < 1) {
x–;
}
x++;
printf(“The smallest value of short is %d.\n”, x);
unsigned short y = 1;
while (y > 0) {
y++;
}
y–;
printf(“The largest value of unsigned short is %d.\n”, y);
return 0;
}[/b]

And that’s what we got:

The largest value of short is 32767.
The smallest value of short is -32768.
The largest value of unsigned short is 65535.
Program ended with exit code: 0
[/quote]

SaidNun, why do you decrement your x variable after incrementing it? It looks like it worked, but I don’t understand why.

My solution wasn’t as elegant, but I was able to answer the question. Note: I did not code for the unsigned int.

[code]printf(“The memory held by float is %lu.\n”, (sizeof(float)) );

short int smallestNumber;
short int largestNumber;



for (smallestNumber = 0; smallestNumber <= 0; smallestNumber--)
    {
        printf("The smallest number a short int can store is %d.\n", smallestNumber);
    }

for (largestNumber = 0; largestNumber >= 0; largestNumber++)
    {
    
        printf("The largest number a short int can store is %d.\n", largestNumber);
    }

}[/code]

This code prints each number from 0 to either limit. How would I code it to only print the final numbers?

Thanks


#10

I don’t speak english well, but i’ll try to explain.
Because the while loop continuous while conditional x>-1 is true (I started from 0). When x riches the largest amount (32767) it still x>-1 and the loop increments x one more time. Then x becomes the lowest amount (it can’t be larger then 32767 so it goes around and start from the lowest again). The conditional x>-1 is now false, and the while loop ends.
So the final amount of x is now to be decremented to get it back to the largest amount.


#11

#include <stdio.h>

int main(int argc, const char * argv[])
{
// how much memory float consumes

printf("a float is %zu bytes\n", sizeof(float));

// what is the smallest number a short can hold and its largest

short x , y;

for (x; x > -1; x++) {
    continue;
}

for (y; y < 1; y--) {
    continue;
}

printf("%d\n %d\n", x, y);

// same question but unsigned small instead

unsigned short i;

for (i; i < 1; i--) {
    continue;
}
printf("%d\n", i);

return 0;

}

why no one likes for loops they give you less writing :stuck_out_tongue:


#12

There are bugs in this code:

[quote][code]…
short x , y;

for (x; x > -1; x++) {
continue;
}

for (y; y < 1; y–) {
continue;
}

}[/code][/quote]
Initialize all variables explicitly before using them.

[Accelerate your learning and become a competent programmer: pretty-function.org]


#13

[quote=“ibex10”]There are bugs in this code:

[quote][code]…
short x , y;

for (x; x > -1; x++) {
continue;
}

for (y; y < 1; y–) {
continue;
}

}[/code][/quote]
Initialize all variables explicitly before using them.

[Accelerate your learning and become a competent programmer: pretty-function.org][/quote]

where are the bugs ?
the code is working just perfect


#14

It is working by accident, not by design :slight_smile:

Initialize all variables explicitly before using them.
Initialize all variables explicitly before using them.
Initialize all variables explicitly before using them.


#15

[quote=“ibex10”]It is working by accident, not by design :slight_smile:

Initialize all variables explicitly before using them.
Initialize all variables explicitly before using them.
Initialize all variables explicitly before using them.[/quote]

do u know how to solve it ?


#16

[quote=“ibex10”]It is working by accident, not by design :slight_smile:

Initialize all variables explicitly before using them.
Initialize all variables explicitly before using them.
Initialize all variables explicitly before using them.[/quote]

sorry I was so confused yesterday now I understand what you mean!

Here is the perfect code :slight_smile:


#include <stdio.h>

int main(int argc, const char * argv[])
{
    // how much memory float consumes

    printf("a float consumes %zu bytes\n\n", sizeof(float));
    
    // what is the smallest number a short can hold and its largest
    
    short x;
    short y;
    
    for (x = 0; x > -1; x++) {
        continue;
    }
    
    for (y = 0; y < 1; y--) {
        continue;
    }

    printf("\nSmallest short %d\nlargest short %d\n", x, y);
    
    // same question but unsigned short instead
    
    unsigned short i;
    
    for (i = 0; i < 1; i--) {
        continue;
    }
    printf("largest unsigned short is %d\n", i);
    
    return 0;
}

#17

So in other words, once the value hits 32768 the sign bit is set to 1, so the value becomes -0. 32769 would be -1, 32770 would be -2, etc. Keep counting until the value becomes high enough where the sign bit would revert to 0 again and it starts counting up positive numbers again.