La mise en œuvre de l'algorithme de Luhn

Malheureusement, aucun des codes ci-dessus a fonctionné pour moi. Mais j'ai trouvé sur GitHub une solution de travail

//takes the form field value and returns true on valid number
function valid_credit_card(value) {
//accept only digits, dashes or spaces
    if (/[^0-9-\s]+/.test(value)) return false;

//The Luhn Algorithm. It's so pretty.
    var nCheck = 0, nDigit = 0, bEven = false;
    value = value.replace(/\D/g, "");

    for (var n = value.length - 1; n >= 0; n--) {
        var cDigit = value.charAt(n),
            nDigit = parseInt(cDigit, 10);

        if (bEven) {
            if ((nDigit *= 2) > 9) nDigit -= 9;
        }

        nCheck += nDigit;
        bEven = !bEven;
    }

    return (nCheck % 10) == 0;
}

Tables de recherche ou les tableaux peuvent simplifier des implémentations d'algorithmes - enregistrer le nombre de lignes de code et avec cette augmentation de la performance... si le calcul de l'index de recherche est simple - ou plus simple - et le tableau de la mémoire est abordable.

D'autre part, de comprendre comment le particulier recherche tableau ou une structure de données est venu à être peut parfois être très difficile, puisque le liés à l'implémentation de l'algorithme peut paraître à première vue, assez différente de l'original de l'algorithme de spécification ou une description.

Indication à utiliser les tables de recherche nombre orienté algorithmes avec un simple calcul, des comparaisons simples, et aussi structuré répétition de motifs - et bien sûr de tout à fait finis les ensembles de valeurs.

Le nombre de réponses dans ce thread aller à différentes tables de recherche et que pour les différents algorithmes à mettre en œuvre le même algorithme de Luhn. La plupart des implémentations utilisez la recherche tableau d'éviter la lourdeur de trouver de la valeur pour le doublé chiffres:

var   luhnArr   =   [0,   2,   4,   6,   8,   1,   3,   5,   7,   9];
//
//                  ^    ^    ^    ^    ^    ^    ^    ^    ^    ^
//                  |    |    |    |    |    |    |    |    |    |
//
//- d-igit=index:   0    1    2    3    4    5    6    7    8    9
//- 1st 
//   calculation: 2*0  2*2  2*2  2*3  2*4  2*5  2*6  2*7  2*8  2*9 
//- intermeduate
//         value: = 0  = 2  = 4  = 6  = 8  =10  =12  =14  =16  =18
//- 2nd
//   calculation:                          1+0  1+2  1+4  1+6  1+8
//
//- final value:    0    2    4    6    8   =1   =3   =5   =7   =9
//      
var luhnFinalValue = luhnArray[d]; //d is numeric value of digit to double

Une égalité de mise en œuvre pour l'obtention de la luhnFinalValue ressemble à ceci:

var luhnIntermediateValue = d * 2; //d is numeric value of digit to double
var luhnFinalValue = (luhnIntermediateValue < 10)
        ? luhnIntermediateValue           //(d    ) * 2;
        : luhnIntermediateValue - 10 + 1; //(d - 5) * 2 + 1;

Qui - avec les commentaires ci-dessus le vrai et le faux des termes est bien sûr simplifié:

var luhnFinalValue = (d < 5) ? d : (d - 5) * 2 + 1;

Maintenant, je ne suis pas sûr si j'ai "sauvé" rien du tout... 😉 surtout grâce à la valeur formée ou la forme abrégée de si-alors-sinon. Sans elle, le code peut ressembler à ceci - avec 'ordonnée' blocs
et incorporée dans la prochaine contexte supérieurs de la couche de l'algorithme et donc luhnValue:

var luhnValue; //card number is valid when luhn values for each digit modulo 10 is 0

if (even) { //even as n-th digit from the the end of the string of digits
    luhnValue = d;
} else { //doubled digits
    if (d < 5) {
        luhnValue = d * 2;
    } else {
        lunnValue = (d - 5) * 2 + 1;
    }
}

Ou:

var luhnValue = (even) ? d : (d < 5) ? d * 2 : (d - 5) * 2 + 1;

Btw, moderne, optimisation des interprètes et (juste à temps) des compilateurs, la différence n'est que dans le code source et les questions uniquement pour des raisons de lisibilité.

Venus de loin avec explication - et la "justification" de l'utilisation de tables de recherche et de comparaison à droite, avant le codage, la table de recherche semble maintenant un peu exagéré pour moi. L'algorithme sans est maintenant très facile de finition, et il a l'air assez compact trop:

function luhnValid(cardNo) { //cardNo as a string w/digits only
    var sum = 0, even = false;
    cardNo.split("").reverse().forEach(function(dstr){ d = parseInt(dstr);
        sum += ((even = !even) ? d : (d < 5) ? d * 2 : (d - 5) * 2 + 1);
      });
    return (sum % 10 == 0);
  }

Ce qui me frappe, après être passé par l'explication de l'exercice est que, à l'origine, les plus alléchantes de la mise en œuvre - une aide à réduire() à partir de @kalypto - vient de perdre totalement son lustre pour moi... pas seulement parce qu'il est défectueux à plusieurs niveaux, mais plus encore parce qu'il montre que les cloches et de sifflets ne peut pas toujours "l'anneau de la victoire bell'. Mais merci à vous, @kalypto, il m'a fait réellement utiliser - et de comprendre - réduire():

function luhnValid2(cardNo) { //cardNo as a string w/digits only
    var d = 0, e = false; //e = even = n-th digit counted from the end
    return ( cardNo.split("").reverse().reduce(
                 function(s,dstr){ d = parseInt(dstr); //reduce arg-0 - callback fnc
                     return (s + ((e = !e) ? d : [0,2,4,6,8,1,3,5,7,9][d]));
                   } ///end of callback fnc
                ,0 //reduce arg-1 - prev value for first iteration (sum)
                ) % 10 == 0
           );
  }

D'être fidèle à ce fil, un peu plus de recherche options de la table doivent être mentionnés:

• que diriez-vous simplement ajuster varues pour doublé chiffres - posté par @yngum
• que diriez-vous simplement tout avec des tables de recherche - posté par @Simon_Weaver - où également les valeurs de la non-doublé chiffres sont prises à partir d'une table.
• que diriez-vous simplement tout avec juste UNE table de recherche - comme inspirés par l'utilisation d'un décalage comme le fait dans le longuement discuté luhnValid() fonction.

Le code pour le dernier - à l'aide de réduire - peut ressembler à ceci:

function luhnValid3(cardNo) { //cardNo as a string w/digits only
    var d = 0, e = false; //e = even = n-th digit counted from the end
    return ( cardNo.split("").reverse().reduce(
          function(s,dstr){ d = parseInt(dstr);
              return (s + [0,1,2,3,4,5,6,7,8,9,0,2,4,6,8,1,3,5,7,9][d+((e=!e)?0:10)]);
            }
         ,0
         ) % 10 == 0
      );
  }

Et de fermeture de lunValid4() - très compact - et en utilisant simplement 'à l'ancienne' (compatible) JavaScript - avec une seule table de recherche:

function luhnValid4(cardNo) { //cardNo as a string w/digits only
  var s = 0, e = false, p = cardNo.length; while (p > 0) { p--;
    s += "01234567890246813579".charAt(cardNo.charAt(p)*1 + ((e=!e)?0:10)) * 1; }
  return (s % 10 == 0);
 }

Corollar: Chaînes peut être regardé comme des tables de caractères... 😉

Un parfait exemple d'une belle table de recherche de l'application est le comptage de bits bits listes de bits dans un (très) long octet de 8 bits chaîne (interprété) langage de haut niveau (où toutes les opérations sur les bits sont assez cher). La table de recherche a 256 entrées. Chaque entrée contient le nombre de bits dans un entier non signé de 8 bits de l'entier égal à l'indice de l'entrée. Une itération à travers la chaîne et la prise de la non signé de 8 bits de l'octet de valeur égale, l'accès le nombre de bits de cet octet de la table de recherche. Même pour le langage de bas niveau - comme assembleur /code machine - la table de recherche est la voie à suivre... surtout dans un environnement où le microcode (instruction) peut gérer plusieurs octets jusqu'à 256 ou plus dans un (unique CDCI) de l'instruction.

Quelques remarques:

• numberString * 1 et parseInt(numberStr) concernant le même.
• il y a quelques superflu des indentations, les parenthèses,etc... soutenir mon cerveau dans l'obtention de la sémantique plus rapide... mais certains que je voulais sortir, sont réellement nécessaires... quand
  il s'agit d'opérations arithmétiques à court formulaire, la valeur-si-alors-sinon expressions comme des termes.
• une certaine mise en forme peut sembler nouveau pour vous; pour des exemples, j'utilise la continuation de la virgule avec le
  continuation sur la même ligne que la continuation, et j' "fermer" les choses de la moitié d'un onglet en retrait de l'ouverture de l'élément.
• Le formatage est fait pour l'homme, pas l'ordinateur... " il " n'moins de soins.

algorithme discbased luhn lookuptable carte validation bitlist

Si vous voulez calculer la somme de contrôle, ce code à partir de cette page est très concis et dans mes essais aléatoires semble fonctionner.

REMARQUE: la vérification algorithmns sur cette page n'ont PAS tout le travail.

//Javascript
String.prototype.luhnGet = function()
{
    var luhnArr = [[0,1,2,3,4,5,6,7,8,9],[0,2,4,6,8,1,3,5,7,9]], sum = 0;
    this.replace(/\D+/g,"").replace(/[\d]/g, function(c, p, o){
        sum += luhnArr[ (o.length-p)&1 ][ parseInt(c,10) ]
    });
    return this + ((10 - sum%10)%10);
};

alert("54511187504546384725".luhnGet());​

Voici mon résultats pour C#

Code est le suivant:

var LuhnCheck = (function()
{
    var luhnArr = [0, 2, 4, 6, 8, 1, 3, 5, 7, 9];
    return function(str)
    {
        var counter = 0;
        var incNum;
        var odd = false;
        var temp = String(str).replace(/[^\d]/g, "");
        if ( temp.length == 0)
            return false;
        for (var i = temp.length-1; i >= 0; --i)
        {
            incNum = parseInt(temp.charAt(i), 10);
            counter += (odd = !odd)? incNum : luhnArr[incNum];
        }
        return (counter%10 == 0);
    }
})();

La variable counter est la somme de tous les chiffres en position impaire, plus du double des chiffres dans les même positions, quand le double de plus de 10 nous ajouter les deux chiffres qui en font (ex: 6 * 2 -> 12 -> 1 + 2 = 3)

Le Tableau que vous me demandez est le résultat de tous les doubles possibles

var luhnArr = [0, 2, 4, 6, 8, 1, 3, 5, 7, 9];

• 0 * 2 = 0 --> 0
• 1 * 2 = 2 --> 2
• 2 * 2 = 4 --> 4
• 3 * 2 = 6 --> 6
• 4 * 2 = 8 --> 8
• 5 * 2 = 10 --> 1+0 --> 1
• 6 * 2 = 12 --> 1+2 --> 3
• 7 * 2 = 14 --> 1+4 --> 5
• 8 * 2 = 16 --> 1+6 --> 7
• 9 * 2 = 18 --> 1+8 --> 9

Ainsi, par exemple

luhnArr[3] --> 6 (6 is in 3rd position of the array, and also 3 * 2 = 6)
luhnArr[7] --> 5 (5 is in 7th position of the array, and also 7 * 2 = 14 -> 5 )

Alternative 😉 Simple et le Meilleur

  <script>
      //takes the form field value and returns true on valid number
    function valid_credit_card(value) {
      //accept only digits, dashes or spaces
        if (/[^0-9-\s]+/.test(value)) return false;

        //The Luhn Algorithm. It's so pretty.
        var nCheck = 0, nDigit = 0, bEven = false;
        value = value.replace(/\D/g, "");

        for (var n = value.length - 1; n >= 0; n--) {
            var cDigit = value.charAt(n),
                  nDigit = parseInt(cDigit, 10);

            if (bEven) {
                if ((nDigit *= 2) > 9) nDigit -= 9;
            }

            nCheck += nDigit;
            bEven = !bEven;
        }

        return (nCheck % 10) == 0;
    }

    console.log(valid_credit_card("5610591081018250"),"valid_credit_card Validation");
  </script>

Meilleure Solution ici

• http://plnkr.co/edit/34aR8NUpaKRCYpgnfUbK?p=preview

de tous les tests passés selon

• http://www.paypalobjects.com/en_US/vhelp/paypalmanager_help/credit_card_numbers.htm

et le crédit va à

• https://gist.github.com/DiegoSalazar/4075533

J'ai travaillé sur la solution suivante après avoir soumis une bien pire pour un test..

function valid(number){
    var splitNumber = parseInt(number.toString().split(""));
    var totalEvenValue = 0;
    var totalOddValue = 0;
    for(var i = 0; i < splitNumber.length; i++){
        if(i % 2 === 0){
            if(splitNumber[i] * 2 >= 10){
                totalEvenValue += splitNumber[i] * 2 - 9;
            } else {
                totalEvenValue += splitNumber[i] * 2;
            }
        }else {
            totalOddValue += splitNumber[i];
        }
    }
    return ((totalEvenValue + totalOddValue) %10 === 0)
}
console.log(valid(41111111111111111));