Getting Odd numbers in a array? [closed] - c

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 4 months ago.
Improve this question
I am begginer,I am faced with a challenge to take few numbers and multiply the odd numbers in them to apply the lunhs alogrithm.
Ex- If user inputs 100034341341313413941391341393413.
Is there any way I can take this input and specifically filter out the numbers in the odd places and even places and add them ?
Please just show me the way or how I can get it the number in a array and approach it.The rest i'll figure out.
Thanks in advance.

Answer 1

The last digit is always odd so start from there. To get last digit you can use Modulo Operator (%) which gives you remainder of a division. If you divide a number by 10 you get your number's very right digit. After that divide your number by 10 (not modulo) to remove right digit. Loop this process until you get 0.
int x = 72;
int last_digit = 72 % 10; // returns 2
int x = x / 10; // its 7.2 but its an int so x will be 7
Other approaches can be found in here.
#include <stdio.h>
void getSum(int n) {
// If n is odd then the last digit
// will be odd positioned
int isOdd = (n % 2 == 1) ? 1 : 0;
// To store the respective sums
int sumOdd = 0;
int sumEven = 0;
// While there are digits left process
while (n != 0) {
// If current digit is odd positioned
if (isOdd)
sumOdd += n % 10;
// Even positioned digit
else
sumEven += n % 10;
// Invert state
isOdd = !isOdd;
// Remove last digit
n /= 10;
}
printf("Sum odd = %d\n", sumOdd);
printf("Sum even = %d\n", sumEven);
}

Answer 2

To calculate LUHN algorithm on a string is always far better than doing it with an int variable, as the integer has a limited amount of memory to represent the numbers normally managed in a credit card. Normally credit card numbers are 20 digits long (but they can grow up to 24 or more), while long integers reach roughly 18 digits and make it impossible to get.
In addition to what was exposed above, the LUHN algorithm can be simulated as a DFA (Deterministic Finite Automaton) that can be easily implemented with a table and a loop, as follows:
#include <ctype.h>
#include <stdio.h>
#include <string.h>
const static char luhn_tab[][10] = {
{ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }, /* state 0, accepting state */
{ 11, 12, 13, 14, 15, 16, 17, 18, 19, 10 }, /* '' 1 */
{ 12, 13, 14, 15, 16, 17, 18, 19, 10, 11 },
{ 13, 14, 15, 16, 17, 18, 19, 10, 11, 12 },
{ 14, 15, 16, 17, 18, 19, 10, 11, 12, 13 },
{ 15, 16, 17, 18, 19, 10, 11, 12, 13, 14 }, /* '' 5 */
{ 16, 17, 18, 19, 10, 11, 12, 13, 14, 15 },
{ 17, 18, 19, 10, 11, 12, 13, 14, 15, 16 },
{ 18, 19, 10, 11, 12, 13, 14, 15, 16, 17 },
{ 19, 10, 11, 12, 13, 14, 15, 16, 17, 18 }, /* '' 9 */
{ 0, 2, 4, 6, 8, 1, 3, 5, 7, 9 }, /* state 10, accepting state */
{ 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 },
{ 2, 4, 6, 8, 0, 3, 5, 7, 9, 1 },
{ 3, 5, 7, 9, 1, 4, 6, 8, 0, 2 },
{ 4, 6, 8, 0, 2, 5, 7, 9, 1, 3 },
{ 5, 7, 9, 1, 3, 6, 8, 0, 2, 4 },
{ 6, 8, 0, 2, 4, 7, 9, 1, 3, 5 },
{ 7, 9, 1, 3, 5, 8, 0, 2, 4, 6 },
{ 8, 0, 2, 4, 6, 9, 1, 3, 5, 7 },
{ 9, 1, 3, 5, 7, 0, 2, 4, 6, 8 },
};
/* as the number of states is less than 32, we can use the bits of
* an integer to mark which states are accepting states and which aren't */
const static int accepting = (1 << 0) | (1 << 10);
int luhn_ok(char *s, size_t s_len)
{
s += s_len; /* point to the string end */
char st = 0; /* automaton state, initially zero */
while (s_len--) {
if (isdigit(*--s)) {
/* operate only on digits, skipping nondigits */
st = luhn_tab[st][*s - '0'];
}
}
/* accepting state only if final state is one of the marked
* bits in accepting */
return ((1 << st) & accepting) != 0;
} /* luhn_ok */
int main(int argc, char **argv)
{
for (int i = 1; i < argc; i++) {
printf("luhn_ok(\"%s\") == %s\n",
argv[i],
luhn_ok(argv[i],
strlen(argv[i]))
? "Good"
: "Bad");
}
} /* main */
As you see, the only difficulty lies in that I have to scan the string of digits from the rigth, instead of doing it from the left (to tie us to the odd/even position in the string) This can also be done from the left (I mean, with an automaton), but the automaton table grows up to 100 states (because we don't know if we start in an odd/even position from the left digit), instead of 20 of the table above /well, I have not minimized the table, but I think I will not get a table simpler than 100 states) Above, the state represents the expected LUHN remainder after processing the digits of the string, with 10 added if we are in an odd position or even. You will easily see that this matches the algorithm you have been given.
$ luhn "100034341341313413941391341393413" 12345678903
luhn_ok("100034341341313413941391341393413") == Bad
luhn_ok("12345678903") == Good
$ _
Note:
I have computed the 100 states table to allow computing the LUHN algorithm left to right, but finally I considered it cumbersome to add it here, as it adds no advantage to the computing (it is only interesting if you don't know in advance how long your string of digits will be, or if you are involved in a parsing algorithm that requires left to right parsing) If someone is interested, please ask for it in the comments, and I'll add it.