I wrote a function that reverses an integer (123 becomes 321) with recursion, and I was told that using global variables is bad practice, but I'm having trouble figuring out how to get the result from the function without using one. I tried declaring the variable inside the function, but then I get undesired results.
#include <stdio.h>
int result = 0;
int reverse_num(int num)
{
int remainder = num % 10;
if (num == 0) return 0;
result *= 10;
result += remainder;
reverse_num(num / 10);
return result;
}
int main(void)
{
int num, reversed_num;
printf("Insert number: ");
scanf("%d", &num);
reversed_num = reverse_num(num);
printf("Inverted number: %d", reversed_num);
return 0;
}
The common way to do this is to have another argument just for the accumulated result. It can be accomplished in C by splitting your function into the one called by the user and the one that does all the work.
int reverse_num_helper(int num, int result)
{
int remainder = num % 10;
if (num == 0) return result;
result *= 10;
result += remainder;
return reverse_num_helper(num / 10, result);
}
int reverse_num(int num)
{
return reverse_num_helper(num, 0);
}
(In C++ you could combine the two into int reverse_num(int num, int result = 0).)
Notice how your function is essentially unchanged.We made only two minor modifications:
returning result instead of zero when num reaches zero
invoking recursion with the modified result value
There are many ways. One way involves finding the most significant decimal digit per each recursion.
Below is an inefficient example.
Works OK for some values 0 to near INT_MAX/10.
#include <stdio.h>
int reverse_num(int num) {
if (num < 10) {
return num;
}
int pow10 = 10;
while (num/pow10 >= 10) {
pow10 *= 10;
}
int lead_digit = num/pow10;
return reverse_num(num % pow10) * 10 + lead_digit;
}
int main() {
printf("%d\n", reverse_num(123456789));
printf("%d\n", reverse_num(1));
printf("%d\n", reverse_num(100));
}
Output
987654321
1
1
Fails for others printf("%d\n", reverse_num(123000789)); --> 987321.
Improved: recursive and efficient.
static int reverse_num_helper(int num, int power10) {
if (power10 < 10) {
return num;
}
return reverse_num_helper(num % power10, power10 / 10) * 10 + num / power10;
}
int reverse_num(int num) {
int pow10 = 1;
while (num / pow10 >= 10) {
pow10 *= 10;
}
return reverse_num_helper(num, pow10);
}
int main() {
printf("%d\n", reverse_num(123000789));
printf("%d\n", reverse_num(123456789));
printf("%d\n", reverse_num(123));
printf("%d\n", reverse_num(1));
printf("%d\n", reverse_num(100));
}
Output
987000321
987654321
321
1
1
A somewhat more long-winded version of that given by #chux might be a bit clearer.
#include <stdio.h>
int count_places(int num);
int reverse_by_places(int num, int num_places);
int ipow(int base, int power);
int reverse_num(int num)
{
return reverse_by_places(num, count_places(num)) / 10;
}
int ipow(int base, int power)
{
if (power == 0)
return 1;
return base * ipow(base, power-1);
}
int count_places(int num)
{
int i;
if (num == 0)
return 1;
for (i = 0; num > 0; i++)
{
num /= 10;
}
return i;
}
int reverse_by_places(int num, int num_places)
{
int dividend = num / 10, remainder = num % 10;
if (dividend == 0)
return remainder * ipow(10, num_places);
else
return ((remainder * ipow(10, num_places)) + reverse_by_places(dividend, num_places-1));
}
int main(void)
{
int num, reversed_num;
printf("Insert number: ");
scanf("%d", &num);
reversed_num = reverse_num(num);
printf("Inverted number: %d\n", reversed_num);
return 0;
}
To keep it similar to your original code, only without the global variable, try this:
#include <stdio.h>
#define RESET (-1)
int reverse_num(int num)
{
static int result = 0;
int remainder = num % 10;
if (num < 0) {
result = 0;
return 0;
}
if (num == 0) return 0;
result *= 10;
result += remainder;
reverse_num(num / 10);
return result;
}
int main(void)
{
int num, reversed_num;
printf("Insert number: ");
scanf("%d", &num);
reverse_num(RESET);
reversed_num = reverse_num(num);
printf("Inverted number: %d\n", reversed_num);
return 0;
}
Here, I just make result into a local static variable in the function, which means it keeps its value even when the function returns (like a global variable, except that its scope is only within the function). The catch is that if you want to call it more than once, you need a way to reset the result value; I did this by using a negative value for num as a semaphore to reset.
int Reverse(int n,int Len) {
if (n == 0)
return 0;
return std::pow(10, Len-1)*(n % 10) + Reverse(n / 10, Len-1);
}
//inside main
Reverse(54321,5);
//Output Should be 12345
#include <stdio.h>
int max_of_four(int, int, int, int);
int main() {
int a, b, c, d;
printf("Enter 4 numbers -");
scanf("%d %d %d %d", &a, &b, &c, &d);
int ans = max_of_four(a, b, c, d);
printf("%d", ans);
return 0;
}
int max_of_four(int a, int b, int c, int d) {
int greatest, i = 0;
int num[4] = { a, b, c, d };
greatest = num[0];
while (i >= 3) {
if (greatest <= num[i]) {
greatest = num[i];
}
i++;
}
return greatest;
}
So I tried using a for loop to compare every number to a variable greatest.
But the answer for the greatest integer is always the first integer.
In max_of_four:
while (i >= 3) is never true because you start with i being 0, and 0 is not greater than or equal to 3. Perhaps you meant while (i <= 3), but you would normally write this loop using for rather than while:
for (int i = 0; i < 4; i++)
if (greatest <= num[i]) greatest = num[i];
The problem is with the while loop condition. The condition should have been while(i<=3).
int max_of_four(int a,int b ,int c, int d) {
int greatest,i = 0;
int num[4] = {a, b, c, d};
greatest = num[0];
while(i <= 3) {
if(greatest <= num[i]) {
greatest = num[i];
}
i++;
}
return greatest;
}
The test while (i >= 3) is incorrect, you probably meant to write this instead:
while (i <= 3)
Note that for loops are much more readable as you can group the initialization, test and increment of i in a single line:
for (i = 0; i <= 3; i++) {
if (greatest <= num[i]) {
greatest = num[i];
}
}
Note also that it is more consistent to use i < 4 instead of i <= 3 to make the array length more obvious.
Also, you do not need an array with 4 entries: 3 entries suffice as you initialize greatest to the first value already.
Here is a modified version:
int max_of_four(int a, int b, int c, int d) {
int greatest = a;
int num[3] = { b, c, d };
for (int i = 0; i < 3; i++) {
if (greatest < num[i]) {
greatest = num[i];
}
}
return greatest;
}
Finally, constructing an array to determine the maximum value among 4 integers is a bit of an overkill. Here is a much simpler version:
int max_of_four(int a, int b, int c, int d) {
if (a < b) a = b; // a = max(a, b)
if (c < d) c = d; // c = max(c, d)
if (a < c) a = c; // a = max(a, c)
return a;
}
If you must use a for loop, you can just wrap 3 simple tests into a dummy for statement:
int max_of_four(int a, int b, int c, int d) {
for (;;) {
if (a < b) a = b;
if (c < d) c = d;
if (a < c) a = c;
return a;
}
}
I'm trying to find nCr value. There is no error but I'm getting 1 as the answer for all the inputs. Help me find the solution please.
#include <stdio.h>
int fact(int num)
{
int f=1,i;
for(i=1;i<=num;i++)
{
f=f*1;
}
return f;
}
int main(void)
{
int n,r,ncr=0;
printf("\n enter n and r values");
scanf("%d%d",&n,&r);
ncr=(fact(n) / (fact(r) * fact(n-r)));
printf("\n ncr for %d and %d is %d",n,r,ncr);
return 0;
}
It should not be f = f *1, but rather f = f * i
Your factorial code is incorrect.
You set f = 1, then do f = f * 1 a bunch of times. Then return f which is still 1. I think you mean f = f*i right?
int fact(int num)
{
int f=1,i;
for(i=1;i<=num;i++)
{
f=f*i;
}
return f;
}
Your method to compute factorial needs a correction. Should be :
int fact(int num)
{
int f=1,i;
for(i=1;i<=num;i++)
{
f=f*i;
}
return f;
}
Also, nCr is not defined if r > n. You should add this check after your scanf call.
Something like :
if (r > n) printf("r cannot be greater than n.").
A more standard form of computing factorial is one that uses recursion.
int fact(int num)
{
if (num == 1 || num == 0)
return 1;
else
return (num * fact(num - 1));
}
A better and faster approach would be to calculate nCr like this
int nCr(int n, int r) {
if (r > n / 2) r = n - r;
int ans = 1, i;
for (i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
Q 1. Problem 5 (evenly divisible) I tried the brute force method but it took time, so I referred few sites and found this code:
#include<stdio.h>
int gcd(int a, int b)
{
while (b != 0)
{
a %= b;
a ^= b;
b ^= a;
a ^= b;
}
return a;
}
int lcm(int a, int b)
{
return a / gcd(a, b) * b;
}
int main()
{
int res = 1;
int i;
for (i = 2; i <= 20; i++)
{
res = lcm(res, i);
}
printf("%d\n", res);
return 0;
}
This is very simple but I don't understand how function "gcd" works; can somebody please help me understand the logic. (I know it returns the GCD of 2 numbers but why so many operations?)
To your second question: The GCD function uses Euclid's Algorithm. It computes A mod B, then swaps A and B with an XOR swap. A more readable version might look like this:
int gcd(int a, int b)
{
int temp;
while (b != 0)
{
temp = a % b;
a = b;
b = temp;
}
return a;
}
This problem can also be solved in a very clean way with recursion:
int gcd(int a, int b) {
int remainder = a % b;
if (remainder == 0) {
return b;
}
return gcd(b, remainder);
}
The GCD computation in C :
int gcd(int a, int b){
if (a && b) for(;(a %= b) && (b %= a););
return a | b;
}
The absolute value computation :
#include <limits.h>
unsigned int abso(int v){
const int mask = v >> (sizeof(int) * CHAR_BIT - 1);
return (v + mask) ^ mask;
}
I executed this statements for GCD :
#include<stdio.h>
#include<conio.h>
int main(){
int l, s,r;
printf("\n\tEnter value : ");
scanf("%d %d",&l,&s);
while(l%s!=0){
r=l%s;
l=s;
s=r;
}
printf("\n\tGCD = %d",s);
getch();
}
Using a bit of recursion and Objective-C
-(int)euclid:(int)numA numB:(int)numB
{
if (numB == 0)
return numA;
else
return ([self euclid:numB numB:numA % numB]);
}
Is there a simpler and better way to solve this problem because
I used too many variables.
I used so many if else statements
I did this using the brute force method
Write a program that receives three integers as input and outputs the numbers in increasing order.
Do not use loop / array.
#include <stdio.h>
main(){
int no1;
int no2;
int no3;
int sto;
int hi;
int lo;
printf("Enter No. 1: ");
scanf("%d", &no1);
printf("Enter No. 2: ");
scanf("%d", &no2);
printf("Enter No. 3: ");
scanf("%d", &no3);
if (no1>no2) {
sto=no1;
lo=no2;
} else {
sto=no2;
lo=no1;
}
if (sto>no3) {
hi=sto;
if(lo>no3){
sto=lo;
lo=no3;
}else {
sto=no3;
}
}else hi=no3;
printf("LOWEST %d\n", lo);
printf("MIDDLE %d\n", sto);
printf("HIGHEST %d\n", hi);
getch();
}
if (a > c)
swap(a, c);
if (a > b)
swap(a, b);
//Now the smallest element is the 1st one. Just check the 2nd and 3rd
if (b > c)
swap(b, c);
Note: Swap changes the values of two
variables.
Call the three variables x, y, and z, then:
if (x > y) swap(x, y);
if (y > z) swap(y, z)
if (x > y) swap(x, y);
Writing the swap function is left as an exercise for the reader. Hint: you may have to use pointers.
#include <stdio.h>
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
int main(){
int a, b, c;
int hi;
int lo;
printf("Enter No. 1: ");
scanf("%d", &a);
printf("Enter No. 2: ");
scanf("%d", &b);
printf("Enter No. 3: ");
scanf("%d", &c);
lo = min(min(a, b), c);
hi = max(max(a, b), c);
printf("LOWEST %d\n", lo);
printf("MIDDLE %d\n", a+b+c-lo-hi);
printf("HIGHEST %d\n", hi);
getchar();
}
If you want to sort the values into new external variables, you can actually do the swaps without temporaries:
void sort(int a, int b, int c, int *min, int *mid, int *max) {
min = a;
mid = b;
max = c;
if (min > mid) { mid = a; min = b; }
if (mid > max)
{
max = mid;
mid = c;
if (min > mid)
{
mid = min;
min = c;
}
}
}
This works because the last swap test is really only needed if the second test succeeds (otherwise it will simply be a repetition of the first test, which will fail by definition since we already sorted those variables).
Because of this, we can track the assignments of each of the original variables and avoid swap locals.
The following code performs only 2 (best case) to 3 (worst case) conditional tests, with no assignment operations nor any extra variables:
void echo(int _1st, int _2nd, int _3rd) { printf("%d %d %d", _1st, _2nd, _3rd); }
void echoFrom(int pivot, int x, int y) {
(pivot < y) ? ((x < y) ? echo(pivot, x, y) : echo(pivot, y, x)) : echo(y, pivot, x);
}
void printSorted(int a, int b, int c) { (a < b) ? echoFrom(a, b, c) : echoFrom(b, a, c); }
Basic call (scanf() stuff avoided for simplicity):
int main() {
printSorted(2,3,1); //Output: 1 2 3
}
To find the min, mid and max of 3 values, you can use the ternary operator. You can either do all your work within the main body of your code, or you can separate the minof3, midof3 and maxof3 calculations into reusable functions.
In the case of min and max you simply make 2 out of 3 possible comparisons, and then return a comparison of the results. In the case of mid, you do the same, but compute the min and max of the 3 values, and then check all 3 against min and max in order to find the value that is neither the min or max. (you can do this part in the main body of your code without an additional function by declaring the min and max values as variables and doing the elimination there).
Putting the pieces together, you could do something similar to the following, which takes the first 3 arguments as the values to sort (or uses defaults of 99, 231, 8 if a needed value isn't specified)
#include <stdio.h>
#include <stdlib.h>
/** direct ternary comparison of 3 values */
long minof3 (long a, long b, long c) {
long x = a < b ? a : b,
y = a < c ? a : c;
return x < y ? x : y;
}
long maxof3 (long a, long b, long c) {
long x = a > b ? a : b,
y = a > c ? a : c;
return x > y ? x : y;
}
long midof3 (long a, long b, long c) {
long x = a < b ? a : b,
y = a > b ? a : b,
z = y < c ? y : c;
return x > z ? x : z;
}
int main (int argc, char **argv) {
long x = argc > 1 ? strtol (argv[1], NULL, 10) : 99,
y = argc > 2 ? strtol (argv[2], NULL, 10) : 231,
z = argc > 3 ? strtol (argv[3], NULL, 10) : 8;
/* strtol validations omitted for brevity */
printf ("\n sorted values : %ld, %ld, %ld\n",
minof3 (x, y, z), midof3 (x, y, z), maxof3 (x, y, z));
}
Example Use/Output
$ ./bin/sort3
sorted values : 8, 99, 231
$ ./bin/sort3 -23 -281 1031
sorted values : -281, -23, 1031
(yes, I know this is an old post, but given the recent comment about code hidden behind the swap function, a full example was in order).
A compact solution sans magic swap() function, that dances around int overflow, and abuses arrays:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv) {
int a = atoi(argv[1]);
int b = atoi(argv[2]);
int c = atoi(argv[3]);
int ab[] = {a, b}, bc[] = {b, c};
int smaller[] = {ab[a > b], bc[b > c]}, larger[] = {ab[a < b], bc[b < c]};
int smallest = smaller[a > c], largest = larger[a < c];
int middle = (a - smallest) + (b - largest) + c;
printf("%d, %d, %d\n", smallest, middle, largest);
return 0;
}
USAGE
> ./a.out 2147483647 2147483645 2147483646
2147483645, 2147483646, 2147483647
>
#include <stdio.h>
int main()
{
int a;
int b;
int c;
//Temporary storage variable
int t = 0;
printf("Enter No. a: ");
scanf("%d", &a);
printf("Enter No. b: ");
scanf("%d", &b);
printf("Enter No. c: ");
scanf("%d", &c);
if (a > b)
{
t = a;
a = b;
b = t;
}
if (a > c)
{
t = a;
a = c;
c = t;
}
if (c < b)
{
t = c;
c = b;
b = t;
}
printf("a = %d < b = %d < c = %d", a, b, c);
return 0;
}
#include <stdio.h>
int main() {
int a,b,c;
printf("enter a b c values:\n");
scanf("%d%d%d",&a,&b,&c);
if(a<b && a<c)
{ printf("%d,",a);
if(b<c)
printf("%d,%d",b,c);
else
printf("%d,%d",c,b);
}
else if(b<a && b<c)
{
printf("%d,",b);
if(a<c)
printf("%d,%d",a,c);
else
printf("%d,%d",c,a);
}
else
{
printf("%d,",c);
if(a<b)
printf("%d,%d",a,b);
else
printf("%d,%d",b,a);
}
return 0;
}
int number1 = int.Parse(Console.ReadLine());
int number2 = int.Parse(Console.ReadLine());
int number3 = int.Parse(Console.ReadLine());
int swap = 0;
if (number2 > number1 && number2 > number3)
{
swap = number2;
number2 = number1;
number1 = swap;
}
else if (number3 > number2 && number3 > number1)
{
swap = number3;
number3 = number1;
number1 = swap;
}
if (number3 > number2)
{
swap = number2;
number2 = number3;
number3 = swap;
}
Console.WriteLine(number1 + "/" + number2 + "/" + number3);
Console.ReadKey();
I was attempting to solve the same problem today. Could make this compact version of code without using any temporary variables; loops; library functions like swap, sort, max, min, etc. The code uses only if statements and makes continuous mutations in the hierarchy until all possibilities are checked.
int main()
{
int a, b, c; //User inputs stored in these three variables
int first, second, third; //These three variables will store the sorted numbers in sequence
std::cout<<"Please enter three integers : "; //User input prompt
std::cin>>a>>b>>c;
first = a; //Initially assuming number 'a' is smallest
if (b <= a && b <= c) first = b; //Checking whether b is smallest
if (c <= a && c <= b) first = c; //Checking whether c is smallest
if (((a >= b && a <= c) || (a >= c && a <= b))) second = a; //Checking if a is middle number
if (((b >= a && b <= c) || (b >= c && b <= a))) second = b; //Checking if b is middle number
if (((c >= a && c <= b) || (c >= b && b <= a))) second = c; //Checking if c is middle number
if (a >= b && a >= c) third = a; //Checking if a is the greatest
if (b >= c && b >= a) third = b; //Checking if b is the greatest
if (c >= a && c >= b) third = c; //Checking if c is the greatest
std::cout<<"The numbers in ascending order are : "<<first<<", "<<second<<", "<<third<<std::endl;
}