Luhn test of credit card numbers: Difference between revisions

{{trans|Python}}

 

V ch = String(n)

V sum = 0

1234567812345678,

1234567812345670)

 

{{out}}

For maximum compatibility, this program uses only the basic instruction set (S/360)

and an ASSIST macro (XPRNT) to keep the code as short as possible.

LUHNTEST CSECT

USING LUHNTEST,R13 base register

PG DC CL80' ' buffer

YREGS

{{out}}

<pre>

 

=={{header|8080 Assembly}}==

jmp demo

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

jmp 5

pass: db 'Pass$'

 

{{out}}

=={{header|8086 Assembly}}==

 

cpu 8086

org 100h

section .data

pass: db 'Pass$'

 

{{out}}

 

=={{header|8th}}==

\ Adapted from the C version:

: remap \ n1 -- n2

"1234567812345670" test-luhn

 

 

{{out}}

 

=={{header|ABAP}}==

 

DATA: sum(1) TYPE n VALUE 0. " Sum of checksum.

ENDIF.

 

 

=={{header|ACL2}}==

 

(defun digits (n)

(sum (double-and-sum-digits evens)))

10)

 

{{out}}

&gt; (luhn 1234567812345670)

T</pre>

 

=={{header|ActionScript}}==

{

var isOdd:Boolean = true;

trace(isValid("49927398717"));

trace(isValid("1234567812345678"));

 

=={{header|Ada}}==

{{trans|C}}

{{works with|GNAT}}

use Ada.Text_IO;

 

Put_Line (Boolean'Image (Luhn_Test ("1234567812345670")));

 

{{out}}

<pre>

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards)}}

ABS c - ABS "0";

print((cp, ": ", confirm(cp), new line))

OD

{{out}}

<pre>

=={{header|ALGOL W}}==

Separate source so the LuhnTest procedure can be used in other tasks, e.g.: [[Validate International Securities Identification Number]]

% as Algol W has fixed length strings, the length of the number %

% must be specified in ccLength %

end for_cPos ;

isValid and ( ( checkSum rem 10 ) = 0 )

 

Use the above to test the LuhnTest procedure:

 

% external procedure that returns true if ccNumber passes the Luhn test, false otherwise %

logical procedure LuhnTest ( string(32) value ccNumber

testLuhnTest( "1234567812345670", 16 )

 

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

digits←⍎¨⍵ ⍝ Characters to digits

doubled←2∘×@(⌽⍤~1 0⍴⍨≢)⊢digits ⍝ Double every other digit

partial←-∘9@(9∘<)⊢doubled ⍝ Subtract 9 is equivalent to sum of digits for the domain 10≤x≤19

0=10|+/partial ⍝ Valid if sum is a multiple of 10

{{out}}

<pre>

 

{{works with|APL+Win}}

[1] num←⌽((⌈10⍟num)/10)⊤num

[2] s1←+/((⍴num)⍴1 0)/num

[3] s2←+/∊(⊂10 10)⊤¨2×((⍴num)⍴0 1)/num

[4] ret←0=10⊤s1+s2

{{out}}

<pre> LuhnTest¨ 49927398716 49927398717 1234567812345678 1234567812345670

=={{header|AppleScript}}==

===Functional===

on luhn(s)

-- True if the digit string represents

return lst

end tell

{{Out}}

<pre>{true, false, false, true}</pre>

===Straightforward===

 

-- Accept only text input.

if (n's class is not text) then return false

set end of testResults to {testNumber:testNumber's contents, valid:luhnTest(testNumber)}

end repeat

 

{{output}}

 

=={{header|ARM Assembly}}==

.global _start

_start:

.asciz "49927398717"

.asciz "1234567812345678"

 

=={{header|AutoHotkey}}==

; http://www.autohotkey.com/forum/post-229412.html#229412

 

Sum += ( ( 9 < ( Temp := MultFactor * A_LoopField ) ) ? Temp - 9 : Temp ) , MultFactor := 3 - MultFactor

Return !Mod(Sum,10)

 

=={{header|AutoIt}}==

Global $avarray[4] = [49927398716, 49927398717, 1234567812345678, 1234567812345670]

For $i = 0 To 3

EndIf

EndFunc ;==>checkLuhn

 

{{out}}

 

=={{header|AWK}}==

BEGIN {

A[1] = 49927398716;

}

return ((s%10)==0);

{{out}}

<pre>isLuhn(1234567812345670): 1

 

=={{header|Bash}}==

 

function luhn_validate # <numeric-string>

print_result "49927398717"

print_result "1234567812345678"

 

{{out}}

1234567812345670 is valid

</pre>

 

=={{header|Batch File}}==

This simple implementation does not reverse the numbers. Instead, it counts from right to left.

setlocal enabledelayedexpansion

call :luhn 49927398716

call :luhn 49927398717

call :luhn 1234567812345670

exit /b 0

:luhn

:digit_loop

) else (

)

{{Out}}

<pre>>luhn.bat

 

=={{header|BBC BASIC}}==

READ cardnumber$

IF FNluhn(cardnumber$) THEN

ENDIF

NEXT

 

=={{header|bc}}==

define l(n) {

auto m, o, s, x

l(49927398717)

l(1234567812345678)

 

{{Out}}

0

1</pre>

 

=={{header|Befunge}}==

 

>&:19+`|v < >v 5 6 7 8

^ \ <>09p19p>09g+09p:|>2*:19+%19g+19p19+/19g+19p:|

>:#,_@

11

The labelled points (1 to 11) are:

1. Read in input until number greater than 10,

valid

</pre>

 

=={{header|Bracmat}}==

= sum odd even

. 0:?sum

& test$1234567812345678

& test$1234567812345670

{{out}}

<pre>49927398716 : true

=={{header|Brainf***}}==

 

>++++++++[<----->-]<++>>>>>>+>,----------] SUBTRACT ASCII 0 FROM EACH

<-<<<<<<< GO TO LAST DIGIT

<[<<.<---.<+++++..<] IF ZERO PASS

++++++++++. NEWLINE

 

{{out}}

Pass</pre>

 

 

=={{header|C}}==

#include <stdio.h>

 

 

return 0;

49927398716 ok

49927398717 not ok

The LuhnCheck method takes an array of integers because values in memory will be integer-aligned.

 

public static class Luhn

{

}

}

<pre>

49927398716 is valid

Note that the original implementation, which follows, is flawed because it assumes that n is a number which, when represented as a string, has an even number of characters. Granted, the brief is for Credit Card Numbers which are all, at the time of writing, an even number of digits.

 

using System.Linq;

 

}

}

<pre>

49927398716 is valid

 

A solution without using LINQ, works for all versions of .NET.

using System;

namespace Luhn_Test

}

}

<pre>

1234567812345670 is Valid.

 

A solution optimized for readability:

using System;

using System.Linq;

}

}

 

Extremely compact version uses Europa rtl library https://github.com/CodeAlkemist/Europa-rtl

using System;

using EuropaRTL.Utilities;

}

}

<pre>

49927398716

 

=={{header|C++}}==

using namespace std;

 

}

return 0;

 

===C++11===

#include <vector>

#include <algorithm>

return 0;

}

 

It is also possible to achieve a compile-time version using metaprogramming.

 

#include <type_traits>

 

return 0;

}

<pre>

true

=={{header|Caché ObjectScript}}==

 

{

 

}

 

{{out|Examples}}

<pre>USER>For { Read ccn Quit:ccn="" Write ": "_##class(Utils.Check).Luhn(ccn), ! }

 

=={{header|Ceylon}}==

value numbers = "49927398716

49927398717

};

return (s1 + s2) % 10 == 0;

 

=={{header|Clojure}}==

(let [factors (cycle [1 2])

numbers (map #(Character/digit % 10) cc)

 

(doseq [n ["49927398716" "49927398717" "1234567812345678" "1234567812345670"]]

 

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

{{works with|IBM Enterprise COBOL for z/OS}}

PROGRAM-ID. LUHNTEST.

ENVIRONMENT DIVISION.

goback

.

 

{{out}}

input=1234567812345670 pass

</pre>

 

=={{header|Common Lisp}}==

(labels ((sum-digits (n) (if (> n 9) (- n 9) n)))

(let ((n* (reverse n)) (l (length n)))

(s2 (loop for i from 1 below l by 2

summing (sum-digits (* 2 (digit-char-p (aref n* i)))))))

Another version, using Maciej Pasternacki's reader macros for

function composition and [[currying]] in the [http://www.cl-user.net/asp/Fr4F/sdataQ1nAQqjvnQ3MDQ3ESH8X8yBX8yBXnMq=/sdataQu3F$sSHnB== curly] package:

(use-package :curly)

(enable-curly-syntax)

(labels ((sum-digits (n) (if (> n 9) (- n 9) n)))

(funcall {zerop (mod * 10) (apply #'+) (mapcar #'sum-digits)

 

=={{header|Cowgol}}==

 

# Given a string containing the digits of a credit card number,

test("49927398717");

test("1234567812345678");

 

{{out}}

 

=={{header|Crystal}}==

d2sum = [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]

sum, n = 0, n.to_u64

 

cards = [49927398716, "49927398717", 1234567812345678, "1234567812345670"]

{{out}}

<pre>49927398716: true

===Functional Version===

{{trans|Haskell}}

 

enum luhnTest = (in string n) pure /*nothrow*/ @safe /*@nogc*/ =>

assert("49927398716 49927398717 1234567812345678 1234567812345670"

.split.map!luhnTest.equal([true, false, false, true]));

 

===More Imperative Version===

{{trans|C}}

 

bool luhnTest(in string num) @safe pure nothrow @nogc {

"1234567812345670"];

assert(data.map!luhnTest.equal([true, false, false, true]));

 

===Stronger Statically Typed Version===

This version uses more precise types.

{{trans|SPARK}}

 

struct Interval(T) {

"123456781234567D"])

writefln("%s is %svalid", n, luhnTest(n) ? "" : "not ");

 

=={{header|EchoLisp}}==

;; value for 'even' numbers

(define (even-val n) (if (> n 4) (+ n n -9) (+ n n)))

(valid "1234567812345678") → #f

(valid "49927398717") → #f

 

=={{header|Elixir}}==

 

def valid?(cc) when is_binary(cc), do: String.to_integer(cc) |> valid?

def valid?(cc) when is_integer(cc) do

 

numbers = ~w(49927398716 49927398717 1234567812345678 1234567812345670)

 

{{out}}

 

=={{header|Emacs Lisp}}==

(defun luhn (str)

(if (string-match-p "[^0-9]" str)

(error "String contains invalid character")

(string-to-list str)))))

(zerop

(mod (apply #'+ (seq-map-indexed

(lambda (elt idx)

(if (> (* 2 elt) 9)

(- (* 2 elt) 9)

elt))

digit-list))

 

 

{{out}}

 

=={{header|Erlang}}==

-module(luhn_test).

 

Numbers = ["49927398716", "49927398717", "1234567812345678", "1234567812345670"],

[io:fwrite("~s: ~p~n", [X, credit_card(X)]) || X <- Numbers].

 

{{out}}

=={{header|Euphoria}}==

{{trans|C}}

integer isOdd, oddSum, evenSum, digit

isOdd = 1

for i = 1 to length(cc_numbers) do

printf(1,"%s = %d\n", {cc_numbers[i], luhn(cc_numbers[i])})

 

{{out}}

1234567812345678 = 0

1234567812345670 = 1</pre>

 

=={{header|F Sharp|F#}}==

let rec g r c = function

| 0 -> r

let d = ((int s.[i - 1]) - 48) <<< c

g (r + if d < 10 then d else d - 9) (1 - c) (i - 1)

 

=={{header|Factor}}==

{{works with|Factor|0.98}}

IN: luhn

 

: luhn? ( n -- ? )

luhn-digit 0 = ;

 

{{out}}

 

=={{header|Forth}}==

0 >r over + ( R: sum )

begin 1- 2dup <=

s" 49927398717" luhn . \ 0

s" 1234567812345678" luhn . \ 0

 

=={{header|Fortran}}==

implicit none

integer :: nargs

! 49927398717 is not valid

! 1234567812345678 is not valid

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Task test number 49927398716 should be TRUE, report back as TRUE

1234567812345678 = FALSE

1234567812345670 = TRUE</pre>

 

=={{header|FunL}}==

def digits_of( n ) = [int(d) | d <- n.toString()]

 

for n <- [49927398716, 49927398717, 1234567812345678, 1234567812345670]

 

{{out}}

1234567812345678 is invalid

1234567812345670 is valid

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=966f04aa2a1e9af43ba9553f5cb9160d Click this link to run this code]'''

Dim sTrial As String[] = ["49927398716", "49927398717", "1234567812345678", "1234567812345670"]

Dim sRev As String

Next

 

Output:

<pre>

 

=={{header|GAP}}==

local c, d, i, j, r;

d := "0123456789";

# Will also work on strings, and will skip non-digits

IsLuhn("4-992-739-871-6");

 

=={{header|Go}}==

 

import (

fmt.Println(s, luhn(s))

}

{{out}}

<pre>

 

=={{header|Groovy}}==

int total

(number as String).reverse().eachWithIndex { ch, index ->

}

total % 10 == 0

Testing the function:

println "Checking: $number (${checkLuhn(number)})"

assert expected == checkLuhn(number)

[49927398716: true, 49927398717: false, 1234567812345678: false, 1234567812345670: true].each { number, expected ->

verifyLuhn number, expected

{{out}}

<pre>Checking: 49927398716 (true)

 

=={{header|Haskell}}==

luhn = (0 ==) . (`mod` 10) . sum . map (uncurry (+) . (`divMod` 10)) .

 

{{out}}

 

Or, aiming for a legible relationship with the stages shown in the task description:

import Data.List (transpose)

import Data.List.Split (chunksOf)

"1234567812345678",

"1234567812345670"

{{Out}}

<pre>("49927398716",True)

 

=={{header|HicEst}}==

 

DO nr = 1, 4

valid = (0 == MOD(sum_odds + sum_even, 10))

WRITE() number, " is ", "invalid"(1 + 2*valid:)

<pre>49927398716 is valid

49927398717 is invalid

=={{header|Icon}} and {{header|Unicon}}==

We use map to pre-compute the sum of doubled digits.

every write(i := !aL ," - ", ((\isluhn10(i),"valid")|"invalid") \ 1)

end

 

return (sum % 10 = 0,i)

 

{{out}}

1234567812345670 - valid

</pre>

 

=={{header|J}}==

Also, we do not need the intermediate sums.

 

 

Example use:

 

Interpreting that example: In J, 1 is true, 0 is false, so the first and last provided digit sequences were valid and the middle two were not.

 

=={{header|Java}}==

public static void main(String[] args) {

System.out.println(luhnTest("49927398716"));

return (s1 + s2) % 10 == 0;

}

{{out}}

<pre>true

false

true</pre>

 

=={{header|JavaScript}}==

Using prototype.

return $A(cc).reverse().map(Number).inject(0, function(s, d, i) {

return s + (i % 2 == 1 ? (d == 9 ? 9 : (d * 2) % 9) : d);

}) % 10 == 0;

};

 

Without any library.

{

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

return (counter%10 == 0);

}

 

Highly compressed version.

for(d = +a[b = a.length-1], e=0; b--;)

c = +a[b], d += ++e % 2 ? 2 * c % 10 + (c > 4) : c;

// returns false

luhn10('4111111111111112')

 

=={{header|jq}}==

def odds: . as $in | reduce range(0; length) as $i

([]; if ($i % 2) == 0 then . + [$in[$i]] else . end);

| ($reverse | odds | digits | add) as $s1

| ($reverse | evens | digits | map(. * 2 | sumdigits) | add) as $s2

'''Example'''

49927398717,

1234567812345678,

1234567812345670

{{Out}}

$ jq -r -M -n -f luhn.jq

The test function itself is only a single line of code:

 

 

More readable version:

 

d = reverse(digits(x))

s = sum(d[1:2:end])

for card in [49927398716, 49927398717, 1234567812345678, 1234567812345670]

println(luhntest(card) ? "PASS " : "FAIL ", card)

 

{{out}}

 

=={{header|K}}==

se: {+/{+/0$'$x}'2*x@1+2*!(#x)%2}

 

{{trans|J}}

 

 

'''Example:'''

 

1 0 0 1

luhn2'49927398716 49927398717 1234567812345678 1234567812345670

 

{{Works with|K|3}}

digits:0$/:|cc / convert chars to digit ints

s:digits*(#cc)#1 2 / evens doubled, odds not

nines:+/s>9 / number of sums greater than 9

:~((+/s)-(9*nines))!10 / sum minus the nines is mod ten?

'''Example:'''

 

luhn'test

 

=={{header|Kotlin}}==

 

fun checkLuhn(number: String): Boolean {

for (number in numbers)

println("${number.padEnd(16)} is ${if(checkLuhn(number)) "valid" else "invalid"}")

 

{{out}}

=={{header|langur}}==

{{trans|Go}}

val .t = [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]

val .numbers = s2n .s

}

 

"49927398716": true,

"49927398717": false,

write .key, ": ", .pass

writeln if(.pass == .tests[.key]: ""; " (LUHN TEST FAILED)")

 

{{out}}

=={{header|Lasso}}==

Part of the Lasso's implementation of "valid_creditcard".

 

define luhn_check(number) => {

stdoutnl(luhn_check(49927398717)) // false

stdoutnl(luhn_check(1234567812345678)) // false

 

=={{header|Liberty BASIC}}==

 

card$(1)="49927398716"

print card$(test),"False"

end if

 

=={{header|LiveCode}}==

local s1,evens, s2

repeat with n = 1 to len(cc)

1234567812345678 false

1234567812345670 true

 

=={{header|Logo}}==

output or [empty? :list] [empty? bf :list]

end

show luhn "49927398717 ; false

show luhn "1234-5678-1234-5678 ; false

 

=={{header|Lua}}==

n=string.reverse(n)

print(n)

print(luhn'49927398717')

print(luhn'1234567812345678')

 

=={{header|M2000 Interpreter}}==

{{trans|FreeBASIC}}

Function luhntest(cardnr$) {

end while

}

{{out}}

<pre>49927398716 = True

1234567812345670 = True</pre>

 

+ Total[ToExpression[#[[1;;All;;2]]]], 10] == 0)& [Characters[StringReverse[ToString[nb]]] ]

 

LuhnQ /@ {49927398716, 49927398717, 1234567812345678, 1234567812345670}

===Alternate Code===

Eliminates conversion of numbers to strings and back

Block[{digits = Reverse@IntegerDigits@n},

Mod[Total[{digits[[;; ;; 2]],

IntegerDigits[2 #] & /@ digits[[2 ;; ;; 2]]}, -1], 10] == 0]

 

{{out}}<pre>{True,False,False,True}</pre>

 

=={{header|MATLAB}}==

The solution is basically the same as for [[#Octave|Octave]].

if nargin == 0 % evaluate test cases

testnum = [49927398716 49927398717 1234567812345678 1234567812345670];

m = [2:2:8,1:2:9]; % rule 3: maps 1:9 to [2 4 6 8 1 3 5 7 9]

passed = ~mod(sum(d(end:-2:1)) + sum(m(d(end-1:-2:1))), 10);

{{out}}

<pre>49927398716: 1

=={{header|min}}==

{{works with|min|0.19.3}}

((0 0) dip (pop 'succ dip over even?) partition ((pop pop) dip) dip) :evens/odds

((2 * digits sum) map sum) :evens-sum

 

(49927398716 49927398717 1234567812345678 1234567812345670)

{{out}}

<pre>

 

=={{header|MiniScript}}==

sum = 0

odd = true

test "49927398717"

test "1234567812345678"

 

{{out}}

 

=={{header|MUMPS}}==

NEW ODD,EVEN,S

SET S=$REVERSE(C)

SET ODD=0 FOR I=1:2:$LENGTH(S) SET ODD=ODD+$EXTRACT(S,I)

SET EVEN=0 FOR I=2:2:$LENGTH(S) SET T=$EXTRACT(S,I)*2 SET EVEN=EVEN+$SELECT(T<=9:T,T>9:$EXTRACT(T,1)+$EXTRACT(T,2))

<pre>USER>W !,$S($$LUHN^ROSETTA("49927398716")=0:"INVALID",1:"VALID")

=={{header|Nanoquery}}==

{{trans|Java}}

to_return = ""

 

println luhnTest("49927398717")

println luhnTest("1234567812345678")

{{out}}

<pre>true

 

=={{header|NetRexx}}==

class LuhnTest

 

end

return s//10\==0

 

=={{header|Nim}}==

const m = [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]

var sum = 0

for cc in ["49927398716", "49927398717", "1234567812345678", "1234567812345670"]:

 

{{out}}

 

=={{header|Objeck}}==

class Luhn {

function : IsValid(cc : String) ~ Bool {

}

}

 

=={{header|Objective-C}}==

NSMutableArray *characters = [[NSMutableArray alloc] initWithCapacity:[self length]];

BOOL test1 = [self luhnCheck:@"49927398717"]; //Result = NO

BOOL test2 = [self luhnCheck:@"1234567812345678"]; //Result = NO

 

=={{header|OCaml}}==

let rec g r c = function

| 0 -> r

in

(g 0 1 (String.length s)) mod 10 = 0

 

{{out}}

 

=={{header|Octave}}==

if isnumeric(s) s = mat2str(s); end; % make sure s is a string

d = s-'0'; % convert string into vector of digits

m = [2:2:8,1:2:9]; % rule 3: maps [1:9] -> i

y = ~mod(sum(d(end:-2:1)) + sum(m(d(end-1:-2:1))),10);

 

{{out}}

ans = 1

isluhn('49927398717')

isluhn('1234567812345670')

ans = 1

 

=={{header|Oforth}}==

 

| s i |

n asString reverse ->s

i isEven ifTrue: [ 2 * dup 10 >= ifTrue: [ 9 - ] ] +

]

 

{{out}}

 

=={{header|OpenEdge/Progress}}==

(INPUT pcNumber AS CHARACTER):

/*------------------------------------------------------------------------------

RETURN FALSE.

 

 

{{out}}

Numbers larger than 100 are not recognized by the interpreter in literal form and must instead be entered as "native" numbers (i.e. listing the separate digits as arguments to <code>8nat</code>).

Since internally, a native number is just a sequence of the digits in reverse order with an end digit marker, converting the number into a reversed list of digits mainly involves removing this terminator, so that we can immediately treat the digits as number elements.

 

#define ORDER_PP_DEF_8luhn ORDER_PP_FN( \

8nat(1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8),

8nat(1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,0)))

{{out}}

 

=={{header|Oz}}==

fun {Luhn N}

{Sum {List.mapInd {Reverse {Digits N}}

{Map

[49927398716 49927398717 1234567812345678 1234567812345670]

 

=={{header|Pascal}}==

 

 

begin

 

{{out}}

 

=={{header|Perl}}==

{

my @rev = reverse split //,$_[0];

print luhn_test('49927398717');

print luhn_test('1234567812345678');

 

Or using map( ) and a precomputed array:

 

my (@n,$i,$sum) = split //, reverse $_[0];

my @a = map {int(2*$_ / 10) + (2*$_ % 10)} (0..9);

# Test and display

map {print luhn($_), ": $_\n"}

 

{{out}}

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

 

=={{header|PHP}}==

{{trans|C}}

foreach (split(' ', $numbers) as $n)

echo "$n is ", luhnTest($n) ? 'valid' : 'not valid', '</br>';

}

return $sum % 10 == 0;

{{out}}

<pre>49927398716 is valid

 

And a more concise example using PHP core methods:

$str = '';

foreach( array_reverse( str_split( $num ) ) as $i => $c ) $str .= ($i % 2 ? $c * 2 : $c );

 

foreach (array('49927398716','49927398717','1234567812345678','1234567812345670') as $n)

{{out}}

<pre>49927398716 is valid

1234567812345670 is valid

</pre>

 

=={{header|PicoLisp}}==

(=0

(%

(flip (chop Num))

'(T NIL .) )

{{out}}

<pre>: (mapcar luhn (49927398716 49927398717 1234567812345678 1234567812345670))

 

=={{header|PL/I}}==

 

declare (cardnumber, rcn) character (20) varying;

put skip edit (cardnumber, ' does not pass the Luhn test' )(a);

put skip list (s1 + s2);

 

{{out}}

Comment: it isn't necessary to reverse the string

in order to perform the test.

 

=={{header|PL/SQL}}==

RETURN NUMBER

IS

RETURN 1;

 

=={{header|Plain English}}==

Start up.

Test whether "49927398716" will pass the luhn test.

 

To convert a byte to a number:

{{out}}

<pre>

=={{header|PowerBASIC}}==

{{trans|Visual Basic}}

#DIM ALL

#COMPILER PBCC 6

' this test is expected to pass:

CON.PRINT IIF$(LuhnCheckPassed("1234567812345670"), "passed", "failed")

{{out}}

<pre>passed

 

=={{header|PowerShell}}==

function Test-LuhnNumber

{

($sumOdds + $sumEvens).ToString()[-1] -eq "0"

}

Test-LuhnNumber 49927398716

{{Out}}

<pre>

True

</pre>

49927398716, 49927398717, 1234567812345678, 1234567812345670 | ForEach-Object {

"{0,-17}: {1}" -f $_,"$(if(Test-LuhnNumber $_) {'Is valid.'} else {'Is not valid.'})"

}

{{Out}}

<pre>

 

=={{header|PureBasic}}==

Sample:

Data.s "49927398716"

Input()

CloseConsole()

{{out}}

<pre>49927398716 is valid

===Functional===

The [http://docs.python.org/py3k/library/functions.html#divmod divmod] in the function below conveniently splits a number into its two digits ready for summing:

r = [int(ch) for ch in str(n)][::-1]

return (sum(r[0::2]) + sum(sum(divmod(d*2,10)) for d in r[1::2])) % 10 == 0

 

>>> for n in (49927398716, 49927398717, 1234567812345678, 1234567812345670):

 

{{out}}

Or, using itertools ''cycle'' with map and reduce:

{{Works with|Python|3.7}}

 

from operator import add, mul

 

if __name__ == '__main__':

{{Out}}

<pre>[True, False, False, True]</pre>

and cycle lambdas rather than integers.

 

 

from itertools import cycle

if __name__ == '__main__':

main()

{{Out}}

<pre>('49927398716', True)

===Procedural===

Without usingsum() and divmod() functions:

sum = 0

chParity = len(ch) % 2

for n in (49927398716, 49927398717, 1234567812345678, 1234567812345670):

print (str(n)+" =>", vérifLuhn(str(n)))

 

=={{header|Q}}==

luhn:{

r:reverse string x; / Reversed credit card number

e:("I"$) each r[1+2*til floor (count r) % 2]; / Even-indexed numbers

0=(sum o,sd each e*2) mod 10 / Return 1b if checksum ends in 0; 0b otherwise

 

{{out}}

=={{header|Quackery}}==

 

 

[ [] swap

else

[ say " invalid" ]

 

{{out}}

=={{header|R}}==

 

is.luhn <- function(cc){

numbers <- as.numeric(rev(unlist(strsplit(cc,""))))

sapply(c("49927398716","49927398717","1234567812345678","1234567812345670"),is.luhn)

 

 

{{out}}

=={{header|Racket}}==

 

#lang racket

 

(map luhn-test '(49927398716 49927398717 1234567812345678 1234567812345670))

;; -> '(#t #f #f #t)

 

=={{header|Raku}}==

If you rename it or change its behavior, make sure to update that task as well.

-->

my @digits = $number.comb.reverse;

my $sum = @digits[0,2...*].sum

is luhn-test(+$cc), $expected-result,

"$cc {$expected-result ?? 'passes' !! 'does not pass'} the Luhn test.";

 

{{out}}

ok 4 - 1234567812345670 passes the Luhn test.</pre>

 

=={{header|REXX}}==

===version 1===

#.=; #.1= 49927398716 /*the 1st sample credit card number. */

#.2= 49927398717 /* " 2nd " " " " */

$= $ + substr(y, j, 1) + left(_, 1) + substr(_, 2, 1, 0) /* ◄────────┐*/

end /*j*/ /*sum odd and even decimal digits ►────┘*/

{{out|output|text=&nbsp; when using the (internal) default inputs:}}

<pre>

 

===Version 2===

* 09.04.2013 Walter Pachl

* Implements the task's description in a rather concise way

sum=sum+c /* add into test sum */

End

{{out}}

<pre>

 

=={{header|Ring}}==

 

test = ["49927398716", "49927398717", "1234567812345678", "1234567812345670"]

next

return sumarr

Output:

<pre>

1234567812345678 -> Invalid

1234567812345670 -> Valid

</pre>

 

=={{header|Ruby}}==

str.scan(/\d/).reverse #using str.to_i.digits fails for cases with leading zeros

.each_slice(2)

 

["49927398716", "49927398717", "1234567812345678", "1234567812345670"].map{ |i| luhn_valid?(i) }

 

{{out}}

 

Simpler Alternative

d2sum = [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]

sum, num = 0, n.to_i

 

cards = [49927398716, "49927398717", 1234567812345678, "1234567812345670"]

 

{{out}}

 

=={{header|Run BASIC}}==

card$(2) = "49927398717"

card$(3) = "1234567812345678"

next i

if chkSum mod 10 = 0 then luhn$ = "True" else luhn$ = "False"

{{out}}

<pre>49927398716 True

 

=={{header|Rust}}==

 

use luhn_test_of_credit_card_numbers::luhn_test;

assert_eq!(validate_isin("FR0000988040"), true);

}

{{out}}

<pre>49927398716: true

 

===Functional style===

private def parse(s: String): Seq[Int] = s.map{c =>

assert(c.isDigit)

assert(Luhn.validate(n) == expected)

}

{{out}}

<pre>49927398716 true

 

===Imperative style===

var (odd, sum) = (true, 0)

 

}

sum % 10 == 0

 

=={{header|Scheme}}==

(lambda (n)

(let loop ((number n)

(remainder number 10)

(let ((part (* 2 (remainder number 10))))

{{out}}

<pre>

 

=={{header|sed}}==

s/.*/&: /

: split

/0:/!a\

Fail

 

{{out}}

 

=={{header|Seed7}}==

 

const func boolean: luhnTest (in string: cardNumber) is func

writeln(cardNumber <& ": " <& luhnTest(cardNumber));

end for;

 

{{out}}

 

=={{header|SenseTalk}}==

put length of ccNum into numDigits

put the last character of ccNum into total

end repeat

return total is divisible by 10

 

put it && LuhnCheck(it)

 

=={{header|SequenceL}}==

main(args(2)) :=

sum(luhnTest(asciiToInt(args[1]) - asciiToInt('0'))) mod 10 = 0;

x[i] when i mod 2 = size(x) mod 2 else

s2Mapping[x[i] + 1];

 

=={{header|Shen}}==

(define mapi

_ _ [] -> []

 

(map (function luhn?) ["49927398716" "49927398717" "1234567812345678" "1234567812345670"])

 

{{out}}

 

=={{header|Sidef}}==

static a = {|j| (2*j // 10) + (2*j % 10) }.map(^10)

 

for n in [49927398716, 49927398717, 1234567812345678, 1234567812345670] {

say [n, luhn(n)]

 

{{out}}

=={{header|SNOBOL4}}==

Using a precomputed array.

luhn_end

 

 

{{out}}

 

=={{header|SPARK}}==

 

A final test has been added which passes as valid unless there is an explicit test for all digits.

--# inherit Spark_IO;

--# main_program;

Do_Test("1234567812345670");

Do_Test("123456781234567D");

{{out}}

<pre>49927398716 is valid.

{{works with|Db2 LUW}}

With SQL PL:

--#SET TERMINATOR @

 

END

@

Output:

<pre>

 

=={{header|Standard ML}}==

fun revDigits 0 = []

| revDigits n = (n mod 10) :: revDigits (n div 10)

val res = [true, false, false, true] : bool list

[closing file "luhn.sml"]

 

=={{header|Swift}}==

return number.reversed().enumerated().map({

let digit = Int(String($0.element))!

 

luhn("49927398716") // true

 

=={{header|Tcl}}==

Based on an algorithmic encoding for the test on Wikipedia.

proc luhn digitString {

if {[regexp {[^0-9]} $digitString]} {error "not a number"}

}

return [expr {($sum % 10) == 0}]

Driver:

49927398716

49927398717

puts [format "%s is %s" $testNumber \

[lindex {"NOT valid" "valid"} [luhn $testNumber]]]

{{out}}

<pre>

 

=={{header|Terraform}}==

type = "string"

}

output "valid" {

value = local.check == 0

{{Out}}

<pre>$ terraform apply

 

=={{header|TI-83 BASIC}}==

:Disp "ENTER NUMBER"

:Input Str1

:Disp "BAD CARD"

:End

 

=={{header|Transact-SQL}}==

 

CREATE FUNCTION dbo._CreditCardNumCheck( @strCCNum VarChar(40) )

RETURNS VarChar(7)

RETURN CASE WHEN (SELECT SUM(S_Value) FROM @table) % 10 = 0 THEN 'Valid' ELSE 'Invalid' END

END

 

=={{header|TUSCRIPT}}==

MODE DATA

$$ SET cardnumbers=*

PRINT c,"false"

ENDIF

{{out}}

<pre>

=={{header|TXR}}==

 

(for ((i 1) (sum 0))

((not (zerop num)) (zerop (mod sum 10)))

@ccnumber -> @(if (luhn (int-str ccnumber 10)) "good" "bad")

@(end)

 

<pre>$ txr luhn.txr luhn.txt

{{works with|bash}}

{{works with|ksh}}

typeset n p s t=('0123456789' '0516273849')

while ((-n<${#1})); do

echo $c is valid

fi

 

Notes:

 

=={{header|Ursala}}==

#import nat

 

 

Some notes on this solution:

* The output from the function is tested for divisibility by 10 with <code>remainder\10</code>, with the result negated so that zero values map to true and non-zero to false.

usage:

 

{{out}}

<pre>

 

=={{header|VBA}}==

Option Explicit

 

Luhn = "invalid"

End If

{{out}}

<pre>Number 49927398716 is valid

 

=={{header|VBScript}}==

cc = RevString(cc)

s1 = 0

WScript.Echo "49927398717 is " & Luhn_Test("49927398717")

WScript.Echo "1234567812345678 is " & Luhn_Test("1234567812345678")

 

{{out}}

=={{header|Visual Basic}}==

{{works with|Visual Basic|VB6 Standard}}

Dim i As Long, s As Long, s1 As Long

dgts = VBA.StrReverse(dgts)

Next i

LuhnCheckPassed = Not CBool(s Mod 10)

 

Test:

Debug.Assert LuhnCheckPassed("49927398716")

Debug.Assert Not LuhnCheckPassed("49927398717")

Debug.Assert Not LuhnCheckPassed("1234567812345678")

Debug.Assert LuhnCheckPassed("1234567812345670")

 

=={{header|Visual Basic .NET}}==

Imports System.Linq

Function ValidLuhn(value As String)

Console.WriteLine(ValidLuhn("1234567812345670"))

End Sub

{{out}}

<pre>

False

True

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var luhn = Fn.new { |s|

for (test in tests) {

var ans = (luhn.call(test)) ? "pass" : "fail"

 

{{out}}

 

=={{header|Xojo}}==

//

// Confirm the digits are really, well, digits

return Modulus10( digits ) = checkDigit

End Function

{{out}}

<pre>

 

=={{header|XPL0}}==

 

func Valid(Str); \Return 'true' if digits in Str pass Luhn test

CrLf(0);

];

 

{{out}}

 

=={{header|zkl}}==

0 == (n.split().reverse().reduce(fcn(s,n,clk){

s + if(clk.next()) n else 2*n%10 + n/5 },0,Walker.cycle(1,0)) %10)

{{out}}

<pre>

 

=={{header|ZX Spectrum Basic}}==

20 LET c$="49927398717": GO SUB 1000

30 LET c$="1234567812345678": GO SUB 1000

1150 IF s$(LEN s$)="0" THEN PRINT c$;" VALID!": LET retval=1: RETURN

1160 PRINT c$;" INVALID!": LET retval=0: RETURN

{{out}}

<pre>