Как добавить цифры продукта, а не сами продукты в C?

Question

Я пытаюсь завершить sh задание в C для курса CS50, в котором я должен реализовать алгоритм Луна для проверки номера кредитной карты. Вот краткий пример, который нужно уточнить:

---

номер кредитной карты: 4003600000000014.
Теперь для каждого другого di git, начиная с числа до второго номера di git:

1-0-0-0-0-6-0-4

Давайте умножим каждую из цифр на 2:

1 • 2 + 0 • 2 + 0 • 2 + 0 • 2 + 0 • 2 + 6 • 2 + 0 • 2 + 4 • 2

Это дает нам:

2 + 0 + 0 + 0 + 0 + 12 + 0 + 8

Теперь давайте сложим цифры этих продуктов (т.е. не сами продукты) вместе:

2 + 0 + 0 + 0 + 0 + 1 + 2 + 0 + 8 = 13

Теперь давайте добавим эту сумму (13) к сумме цифр, которые не были умножены на 2 (начиная с конца):

13 + 4 + 0 + 0 + 0 + 0 + 0 + 3 + 0 = 20

Да, последний ди git в этой сумме (20) равен 0, поэтому число действительно.

---

I Выяснили, как извлечь каждое число в кредитной карте по отдельности (я знаю, что мой путь скучен и, вероятно, не практичен), поэтому следующий шаг - умножить все остальные числа на два и добавьте (цифры продуктов, а не сами цифры), и это то, что мне нужно, чтобы помочь, как это сделать? МОЙ код:

#include <cs50.h>
#include <stdio.h>
#include <math.h>

int main(void)
{
    long credit_card_number;
    do
    {
        credit_card_number = get_long("Enter your credit card number: ");

    }
    while (credit_card_number < 1 || credit_card_number > 9999999999999999);

    //American Express uses 15-digit numbers. American Express numbers start with 34 or 37
    //MasterCard uses 16-digit numbers. MasterCard numbers start with 51, 52, 53, 54, or 55.
    //Visa uses 13- and 16-digit numbers. Visa numbers start with 4.
    // checksum

    long last_number;
    long credit_card_without_last_number;
    long second_to_last_number;
    long credit_card_without_second_number;
    long third_number;
    long credit_card_without_third_number;
    long fourth_number;
    long credit_card_without_fourth_number;
    long fifth_number;
    long credit_card_without_fifth_number;
    long sixth_number;
    long credit_card_without_sixth_number;
    long seventh_number;
    long credit_card_without_seventh_number;
    long eighth_number;
    long credit_card_without_eighth_number;
    long ninth_number;
    long credit_card_without_ninth_number;
    long tenth_number;
    long credit_card_without_tenth_number;
    long eleventh_number;
    long credit_card_without_eleventh_number;
    long twelfth_number;
    long credit_card_without_twelfth_number;
    long thirteenth_number;
    long credit_card_without_thirteenth_number;
    long fourteenth_number;
    long credit_card_without_fourteenth_number;
    long fifteenth_number;
    long credit_card_without_fifteenth_number;
    long sixteenth_number;

    long multiply_digits;

    //separating each number starting from the last (right)in its own variable.
    last_number = credit_card_number % 10;
    credit_card_without_last_number = credit_card_number / 10;

    second_to_last_number = credit_card_without_last_number % 10;
    credit_card_without_second_number = credit_card_without_last_number / 10;

    third_number = credit_card_without_second_number % 10;
    credit_card_without_third_number = credit_card_without_second_number / 10;

    fourth_number = credit_card_without_third_number % 10;
    credit_card_without_fourth_number = credit_card_without_third_number / 10;

    fifth_number = credit_card_without_fourth_number % 10;
    credit_card_without_fifth_number = credit_card_without_fourth_number / 10;

    sixth_number = credit_card_without_fifth_number % 10;
    credit_card_without_sixth_number = credit_card_without_fifth_number / 10;

    seventh_number = credit_card_without_sixth_number % 10;
    credit_card_without_seventh_number = credit_card_without_sixth_number / 10;

    eighth_number = credit_card_without_seventh_number % 10;
    credit_card_without_eighth_number = credit_card_without_seventh_number / 10;

    ninth_number = credit_card_without_eighth_number % 10;
    credit_card_without_ninth_number = credit_card_without_eighth_number / 10;

    tenth_number = credit_card_without_ninth_number % 10;
    credit_card_without_tenth_number = credit_card_without_ninth_number / 10;

    eleventh_number = credit_card_without_tenth_number % 10;
    credit_card_without_eleventh_number = credit_card_without_tenth_number / 10;

    twelfth_number = credit_card_without_eleventh_number % 10;
    credit_card_without_twelfth_number = credit_card_without_eleventh_number / 10;

    thirteenth_number = credit_card_without_twelfth_number % 10;
    credit_card_without_thirteenth_number = credit_card_without_twelfth_number / 10;

    fourteenth_number = credit_card_without_thirteenth_number % 10;
    credit_card_without_fourteenth_number = credit_card_without_thirteenth_number / 10;

    fifteenth_number = credit_card_without_fourteenth_number % 10;
    credit_card_without_fifteenth_number = credit_card_without_fourteenth_number / 10;

    sixteenth_number = credit_card_without_fifteenth_number % 10;

    //Here I need the help to multiply these numbers by two and then add each product's
    //digits to the rest of the unused numbers.
    multiply_digits = (second_to_last_number*2)+(fourth_number*2)+(sixth_number*2)+(eighth_number*2)+(tenth_number*2)+(twelfth_number*2)+(fourteenth_number*2)+(sixteenth_number*2);

}

Answer 1

Попробуйте сделать это вместо

int main(){
    long cNo = 4003600000000014;
    int arr[16];

    for(int i=0; i<16; i++){
        arr[15-i] = cNo % 10;
        cNo /= 10;
    }

    int multipliedSum = 0;
    for(int i=0; i<16; i++){
        if(i%2==1)
            multipliedSum += arr[i];
        else{
            if(arr[i]*2<10){
                multipliedSum += (arr[i]*2);
            }else{
                int num = arr[i]*2;
                while(num){
                    multipliedSum += num%10;
                    num/=10;
                }
            } 
        }
    }

    printf("valid = %s\n",multipliedSum%10==0?" True": " False");
}

Вы получите следующее

valid = True

Answer 2

Общий алгоритм добавления цифр (при условии целочисленного типа):

1. Инициализируйте вашу сумму равной 0: sum = 0
2. Извлеките младший ди git из числа используя оператор модуля %: digit = number % 10
3. Добавьте значение этого di git к сумме: sum += digit (сокращение для sum = sum + digit)
4. Разделите число на 10: number /= 10 (сокращение от number = number / 10
5. Если после деления на 10 число ненулевое, обратно на 2
6. Конец

Оператор модуля % возвращает целочисленный остаток от целочисленного деления - 123 / 10 == 12 rem 3. Таким образом, остаток от деления числа на 10 является наименьшим значащим десятичным числом git от числа. Обратите внимание, что целочисленное деление дает вам целое число результат - 123 / 10 == 12, а не 12.3.

Вы захотите поместить это в отдельную функцию, чтобы вы могли написать что-то вроде

int sumdig( int v )
{
  ...
}

int main( void )
{
   int value = 123;
   int sum = sumdig( value ); // sumdig will return 1 + 2 + 3, or 6
   ...
}

Когда вы создаете куча отдельных переменных одного и того же типа с тем же именем, за исключением некоторой привязанной ордина l (var1, var2, var3 или first_thing, second_thing, third_thing), это действительно сильный совет, который вы хотите использовать array . Вы можете использовать массив для хранения отдельных цифр номера вашей карты:

int number[16];

и использовать метод % 10, как описано выше, чтобы извлечь отдельные цифры:

long tmp = credit_card_number; // use a temporary so we preserve the original card number
for ( int i = 0; i < 16; i++ )
{
  number[i] = tmp % 10;
  tmp /= 10;
}

This означает, что наименее значащий (самый правый) номер карты di git будет сохранен в number[0], а самый значащий (крайний левый) номер карты di git будет сохранен в number[15], так что знайте об этом. Для проверки правильности числа это не имеет значения, но если вы хотите отобразить содержимое массива, вы должны принять это во внимание.

Использование массива облегчает извлечение подмножеств цифр:

for ( int i = 1; i < 16; i += 2 ) // hit every other element starting at element 1
{
  number[i] *= 2; // multiply these digits by 2
}

То, что выше l oop выполняет «1 • 2 + 0 • 2 + 0 • 2 + 0 • 2 + 0 • 2 + 6 • 2 + 0 • 2 + 4 • 2 "часть вашего алгоритма.

Вы должны быть в состоянии выяснить остальное оттуда. Надеюсь это поможет.

Answer 3

Подсказка: чтобы извлечь одно число git из числа, измените его на 10. Итак, скажем, что вы хотите выяснить сумму цифр числа, скажем 123456, вы будете делать следующее: (псевдокод)

number=123456;
sum=0;
loop if number is not 0{
sum+=number % 10;
number-=number % 10;
number=(int)(number/10);
}

Теперь попробуйте реализовать его как функцию, скажем digit(), и когда вы пытаетесь добавить несколько чисел di git -wise, скажем 123 и 456, просто вместо этого введите digit(123)+digit(456).