» 
Arabic Bulgarian Chinese Croatian Czech Danish Dutch English Estonian Finnish French German Greek Hebrew Hindi Hungarian Icelandic Indonesian Italian Japanese Korean Latvian Lithuanian Malagasy Norwegian Persian Polish Portuguese Romanian Russian Serbian Slovak Slovenian Spanish Swedish Thai Turkish Vietnamese
Arabic Bulgarian Chinese Croatian Czech Danish Dutch English Estonian Finnish French German Greek Hebrew Hindi Hungarian Icelandic Indonesian Italian Japanese Korean Latvian Lithuanian Malagasy Norwegian Persian Polish Portuguese Romanian Russian Serbian Slovak Slovenian Spanish Swedish Thai Turkish Vietnamese

definition - luhn-algoritmen

definition of Wikipedia

   Advertizing ▼

Wikipedia

Luhn-algoritmen

Från Wikipedia

Hoppa till: navigering, sök

Luhnalgoritmen, även kallad modulus-10-algoritmen eller mod-10-algoritmen, är en vanligt förekommande algoritm för att beräkna en enkel felupptäckande kod i form av en kontrollsumma. Luhnalgoritmen används bland annat för att beräkna kontrollsiffran i svenska personnummer, samt i kreditkorts-, postgiro-, bankgiro- och bankkontonummer. Den ingår i kontrollsiffrorna för OCR-nummer (referensnummer på inbetalningskort av typ bankgiro och plusgiro), men där är den ibland kompletterad med en kontrollsiffra som anger entalssiffran i antalet siffror i OCR-numret. På så sätt kan man även upptäcka om en nolla lagts till eller tagits bort ur OCR-numret.

Syftet med algoritmen är att upptäcka enkla fel av typen en felskriven siffra eller ett byte av två intilliggande siffror. Emellertid finns en liten risk att två eller fler siffror är felskrivna, men att felen inte upptäcks därför att de tar ut varandra så att de ger upphov till samma kontrollsiffra. Algoritmen är utformad så att det är möjligt att infoga ett godtyckligt antal nollor i början av koden utan att det påverkar kontrollsiffran (ex 000123 och 123 ger upphov till samma kontrollsiffra).

När algoritmen uppfanns fanns det krav på en enkel algoritm för att kunna kontrollera och generera kontrollsiffror och Luhn-algoritmen uppfyller detta krav. I jämförelse med moderna felupptäckande koder har algoritmen inte någon betydande styrka eller effektivitet.

Algoritmen utvecklades av Hans Peter Luhn på IBM och beskrivs i US patent 2950048, med ansökningsdatum den 6 januari, 1954, och beviljandedatum den 23 augusti, 1960.

Innehåll

Funktionsprincip

Kontroll av nummer

Vid kontroll av koden, inklusive kontrollsiffra, fungerar algoritmen på så sätt att med start från den sista siffran i koden (den minst signifikanta siffran), det vill säga kontrollsiffran, så multipliceras siffrorna ömsom med 1 och ömsom med 2. Skulle något tal vid en sådan multiplikation bli större än 9 ersätts talet med dess siffersumma (eller, likvärdigt, med talet subtraherat med 9). Därefter summeras talen. Om den erhållna summan är jämnt delbar med 10 så är kontrollsiffran korrekt.

Exempel på personnummer 811218-9876:

  8  1 1 2 1 8  9 8  7 6*  2  1 2 1 2 1  2 1  2 1-------------------------   ^  ^ ^ ^ ^ ^  ^ ^  ^   16  1 2 2 2 8 18 8 14 6

Tvåsiffriga produkter splittras upp i ensiffriga tal. Siffrorna summeras därefter:

1+6+1+2+2+2+8+1+8+8+1+4+6 = 50

Denna summa är delbar med 10 och sålunda har vi inte upptäckt något fel i numret.

Beräkning av kontrollsiffra

För att beräkna kontrollsiffran är förfarandet likvärdigt, med skillnaden att man multiplicerar ömsom med 2 och ömsom med 1 (det vill säga att man börjar att multiplicera den sista siffran med 2, och inte med 1 som i fallet vid kontroll). Den erhållna summan dras därefter ifrån närmast större 10-tal, varvid kontrollsiffran erhålles.

För att beräkna kontrollsiffrna för det niosiffriga personnumret 811218-987 erhålles följande produkter:

  8  1 1 2 1 8  9 8  7*  2  1 2 1 2 1  2 1  2-------------------------   ^  ^ ^ ^ ^ ^  ^ ^    16  1 2 2 2 8 18 8 14

Tvåsiffriga produkter splittras upp i ensiffriga tal. Siffrorna summeras därefter:

1+6+1+2+2+2+8+1+8+8+1+4 = 44

Kontrollsiffran erhålls genom att detta tal subtraheras från närmast högre tiotal.

50-44 = 6

Den avslutande kontrollsiffran blir således en sexa. Det tiosiffriga personnumret blir 811218-9876.

Implementationer

C

Här är en c-implementation av algoritmen som kontrollerar om kontrollsiffran är korrekt. Funktionen luhn returnerar 0 om kontrollsiffran är korrekt, och annars ett värde x. Om kontrollsiffran är felaktig, kan 10-x adderas till denna varvid en korrekt kontrollsiffra (mod 10) erhålles.<source lang="C">

  1. include <stdio.h>
  2. include <string.h>
  3. include <stdlib.h>

int luhn(const char *p){

  int m = 1;  int sum = 0;  int term = 0;
  if (strlen(p) % 2 == 0)     m = 2;
  while(*p) {                       term = ( *p - '0' ) * m ;       if ( term > 9 ) term -= 9;      sum += term;                    p++;                            m = 3 - m;  }
  return sum % 10;

}

int main(int argc, char **argv){

  if (argc != 2)     exit(1);  printf("%d\n", luhn(argv[1]));
  return 0;

}</source>

Java

Samma algoritm i java:<source lang="Java">

 class Mod10 {    public static int luhn(String indata)   {     int a = 1;     int sum = 0;     int term;     for (int i = indata.length() - 1; i >= 0; i--) {       term = Character.digit(indata.charAt(i),10) * a;       if ( term > 9) term -= 9;       sum += term;       a = 3 - a;     }     return sum % 10;   }    public static void main(String[] args)   {     if (args.length != 1)       System.exit(0);     System.out.println(luhn(args[0]));   } }

</source>

C#

<source lang="csharp">class luhnProgram{

   static void Main(string[] args)   {       if (args.Length > 0) System.Console.WriteLine(luhn(args[0]));   }   static bool luhn(string pNum)   {         int sum = 0;         for (int i = 0; i < pNum.Length; i++){             int temp = (pNum[i] - '0') << (1 - (i & 1));             if (temp > 9) temp -= 9;             sum += temp;        }        return (sum % 10) == 0;    }

}</source>

Haskell

<source lang="Haskell">import Data.Charluhn :: String -> Intluhn n = (`mod` 10).sum.map addUp.zipWith (*) lst.reverse.map digitToInt $ n

 where lst = 1:2:lst       addUp c = (c `mod` 10) + (c `div` 10)

</source>

Pascal

En implementation i Pascal som en unit (använd FreePascal eller gpc - The Gnu Pascal compiler - om du vill kompilera nedanstående)<source lang="Pascal">

 unit luhnunit;  interface function luhn( a : string ) : integer;  implementation  function luhn(a : string ):integer; var   x, m, term : word;   sum            : integer; begin   sum := 0;   m := 1;   for x := length(a) downto 1 do   begin     term := ( ord(a[x]) - ord('0') ) * m;     if term > 9 then term := term - 9;     sum := sum + term;     m := 3 - m;   end;   luhn := (sum mod 10); end; { valid }  begin end.

</source>

PHP

Såhär kan personnumret verifieras med PHP.<source lang="php"><?php

function personnr($pnr){ //Om personnumret inte är 10 tecken långt eller inte är numeriskt är det inget personnummer. if(strlen($pnr) !== 10 || !is_numeric($pnr)) return false;

$num = 2; //Variabel med den siffra som varje siffra i personnumret multipliceras med. $sum = 0; //Variabel vari siffersumman samlas.

//Den slutgiltiga siffersumman skapas i följande for-sats. for ($i = 0; $i < 9; $i++) { //En siffra kontrolleras. $tmp = substr($pnr, $i, 1) * $num;

//Siffersumman läggs till totalsumman. if ($tmp > 9) $sum += 1 + ($tmp % 10); else $sum += $tmp;

//"Funktionssiffran" ändras inför nästa kontroll. if ($num == 2) $num = 1; else $num = 2; }

$result = ($sum + substr($pnr, 9, 1)) % 10; //Siffersumma plus kontrollsiffra ska bli jämt delbart med 10 och i så fall läggs 0 i $result. return !$result; //Om $result innehåller 0 (false) är personnummret korrekt och funktionen returnerar 1 (true).}

if(isset($_POST['pnr'])) { if(personnr($_POST['pnr'])) { $pnrResult = "Personnumret stämde.
";

} else { $pnrResult = "Personnumret stämde inte.
";

}

} else { $pnrResult = " ";

}

?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head> <title>Verifiera personnummer</title>

<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />

</head><body>

<?php echo $pnrResult; ?>

<form action="" method="post">

Skriv in ett personnummer: <input type="text" name="pnr" />
<input type="submit" value="Verifiera" />

</form>

</body></html></source>

Javascript

Här är en variant i javascript och html. Klipp ut den, spara den och ladda den i din webläsare. Den anger även korrekt kontrollsiffra om en felaktig angivits.<source lang="javascript"><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html><head><title>Luhn</title><script type="text/javascript">/*<![CDATA[*/

function checkLuhn(c){ if (c.match(/[^\d]/)) return "Endast siffror är tillåtet"; if (c.length < 2) return "Måste vara minst två siffror"; var sum=0, m = 1, d;

var last = c.charAt(c.length - 1) * 1;

for (var i = c.length - 1; i >= 0; i--) { d = c.charAt(i) * m; sum += d > 9 ? d - 9 : d; m = 3 - m; } if (!(sum % 10)) return "'" + c + "'" + " har en KORREKT<\/b> kontrollsiffra."; return "'" + c + "'" + " har en FELAKTIG<\/b> kontrollsiffra. Korrekt siffra är: " + ((10 - (sum - last) % 10) % 10);}

/*]]>*/</script></head><body>

<form method="get" action="" onsubmit="document.getElementById('resultat').innerHTML = checkLuhn(this.luhn.value);return false;"> <fieldset> <legend>Ange det nummmer som skall kontrolleras</legend> <input id="luhn" type="text" /> <input type="submit" value="Kontrollera"> </fieldset> <fieldset> <legend>Resultat</legend>

</fieldset> </form>

</body></html></source>

VBA

<source lang="VB">Function Luhn(Nummer As Double, Optional Multi As Integer = 1) As Integer

   'Luhn funktionen kontrollerar eller genererar en kontrollsiffra enl. Luhn-algoritmen http://sv.wikipedia.org/wiki/Luhn-algoritmen   'Giltiga argument är: Nummer, ett positivt heltal av Single typ (0-3E38)   'Multiplikator 1 eller 2, bestämmer om en kontrollsiffra skall kontrolleras (1) eller genereras (2)   'Resutlatet är ett heltal mellan 0 och 9 där 0 vid kontroll (Multi=1) indikerar en giltig kontrollsiffra   'Vid generering (Multi=2) representerar resutatet helt enkelt kontrollsiffran   Dim x As Integer, Text, Prod As String   Text = Trim(Str(Nummer)) 'Gör en sträng (utan inledande blanksteg) av Numbret   For x = Len(Text) To 1 Step -1 'Loopar från höger till vänster i strängen       Prod = Prod & Val(Mid(Text, x, 1)) * Multi 'Lägger till produkten av varje tal och multiplikator i en sträng       If Multi = 2 Then Multi = 1 Else Multi = 2 'Byter värde på multiplikatorn   Next x   For x = 1 To Len(Prod) 'Loopar igenom listan av produkter       Luhn = Luhn + Val(Mid(Prod, x, 1)) '...och summerar dessa tal för tal   Next x   Luhn = 10 - Val(Right(Str(Luhn), 1))   If Luhn = 10 Then Luhn = 0

End Function</source>

C/AL

Här är samma algoritm som beräknar kontrollsiffra i C/AL, dvs det språk som används i Microsoft Dynamics Nav.<source lang="pascal">PROCEDURE Luhn@1000000002(Number@1000000000 : Text[50]) CheckDigit : Integer;VAR

 LOC_iMultiply@1000000001 : Integer; LOC_iSum@1000000002 : Integer; LOC_iIndex@1000000003 : Integer; LOC_iTerm@1000000004 : Integer; LOC_iPositionInteger@1000000005 : Integer; LOC_iStrLen@1000000006 : Integer;

BEGIN LOC_iMultiply := 1; // Rensa bort allt som inte är siffror Number := DELCHR(Number,'=',DELCHR(Number,'=','0123456789'));

LOC_iStrLen := STRLEN(Number);

IF (LOC_iStrLen MOD 2) = 0 THEN LOC_iMultiply := 2;

FOR LOC_iIndex := 1 TO LOC_iStrLen DO BEGIN EVALUATE(LOC_iPositionInteger, FORMAT(Number[LOC_iIndex])); LOC_iTerm := LOC_iPositionInteger * LOC_iMultiply; IF LOC_iTerm > 9 THEN LOC_iTerm := LOC_iTerm - 9; LOC_iSum := LOC_iSum + LOC_iTerm; LOC_iMultiply := 3 - LOC_iMultiply; END;

CheckDigit := LOC_iSum MOD 10;END;</source>

Python

<source lang="python">def luhn(num):

   """Returnerar Luhns kontrollsiffra"""
   faktor = 2   summa = 0
   for i in map(int, str(num)[::-1]):

summa += sum(map(int, str(i * faktor))) faktor = 1 if faktor != 1 else 2

   return summa % 10 and 10 - summa % 10

</source>

Excel

Excel (Svenskt)
Kontroll av slutsiffra, returnerar SANT eller FALSKT.
Tar nummer ur cell A1 i format "ÅÅMMDD-XXXX"

=HÖGER((VÄNSTER(A1)+EXTEXT(A1;3;1)+EXTEXT(A1;5;1)+EXTEXT(A1;8;1)+EXTEXT(A1;10;1))*2-((VÄNSTER(A1)*1>4)+(EXTEXT(A1;3;1)*1>4)+(EXTEXT(A1;5;1)*1>4)+(EXTEXT(A1;8;1)*1>4)+(EXTEXT(A1;10;1)*1>4))*9+EXTEXT(A1;2;1)+EXTEXT(A1;4;1)+EXTEXT(A1;6;1)+EXTEXT(A1;9;1)+HÖGER(A1))="0"

Ruby

en modul som räknar ut kontrollsiffran av en talsekvens. Du kommer åt funktionen genom antingen Luhn::getControllNumber() eller Luhn.getControllNumber().<source lang="ruby">

  1. modul för beräkning av kontrollsiffra och kontroll av kontrollsiffra i luhn-10 algoritmen

module Luhn def Luhn.getControllNumber(sequence) sequence=sequence.to_s container = [] factor = 2

sequence.each_character {|z| container << (z.to_i * factor) if(factor==2) factor = 1 else factor = 2 end }

sequence = 0 container.each {|z| if(z.to_s.size == 2) sequence += z%10 + z/10 else sequence += z end }

               factor = ((sequence/10)+1)*10 - sequence               return factor       end

end

</source>

 

All translations of luhn-algoritmen


sensagent's content

  • definitions
  • synonyms
  • antonyms
  • encyclopedia

  • synonym

Dictionary and translator for handheld

⇨ New : sensagent is now available on your handheld

   Advertising ▼

sensagent's office

Shortkey or widget. Free.

Windows Shortkey: sensagent. Free.

Vista Widget : sensagent. Free.

Webmaster Solution

Alexandria

A windows (pop-into) of information (full-content of Sensagent) triggered by double-clicking any word on your webpage. Give contextual explanation and translation from your sites !

Try here  or   get the code

SensagentBox

With a SensagentBox, visitors to your site can access reliable information on over 5 million pages provided by Sensagent.com. Choose the design that fits your site.

Business solution

Improve your site content

Add new content to your site from Sensagent by XML.

Crawl products or adds

Get XML access to reach the best products.

Index images and define metadata

Get XML access to fix the meaning of your metadata.


Please, email us to describe your idea.

WordGame

The English word games are:
○   Anagrams
○   Wildcard, crossword
○   Lettris
○   Boggle.

Lettris

Lettris is a curious tetris-clone game where all the bricks have the same square shape but different content. Each square carries a letter. To make squares disappear and save space for other squares you have to assemble English words (left, right, up, down) from the falling squares.

boggle

Boggle gives you 3 minutes to find as many words (3 letters or more) as you can in a grid of 16 letters. You can also try the grid of 16 letters. Letters must be adjacent and longer words score better. See if you can get into the grid Hall of Fame !

English dictionary
Main references

Most English definitions are provided by WordNet .
English thesaurus is mainly derived from The Integral Dictionary (TID).
English Encyclopedia is licensed by Wikipedia (GNU).

Copyrights

The wordgames anagrams, crossword, Lettris and Boggle are provided by Memodata.
The web service Alexandria is granted from Memodata for the Ebay search.
The SensagentBox are offered by sensAgent.

Translation

Change the target language to find translations.
Tips: browse the semantic fields (see From ideas to words) in two languages to learn more.

last searches on the dictionary :

4011 online visitors

computed in 0.063s

I would like to report:
section :
a spelling or a grammatical mistake
an offensive content(racist, pornographic, injurious, etc.)
a copyright violation
an error
a missing statement
other
please precise:

Advertize

Partnership

Company informations

My account

login

registration

   Advertising ▼