挑战

编写最短的程序或函数以计算用于验证（信用卡）号码的Luhn算法。

Luhn算法解释

在RosettaCode中，为此挑战指定了该算法，其示例输入为49927398716：

Reverse the digits, make an array:
    6, 1, 7, 8, 9, 3, 7, 2, 9, 9, 4
Double the numbers in odd indexes:
    6, 2, 7, 16, 9, 6, 7, 4, 9, 18, 4
Sum the digits in each number:
    6, 2, 7, 7, 9, 6, 7, 4, 9, 9, 4
Sum all of the numbers:
    6 + 2 + 7 + 7 + 9 + 6 + 7 + 4 + 9 + 9 + 4 = 70
If the sum modulo 10 is 0, then the number is valid:
    70 % 10 = 0 => valid

IO规则

输入：您选择的语言输入/输出格式的字符串或数字（您的选择）

输出：真实或错误的值，分别表示根据上述测试输入是否有效。

注释/提示

• 如果使用它们来测试，请尽量不要意外发布您自己的信用卡或帐号：)

• 如果输入无效并且无法使用指定的算法进行处理（即太短而无法使用），则可以执行所需的任何操作，包括炸毁我的计算机。

• 但是，前面的符号并不意味着您的语言可以使用太大而无法处理的Numbers来完成您想要的任何事情。如果您的语言无法处理测试用例，请考虑采用字符串作为输入。

例子

以下示例已使用此Python脚本进行了验证；如果您认为错误或有疑问，请ping @cat。

49927398716      True
49927398717      False
1234567812345670 True    
1234567812345678 False
79927398710      False
79927398711      False
79927398712      False
79927398713      True
79927398714      False
79927398715      False
79927398716      False
79927398717      False
79927398718      False
79927398719      False
374652346956782346957823694857692364857368475368 True
374652346956782346957823694857692364857387456834 False
8 False **
0 True  **

**根据Python实现，但是您可以执行任何操作，因为这些时间太短，无法严格遵守规范。

如果上述任何方法使现有答案无效（尽管我认为这不可能），则这些答案仍然有效。但是，新的答案为了有效，应遵循上面的说明。

排行榜

var QUESTION_ID=22,OVERRIDE_USER=73772;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Golfscript-24个字符

-1%{2+0!:0)*109%+}*10%8=

说明：

1. -1% 反转字符串
2. {开始一个块（我们将其用作循环）。字符串中的每个字符都按其ascii值进行推送。
   1. 2+ 加2。（一个数字的ascii值为48 + n，所以我们现在有50 + n，最后一个数字为n）
   2. 0!:0 反转0的值并将其存储（所有都是变量），因此在第一次迭代中有1，在第二次迭代中有0，依此类推。
   3. )* 向此值加1并将其相乘，因此我们先乘以2，然后乘以1，然后乘以2，依此类推。
   4. 109% 余数取模109。这仅影响值5-9（已加倍）并将其减小为正确值。
   5. + 将此值添加到运行总和
3. }*结束该块并执行“折叠”操作。首先，第一个字符被按下（由于我们已经反转了，所以这是校验位）。然后，交替推动并执行该块。因此，我们将第一个字符的ascii值用作运行总和的起始值。
4. 10% 将余数取模10
5. 8= 如果值为8，将返回1。我们使用此方法是因为我们没有规范化第一个被压入的字符（校验位）。

可能有人以为我们可以通过更改为8-而不是使用2+保存字符，除非我们需要添加一个空格以使减号（而不是）。109%89%--0

GolfScript，44个字符

-1%{16%}%2/1,\+{(\.{0=2*.9>9*-+}{;}if+}*10%!

精选评论

有趣的是，下面的前两项展示了该%运算符的三种完全不同的用法：数组选择，映射和mod。大多数GolfScript运算符是“上下文敏感的”，根据参数的类型，它们的行为迥然不同。

1. -1%反转字符串。这很重要，因为数字对是从右边开始计数的。
2. {16%}% 通过将16修改为所有ASCII数字，将其转换为数字。
3. 2/ 将数组分成2组。
4. 1,是一种便宜的做法[0]。
5. \+有效地将0附加到digits数组。它通过交换然后进行连接来实现。

0之前是为下一步折叠而准备的。GolfScript的折叠不使用显式的初始值，而是使用数组中的第一项作为初始值。

现在，让我们看一下实际的折叠功能。此函数有两个参数：折叠值和数组中的当前项（在此情况下，数组为2或（通常为1），因为数组2/较早）。假设参数为1 [2 3]。

1. (\.拆分最左边的数组元素，将剩余的数组移到最前面，然后复制它。堆栈现在看起来像：1 2 [3] [3]。
2. 在if检查该数组为空（这是用于与奇数大小帐号处理时在最后一组的情况下）。如果是这样，则不会进行任何特殊处理（只需弹出空数组）。
3. 对于一个均匀的组：
   1. 0= 获取数组的第一个（在这种情况下，只有这种情况）元素。 1 2 3
   2. 2* 将数字加倍。 1 2 6
   3. .9>9*- 如果数字大于9，则从数字中减去9。实现为：复制数字，与9进行比较，将结果（0或1）乘以9，然后相减。 1 2 6
   4. + 最后将其添加到第一个数字中。 1 8
4. +（在之后if），将的结果if与原始值相加，得到新的折叠值。

折叠完成后，我们简单地对10（10%）进行mod 运算，然后对结果（!）求反，以便在总和为10的倍数时返回1。

Python，73 69个字符

def P(x):D=map(int,x);return sum(D+[d-d/5*9for d in D[-2::-2]])%10==0

Python 3，77个字节

c=lambda a:sum(sum(divmod(int(a[-e-1])<<e%2,10))for e in range(len(a)))%10==0

C＃119个字符：

bool l(string n){return(String.Join("",n.Reverse().Select((x,i)=>(x-48)*(i%2<1?1:2)+"").ToArray()).Sum(x=>x-48))%10<1;}

不是太糟糕的是静态类型语言代码高尔夫的n00b，我希望。

可以减少到100：

bool l(string n){return String.Join("",n.Reverse().Select((x,i)=>(x-48)*(i%2+1))).Sum(x=>x+2)%10<1;}

Golfscript-34个字符

{15&}%.-2%\);-2%{.+(9%)}%+{+}*10%!

维基百科第4992739871页的示例编号

{15&}%  does a bitwise and of each ascii digit with 00001111
        now I have a list of digits 
        [4 9 9 2 7 3 9 8 7 1 6]
.       makes a copy of the list, now I have two identical lists
        [4 9 9 2 7 3 9 8 7 1 6] [4 9 9 2 7 3 9 8 7 1 6]
-2%     like [::-2] in python takes every second element in reverse
        [4 9 9 2 7 3 9 8 7 1 6] [6 7 9 7 9 4]
\       swap the two lists around
        [6 7 9 7 9 4] [4 9 9 2 7 3 9 8 7 1 6]
);      drop the last digit off the list
        [6 7 9 7 9 4] [4 9 9 2 7 3 9 8 7 1]
-2%     same as before
        [6 7 9 7 9 4] [1 8 3 2 9]
{       for each item in the list ...
.+      ... double it ...
(       ... subtract 1 ...
9%      ... mod 9 ...
)}%     ... add 1 ...
        [6 7 9 7 9 4] [2 7 6 4 9]
+       join the two lists
        [6 7 9 7 9 4 2 7 6 4 9]
{+}*    add the elements up
        70
10%     mod 10
        0
!       invert the result
        1

PHP，108字节

<?function v($s,$t=0){for($i=strlen($s);$i>=0;$i--,$c=$s[$i])$t+=$c+$i%2*(($c>4)*-4+$c%5);return!($t % 10);}

Ruby-85个字符

def f s
l=s.size
s.chars.map{|k|(i=k.to_i*((l-=1)%2+1))%10+i/10}.inject(:+)%10==0
end

Haskell，96个字节

必须有一个更好/更短的方法，但这是我用96个字符表示的Haskell解决方案：

l=(==0).(`mod`10).sum.zipWith($)(cycle[id,\x->x`mod`5*2+x`div`5]).reverse.map((+(-48)).fromEnum)

可悲的是，该digitToInt功能只能在您import Data.Char首先使用时使用。否则，我可以通过更换下来到88个字符((+(-48)).fromEnum)使用digitToInt。

Windows PowerShell，82

filter f{!((''+($_[($_.length)..0]|%{+"$_"*($i++%2+1)})-replace'.','+$&'|iex)%10)}

历史：

• 2011-02-13 03:08（84）第一次尝试。
• 2011-02-13 12:13（82）我不需要参加，因为空格不会伤害您。+1 + +3仍然可以评估。

问63

{0=mod[(+/)"I"$(,/)($)($)@["I"$'x;1+2*'(!)(_)((#)x)%2;*;2];10]}

用法

q){0=mod[(+/)"I"$(,/)($)($)@["I"$'x;1+2*'(!)(_)((#)x)%2;*;2];10]}"79927398711"
0b
q){0=mod[(+/)"I"$(,/)($)($)@["I"$'x;1+2*'(!)(_)((#)x)%2;*;2];10]}"79927398712"
0b
q){0=mod[(+/)"I"$(,/)($)($)@["I"$'x;1+2*'(!)(_)((#)x)%2;*;2];10]}"79927398713"
1b

D，144字节

bool f(S)(S s){int t(C)(C c){return to!int(c)-'0';}int n,v;foreach(i,c;array(retro(s))){v=i&1?t(c)*2:t(c);n+=v>=10?v%10+v/10:v;}return n%10==0;}

更清晰：

bool f(S)(S s)
{
    int t(C)(C c)
    {
        return to!int(c) - '0';
    }

    int n, v;

    foreach(i, c; array(retro(s)))
    {
        v = i & 1 ? t(c) * 2 : t(c);

        n += v >= 10 ? v % 10 + v / 10 : v;
    }

    return n % 10 == 0;
}

APL，28 个字节

{0=10|+/⍎¨∊⍕¨v×⌽2-2|⍳⍴v←⍎¨⍵}

分解图

{                     v←⍎¨⍵}  ⍝ turn the string into a numeric vector of its digits, v
                2-2|⍳⍴v       ⍝ make a vector of the same length, with 2 in every 2nd place
             v×⌽              ⍝ multiply it with v, starting from the right
          ∊⍕¨                 ⍝ turn each component into a string and collect all the digits
      +/⍎¨                    ⍝ turn each digit again into a number and sum them
 0=10|                        ⍝ check whether the sum is a multiple of 10

例子

      {0=10|+/⍎¨∊⍕¨v×⌽2-2|⍳⍴v←⍎¨⍵} '79927398713'
1
      {0=10|+/⍎¨∊⍕¨v×⌽2-2|⍳⍴v←⍎¨⍵} '123456789'
0

PowerShell 123

filter L($x){$l=$x.Length-1;$l..0|%{$d=$x[$_]-48;if($_%2-eq$l%2){$s+=$d}elseif($d-le4){$s+=$d*2}else{$s+=$d*2-9}};!($s%10)}

Perl，46 42 41字节

包括+1的 -p

在STDIN上输入：

luhn.pl <<< 79927398713

luhn.pl：

#!/usr/bin/perl -p
s%.%$=-=-$&-$&*1.2*/\G(..)+$/%eg;$_=/0$/

JavaScript（ES6），61个字节

不竞争，因为JavaScript在2011年大为不同。

的数字之和2*n是2*n如果n in 0..4，2*n-9如果n in 5..9。也就是说，所有的总和都可以一步计算。

s=>!([...s].reduceRight((t,d)=>t-d-i++%2*(d>4?d-9:d),i=0)%10)

果冻，12 11字节

ṚḤJḤ$¦DFS⁵ḍ

在线尝试！（包含所有测试用例）

这个怎么运作

ṚḤJḤ$¦DFSḍ⁵  - Main link. Argument: n (integer) e.g. 49927398716
Ṛ            - Reverse. Casts a number to digits     [6, 1, 7, 8, 9, 3, 7, 2, 9, 9, 4]
     ¦       - Sparse application. Apply the next command to the given indicies
 Ḥ           -   Command: Double
    $        -   Indicies:
  J          -     range(length)...                  [1, 2 , 3, 4, 5, 6, 7, 8, 9, 10, 11]
   Ḥ         -     doubled.                          [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
             - Doubles elements at odd indicies      [6, 2, 7, 16, 9, 6, 7, 4, 9, 18, 4]
      D      - Split each into digits                [6, 2, 7, [1, 6], 9, 6, 7, 4, 9, [1, 8], 4]
       F     - Flatten                               [6, 2, 7, 1, 6, 9, 6, 7, 4, 9, 1, 8, 4]
        S    - Sum                                   70
          ḍ  - Divisible by... 
         ⁵   -   10?                                 1

或者，对于12个字节：

ṚḤJḤ$¦DFSḍ@⁵

8086组装，IBM PC DOS，29 28 25 23字节

; Perform LUHN check
; Input: SI = card num string, CX = length
; Output: ZF = 1 if valid, ZF = 0 if not valid
    LUHN    MACRO
            LOCAL DIGIT_LOOP, EVEN
03 F1       ADD  SI, CX         ; start at end of input string 
FD          STD                 ; set LODSB direction to decrement 
    DIGIT_LOOP:
AC          LODSB               ; load next digit into AL, decrement SI
2C 30       SUB  AL, '0'        ; convert ASCII char to binary value 
F7 DA       NEG  DX             ; flip DX to alternate odd/even index
78 06       JS   EVEN           ; if even index, do not double and sum digits 
D0 E0       SHL  AL, 1          ; double the value 
D4 0A       AAM                 ; BCD convert to split digits (ex: 18 = 12H --> 0108H) 
02 DC       ADD  BL, AH         ; add tens digit to running sum 
    EVEN:
02 D8       ADD  BL, AL         ; add ones digit to running sum 
E2 ED       LOOP DIGIT_LOOP 
93          XCHG BX, AX         ; sum is in BL, move to AL for conversion
D4 0A       AAM                 ; BCD convert AL, set ZF=1 if low digit is 0
    ENDM

使用（滥用）x86的BCD到二进制指令来处理单个数字的拆分和modulo 10检查。事实证明，AAM和AAD指令可以对字节值进行BCD /二进制转换（可能非常方便），尽管它们没有被记录或描述为一般执行该功能。

对于所有的官方IBM / MS DOS版本，AX并且BX被初始化为0000在启动时（REF，REF）和DX到CS，这是这样保证是非零正和一个12位的值。这就是我们可以保证BX的0并且可以翻转/翻转DX以确定奇数/偶数位的方式。

输出示例：

下载LUHN.COM IBM PC DOS测试程序。

斯卡拉：132

def q(x:Int)=x%10+x/10
def c(i:String)={val s=i.reverse
(s(0)-48)==10-(s.tail.sliding(2,2).map(n=>(q((n(0)-48)*2)+n(1)-48)).sum%10)}

调用：

c("79927398713")

• 反向（“ 79927398713”）= 31789372997
• s（0），s.tail：（3）（1789372997）
• 滑动（2,2）=（17 89 37 29 97）
• 映射（q（（n（0）-48 * 2 + n（1）-48））=> q（（'1'-'0'）* 2）+'7'-'0'）= 1 * 2 + 7

JavaScript 1.8：106个字符

这是我找到这篇文章之前想出的原始解决方案：

function(n){return!(n.split('').reverse().reduce(function(p,c,i){return(+c&&((c*(1+i%2)%9)||9))+p},0)%10)}

可读形式：

function luhnCheck(ccNum) {
    return !(                                  // True if the result is zero.
             ccNum.split('').
               reverse().                      // Iterate over the string from rtl.
               reduce(function(prev, cur, idx) {
                 return prev +                 // Sum the results of each character.
                        (+cur &&               // If the current digit is 0, move on.
                         ((cur * (1 + idx % 2) // Double cur at even indices.
                           % 9) || 9));        // Sum the digits of the result.
               }, 0)
            % 10);                             // Is the sum evenly divisible by 10?
}

K4，35个字节

{~.*|$+/.:',/$x*1+1{y;~x}\|x:|.:'x}

视网膜，43 42字节

视网膜比这个挑战要新得多。

;
r`(.);.
$1$&
\d
$*
1+
$.&
.
$*
$
$._
0$

前导空行很重要。

打印0虚假和1真实的结果。

在线尝试！（稍作修改即可一次运行所有测试用例。）

说明

;

;在每个位置插入以分隔数字。

r`(.);.
$1$&

从r右边开始，我们反复匹配两个数字，然后将左边的数字翻倍。这样，我们避免了昂贵的列表反转。

\d
$*

我们匹配每个数字并将其转换为这么多1s（即，将每个数字转换为一进制）。

1+
$.&

这将匹配每个一元数，并通过将其替换为长度将其转换回十进制。与上一阶段一起，这将增加两位数。

.
$*

同样，我们匹配每个字符并将其变成那么多1。也就是说，我们将每个数字分别转换回一元。这也与;分隔符匹配，分隔符在转换中被视为零，这意味着它们被简单地删除了。由于所有一元数现在都被压缩在一起，因此我们自动将所有数字的一元表示形式加在一起。

$
$._

最后，我们插入整个字符串的长度，即一进制校验和的十进制表示形式。

0$

最后，我们计算此正则表达式的匹配数，即检查小数表示是否以0，打印0或1相应结尾。

Powershell，74个字节

param($s)$s[$s.Length..0]|%{(1+$i++%2)*"$_"}|%{$r+=$_-9*($_-gt9)}
!($r%10)

说明

1. 对于参数字符串的每个字符，按相反顺序
2. 得到一个数字的两倍的数字
3. 一个数字的双精度值不能大于18。因此，如果value> 9，我们将得到一个值减去9。
4. 如果除以10的余数为0，则返回true

测试脚本

$f = {

param($s)$s[$s.Length..0]|%{(1+$i++%2)*"$_"}|%{$r+=$_-9*($_-gt9)}
!($r%10)

}

@(
    ,("49927398716"      , $True)
    ,("49927398717"      , $False)
    ,("1234567812345670" , $True)
    ,("1234567812345678" , $False)
    ,("79927398710"      , $False)
    ,("79927398711"      , $False)
    ,("79927398712"      , $False)
    ,("79927398713"      , $True)
    ,("79927398714"      , $False)
    ,("79927398715"      , $False)
    ,("79927398716"      , $False)
    ,("79927398717"      , $False)
    ,("79927398718"      , $False)
    ,("79927398719"      , $False)
    ,("374652346956782346957823694857692364857368475368" , $True)
    ,("374652346956782346957823694857692364857387456834" , $False)
    ,("8" , $False)
    ,("0" , $True)
) | % {
    $s, $expected = $_
    $result = &$f $s
    "$($result-eq$expected): $result : $s"
}

输出量

True: True : 49927398716
True: False : 49927398717
True: True : 1234567812345670
True: False : 1234567812345678
True: False : 79927398710
True: False : 79927398711
True: False : 79927398712
True: True : 79927398713
True: False : 79927398714
True: False : 79927398715
True: False : 79927398716
True: False : 79927398717
True: False : 79927398718
True: False : 79927398719
True: True : 374652346956782346957823694857692364857368475368
True: False : 374652346956782346957823694857692364857387456834
True: False : 8
True: True : 0

05AB1E，12 10字节

RSāÈ>*SOTÖ

在线尝试！ 或作为测试套件

说明

R             # reverse input
 S            # split to list of digits
  ā           # push range[1 ... len(input)]
   È          # map isEven on each
    >         # increment
     *        # multiply doubling every other item
      SO      # sum digits
        TÖ    # mod 10 == 0

Haskell：97

由于某种原因，这对我不起作用，所以这是我的版本

l=(\x->(==0)$(`mod`10).sum$zipWith($)(cycle[id,sum.map(read.(:"")).show.(*2)])(map(read.(:""))x))

GNU sed，140字节

（包括+1 -r）

s/^(..)*.$/0&/
s/(.)./\1x&/g
s/x[5-9]/1&/g
s/[0x]//g
s/[789]/&6/g
s/[456]/&3/g
s/[369]/&11/g
s/[258]/&1/g
s/.{10}//g
s/.+/false/
s/^$/true/

Sed几乎从来不是最自然的算术语言，但是我们来：

#!/bin/sed -rf

# zero-pad to even length
s/^(..)*.$/0&/
# double every other digit
s/(.)./\1x&/g
# add carry (converts mod-9 to mod-10)
s/x[5-9]/1&/g
# convert sum to unary
s/[0x]//g
s/[789]/&6/g
s/[456]/&3/g
s/[369]/&11/g
s/[258]/&1/g
# remove whole tens
s/.{10}//g
# output 'true' or false
s/.+/false/
s/^$/true/

APL，38 个字节

d←10∘⊥⍣¯1⋄{0=10|+/+/d x×1+~2|⍳⍴x←⌽d ⍵}

期望数字为数字，而不是字符串，但这仅是因为tryAPL（可理解）未实现⍎

我可以进一步简化

PHP-136个字符

function t($c){foreach($a=str_split(strrev($c)) as $k=>&$v){$v=array_sum(str_split(($k % 2)!==0?2*$v:$v));}return !(array_sum($a)% 10);}

MATL，23 20字节（非竞争）

P!Utn:2X\!*t9>+s10\~

在线尝试！

输出1表示有效数字，否则输出0。

感谢Luis Mendo的建议，节省了三个字节。

说明

P       % flip the order of elements
!       % transpose into column vector
U       % convert char matrix to numeric
t       % duplicate the vector
n       % find the length
:       % create a new vector length n (1, 2, 3, ... n)
2       % number literal
X\      % take it mod 2, to make the new vector (1, 2, 1, ..., (n-1) mod 2 +1)
!       % transpose
*       % element-wise product
t       % duplicate
9       % push 9
>       % 1 if it is greater than 9
+       % add the vectors, this makes the last digit of each the same as the sum of the digits
s       % add them
10      % number literal
\       % mod 10
~       % logical 'not' (element-wise)
        % (implicit) convert to string and display

果冻，14字节

DUḤJḤ$¦DS$€S⁵ḍ

在线尝试！

说明：

D              get digits
 U             reverse array
   JḤ$         for every other index,
  Ḥ   ¦        double the value
          €    for each value,
       D $     get the digits
        S$     and sum them
           S   sum the list
            ⁵ḍ check if it's divisible by 10