的EAN-8条码包括的信息和第八校验和数字7位数字。

通过将数字分别乘以3和1，将结果相加，然后从下一个10的倍数中减去，来计算校验和。

例如，给定数字2103498：

Digit:        2   1   0   3   4   9   8
Multiplier:   3   1   3   1   3   1   3
Result:       6   1   0   3  12   9  24

这些结果数字的总和为55，所以校验和数字为60-55 = 5

挑战

给定一个8位条形码，您的任务是验证它是否有效-如果校验和有效，则返回真实值，否则返回false。

• 您可以采用以下任何形式的输入：
  • 长度为8个字符的字符串，代表条形码数字
  • 8个整数的列表，条形码的数字
  • 一个非负整数（您可以假设前导零而不给出任何前导零，即1= 00000001，或请求输入中给出零）
• 禁止计算EAN-8校验和的内置函数（即，使用前7位数字并计算最后7位数字）。
• 这是代码高尔夫球，因此最短的程序（以字节为单位）获胜！

测试用例

20378240 -> True
33765129 -> True
77234575 -> True
00000000 -> True

21034984 -> False
69165430 -> False
11965421 -> False
12345678 -> False

果冻，7个字节

s2Sḅ3⁵ḍ

在线尝试！

怎么运行的

s2Sḅ3⁵ḍ  Main link. Argument: [a,b,c,d,e,f,g,h] (digit array)

s2       Split into chunks of length 2, yielding [[a,b], [c,d], [e,f], [g,h]].
  S      Take the sum of the pairs, yielding [a+c+e+g, b+d+f+h].
   ḅ3    Convert from ternary to integer, yielding 3(a+c+e+g) + (b+d+f+h).
     ⁵ḍ  Test if the result is divisible by 10.

JavaScript（ES6），41 40 38字节

@ETHProductions节省了2个字节，@ Craig Ayre节省了1个字节。

s=>s.map(e=>t+=e*(i^=2),t=i=1)|t%10==1

将输入作为数字列表。

确定所有数字的总和，包括校验和。

如果总和是10的倍数，则它是有效的条形码。

测试用例

let f=

s=>s.map(e=>t+=e*(i^=2),t=i=1)|t%10==1

console.log(f([2,0,3,7,8,2,4,0]));
console.log(f([3,3,7,6,5,1,2,9]));
console.log(f([7,7,2,3,4,5,7,5]));
console.log(f([0,0,0,0,0,0,0,0]));

console.log(f([2,1,0,3,4,9,8,4]));
console.log(f([6,9,1,6,5,4,3,0]));
console.log(f([1,1,9,6,5,4,2,1]));
console.log(f([1,2,3,4,5,6,7,8]));

Python 2中，64 48 35 29个字节

mypetlion保存了19个字节

lambda x:sum(x[::2]*2+x)%10<1

在线尝试！

果冻，8字节

m2Ḥ+µS⁵ḍ

尝试测试套件。

果冻，9 个字节

JḂḤ‘×µS⁵ḍ

在线尝试或尝试测试套件。

如何运作

m2Ḥ+ µS⁵ḍ〜完整程序。

m2〜模块化2。返回输入的第二个元素。
  Ḥ〜每个加倍。
   + µ〜追加输入并开始新的单子链。
     S〜总和
      ⁵ḍ〜被10整除吗？

JḂḤ'×µS⁵ḍ〜完整程序（单声道）。

J〜1分度长度范围。
 Ḃ〜位；将上述范围内的每个数字乘以2。
  Ḥ〜每个加倍。
   '〜每个递增。
    ×〜与输入成对相乘。
     µ〜开始一个新的单子链。
      S〜总和
       ⁵ḍ〜总和可以除以10吗？

条形码的前7位数字和校验和数字的结果必须加10的倍数才有效。因此，如果应用于整个列表的算法可被10整除，则校验和有效。

MATL，10字节

感谢@Zgarb指出了一个错误，现在已更正。

IlhY"s10\~

在线尝试！或验证所有测试用例。

说明

Ilh     % Push [1 3]
Y"      % Implicit input. Run-length decoding. For each entry in the
        % first input, this produces as many copies as indicated by
        % the corresponding entry of the second input. Entries of
        % the second input are reused cyclically
s       % Sum of array
10\     % Modulo 10
~       % Logical negate. Implicit display

Befunge-98（PyFunge），16 14字节

通过使用j代替;s 跳过第二部分，以及在第一部分交换a ~和+在第二部分中摆脱a +，从而节省了2个字节。

~3*+~+6jq!%a+2

输入为8位数字（如果适用，前导数字为0）。

通过退出代码输出（在TIO上打开调试下拉列表），其中1为true，0为false。

在线尝试！

说明

该程序使用各种技巧。

首先，它通过ASCII值将数字一一对应。通常，这需要从我们从输入中读取的每个值中减去48。但是，如果不进行修改，我们的总和将剩下16个（3 + 1 + 3 + 1 + 3 + 1 + 3 + 1）额外的48个副本，这意味着我们的总数将比768大它应该是什么。由于我们只关心总和mod 10，因此我们可以稍后再将2加和。因此，我们可以采用原始ASCII值，节省6个字节左右。

其次，此代码仅检查是否每个其他字符都是EOF，因为保证输入的长度仅为8个字符。

第三，该#行末尾的不会跳过第一个字符，但是会;从另一方向跳过。这比#;在前面放一个更好。

因为程序的第二部分仅运行一次，所以我们不必对其进行设置，以便在向后运行时跳过第一部分。这使我们可以使用jump命令跳过后半部分，因为我们在执行向后执行之前退出。

一步步

注意：“奇数”和“偶数”字符基于0索引系统。第一个字符是偶数，索引为0。

~3*+~+      Main loop - sum the digits (with multiplication)
~           If we've reached EOF, reverse; otherwise take char input. This will always
                be evenly indexed values, as we take in 2 characters every loop.
 3*+        Multiply the even character by 3 and add it to the sum.
    ~       Then, take an odd digit - we don't have to worry about EOF because
                the input is always 8 characters.
     +      And add it to the sum.
      6j    Jump over the second part - We only want to run it going backwards.

        q!%a+2    The aftermath (get it? after-MATH?)
            +2    Add 2 to the sum to make up for the offset due to reading ASCII
          %a      Mods the result by 10 - only 0 if the bar code is valid
         !        Logical not the result, turning 0s into 1s and anything else into 0s
        q         Prints the top via exit code and exits

C， 78  77字节

i,s,c,d=10;f(b){for(i=s=0,c=b%d;b/=d;)s+=b%d*(3-i++%2*2);return(d-s%d)%d==c;}

在线尝试！

C（gcc），72个字节

i,s,c,d=10;f(b){for(i=s=0,c=b%d;b/=d;)s+=b%d*(i++%2?:3);b=(d-s%d)%d==c;}

在线尝试！

Wolfram语言（Mathematica），26 21字节

10∣(2-9^Range@8).#&

在线尝试！

将输入作为8位数字的列表。

怎么运行的

2-9^Range@8是10的模全同2-(-1)^Range@8，即{3,1,3,1,3,1,3,1}。我们将这个列表的点积与输入进行比较，并检查结果是否可被10整除。

Wolfram语言（Mathematica），33字节，不竞争

Check[#~BarcodeImage~"EAN8";1,0]&

在线尝试！

将输入作为字符串。返回1有效条形码和0无效条形码。

怎么运行的

我可以通过内置方式找到最好的东西（因为Mathematica就是关于这些的）。

内部位#~BarcodeImage~"EAN8";1生成EAN8条形码的图像，然后将其完全忽略并评估为1。但是，如果条形码无效，则会BarcodeImage生成一条警告，Check捕获该警告，在这种情况下返回0。

Java 8，58 56 55字节

a->{int r=0,m=1;for(int i:a)r+=(m^=2)*i;return r%10<1;}

通过@RickHitchcock间接感谢-2个字节，方法是使用(m=4-m)*i而不是m++%2*2*i+i在他的JavaScript答案中看到它。通过使用代替，
间接感谢@ETHProductions（和@RickHitchcock）-1个字节。(m^=2)*i(m=4-m)*i

说明：

在这里尝试。

a->{              // Method with integer-array parameter and boolean return-type
  int r=0,        //  Result-sum
      m=1;        //  Multiplier
  for(int i:a)    //  Loop over the input-array
    r+=           //   Add to the result-sum:
       (m^=2)     //    Either 3 or 1,
       *i;        //    multiplied by the digit
                  //  End of loop (implicit / single-line body)
  return r%10<1;  //  Return if the trailing digit is a 0
}                 // End of method

05AB1E，14个字节

θ¹¨3X‚7∍*O(T%Q

在线尝试！

需要前导0s，需要数字列表。

Pyth，8个字节

!es+*2%2

验证所有测试用例！

Pyth，13个字节

如果我们可以假设输入总是正好有8位数字：

!es.e*bhy%hk2

验证所有测试用例！

这是如何运作的？

！es + * 2％2〜完整程序。

      ％2〜输入[:: 2]。输入的第二个元素。
    * 2〜双（重复列表两次）。
   +〜追加输入。
  s〜总和。
 e〜最后一位。
！〜逻辑非。

！es.e * sbhy％hk2〜完整程序。

               〜将输入转换为字符串。
   .e〜枚举映射，将当前值存储在b中，将索引存储在k中。
          ％hk2〜索引的奇偶校验。（k +1）％2。
        hy〜两倍，递增。这会将奇数整数映射为1，将偶数整数映射为3。
      b〜当前数字。
     *〜相乘。
  s〜总和。
 e〜最后一位。
！〜逻辑否定。

如果应用算法后的前7位数字之和从10中减去，然后与最后一位数字进行比较，则等效于在应用算法后检查所有数字之和是否为10的倍数。

Haskell，40 38字节

a=3:1:a
f x=mod(sum$zipWith(*)a x)10<1

在线尝试！

将输入作为8个整数的列表。一个使用无限列表的实际示例。

编辑：由于GolfWolf，节省了2个字节

视网膜，23 22字节

-1字节感谢Martin Ender！

(.).
$1$1$&
.
$*
M`
1$

在线尝试！

说明

输入示例： 20378240

(.).
$1$1$&

用重复两次的第一个数字替换每个数字对，然后是数字对本身。我们得到2220333788824440

.
$*

将每个数字转换为一元。为了清楚起见加上括号，我们得到(11)(11)(11)()(111)(111)...

M`

计算空字符串的匹配数目，该数目比字符串中的匹配数目大一。（在最后两个步骤中，我们基本上对每个数字+1求和）结果：60

1$

1在字符串末尾匹配a 。我们将数字分别乘以3和1并相加，对于有效的条形码，该数字应被10整除（最后一位为0）；但我们在最后一步中也添加了1，因此我们希望最后一位为1。最终结果：1。

PowerShell，85字节

param($a)(10-(("$a"[0..6]|%{+"$_"*(3,1)[$i++%2]})-join'+'|iex)%10)%10-eq+"$("$a"[7])"

在线尝试！或验证所有测试用例

实现定义的算法。接受输入$a，用拉出每个数字，"$a"[0..6]然后用循环遍历它们|%{...}。每次迭代时，我们将数字取为数字，将其转换为字符串，"$_"然后将其转换为int，+然后再乘以3or或1（通过增加$imodulo 选择2）。

这些结果全部收集起来并加总-join'+'|iex。我们采用该结果mod 10，从中减去该值10，然后再次采用结果mod 10（这第二个mod是考虑00000000测试用例所必需的）。然后，我们检查-eq该数字是否与最后一位数字相同。该布尔结果留在管道上，并且输出是隐式的。

果冻，16字节

ż3,1ṁ$P€SN%⁵
Ṫ=Ç

在线尝试！

将输入作为数字列表

APL（Dyalog），14个字节

等同于流浪汉的解决方案。

完整的程序主体。提示输入来自STDIN的数字列表。

0=10|+/⎕×8⍴3 1

在线尝试！

是...

 0= 零等于

 10| 的mod-10

 +/ 总数是

 ⎕× 输入时间

 8⍴3 1 周期取自八个元素 [3,1]

？

05AB1E，9个字节

3X‚7∍*OTÖ

在线尝试！

3X‚7∍*OTÖ    # Argument a
3X‚          # Push [3, 1]
   7∍        # Extend to length 7
     *       # Multiply elements with elements at same index in a
      O      # Total sum
       TÖ    # Divisible by 10

J，17个字节

-10个字节，感谢科尔

0=10|1#.(8$3 1)*]

在线尝试！

这使用大小相等的列表的乘法来避免原始解决方案的zip / multiply组合，以及1#.将产品加在一起的“ base 1技巧” 。高级方法类似于原始解释。

原始的27字节

0=10|{:+[:+/[:*/(7$3 1),:}:

在线尝试！

解释

0 =                                        is 0 equal to... 
    10 |                                   the remainder when 10 divides...
         {: +                              the last input item plus...
              [: +/                        the sum of...
                    [: */                  the pairwise product of...
                          7$(3 1) ,:       3 1 3 1 3 1 3 zipped with...
                                     }:    all but the last item of the input

C（gcc），84 82 72 61 54字节

c;i;f(x){for(i=c=0;x;x/=10)c+=(1+2*i++%4)*x;c=c%10<1;}

来自Neil的 -21个字节

Nahuel Fouilleul的 -7个字节

在线尝试！

独立于Steadybox的答案而开发

'f'是将条形码作为int，然后返回1True和0False 的函数。

• f存储的最后一位数字x的s（s=x%10）

• 然后计算c（for(i=c=0;x;x/=10)c+=(1+2*i++%4)*x;）中的总和

  • c是总和，i是一个计数器

  • 对于每个数字（包括第一个1+2*i%4数字x%10），将数字（）乘以校验和并递增i（i++in 3-2*i++%4）

    • 1+2*i%4在i偶数时为1，在i奇数时为0

• 然后返回总和是否为10的倍数，并且由于我们添加了最后一位数字（乘以1），因此如果条形码有效，则总和将为10的倍数。（使用依赖于GCC的未定义行为来忽略return）。

C，63字节

i;s=0;c(int*v){for(i=0;i<8;i++){s+=v[i]*3+v[++i];}return s%10;}

假设0是，true并且其他任何值为false。

+3个字节以获得更好的返回值

i;s=0;c(int*v){for(i=0;i<8;i++){s+=v[i]*3+v[++i];}return s%10==0;}

添加==0到return语句。

不打高尔夫球

int check(int* values)
{
    int result = 0;
    for (int index = 0; index < 8; index++)
    {
        result += v[i] * 3 + v[++i]; // adds this digit times 3 plus the next digit times 1 to the result
    }
    return result % 10 == 0; // returns true if the result is a multiple of 10
}

这使用了EAN校验和的替代定义，在该定义中选择了校验位，以使包括校验位在内的整个条形码的校验和为10的倍数。从数学上讲，这是相同的，但编写起来要简单得多。

根据Steadybox的建议，在循环内初始化变量，共63个字节

i;s;c(int*v){for(i=s=0;i<8;i++){s+=v[i]*3+v[++i];}return s%10;}

根据Steadybox的建议删除大括号，61字节

i;s;c(int*v){for(i=s=0;i<8;i++)s+=v[i]*3+v[++i];return s%10;}

使用<1而不是==0更好的返回值由凯文Cruijssen的建议

i;s=0;c(int*v){for(i=0;i<8;i++){s+=v[i]*3+v[++i];}return s%10<1;}

添加<1到return语句中，这只会添加2个字节，而不是添加==0会添加3个字节。

JavaScript（Node.js），47字节

e=>eval(e.map((a,i)=>(3-i%2*2)*a).join`+`)%10<1

尽管答案还短得多，但这是我第一次尝试使用JavaScript打高尔夫球，因此我想听听打高尔夫球的建议:-)

测试中

let f=

e=>eval(e.map((a,i)=>(3-i%2*2)*a).join`+`)%10<1

console.log(f([2,0,3,7,8,2,4,0]));
console.log(f([3,3,7,6,5,1,2,9]));
console.log(f([7,7,2,3,4,5,7,5]));
console.log(f([0,0,0,0,0,0,0,0]));

console.log(f([2,1,0,3,4,9,8,4]));
console.log(f([6,9,1,6,5,4,3,0]));
console.log(f([1,1,9,6,5,4,2,1]));
console.log(f([1,2,3,4,5,6,7,8]));

或者，您可以在线尝试！

Perl 5 5，37 32 +1（-p）字节

s/./$-+=$&*(--$|*2+1)/ge;$_=/0$/

-5字节，感谢Dom Hastings。原为37 +1字节

$s+=$_*(++$i%2*2+1)for/./g;$_=!!$s%10

在线尝试

Brainfuck，228字节

>>>>++++[<++>-]<[[>],>>++++++[<++++++++>-]<--[<->-]+[<]>-]>[->]<<<<[[<+>->+<]<[>+>+<<-]>>[<+>-]<<<<<]>>>>[>>[<<[>>+<<-]]>>]<<<++++[<---->-]+++++[<++<+++>>-]<<[<[>>[<<->>-]]>[>>]++[<+++++>-]<<-]<[[+]-<]<++++++[>++[>++++<-]<-]>>+.

大概可以改善一点。输入一次取1位数，输出1为真，0为假。

怎么运行的：

>>>>++++[<++>-]<

将8放在位置3。

[[>],>>++++++[<++++++++>-]<--[<->-]+[<]>-]

输入8次，每次将其从ascii值更改为实际值+2。输入之间用一个空格隔开，这些编号将被删除，以便以后更容易乘法。

>[->]

从每个项目中减去一个。我们的磁带现在看起来像

0 0 0 0 4 0 4 0 8 0 7 0 6 0 2 0 3 0 10 0 0
                                         ^

每个值大于应有的1。这是因为零会弄乱我们的乘法过程。

现在我们准备开始乘法。

<<<<

转到倒数第二个项目。

[[<+>->+<]<[>+>+<<-]>>[<+>-]<<<<<]

当为零时，将其处的项目乘以3，然后向左移动两个项目。现在，我们将所需的所有内容乘以三，并且我们在磁带上的第一个位置。

>>>>[>>[<<[>>+<<-]]>>]

对整个列表求和。

<<<++++[<---->-]

我们的值比实际值大16。减去16即可解决此问题。

+++++[<++<+++>>-]

我们需要测试总和是否为10的倍数。最大总和为所有9s，即144。由于没有总和大于10 * 15，因此按15和10的顺序将其放在磁带上总和的权利。

<<[<[>>[<<->>-]]>[>>]++[<+++++>-]<<-]

移至15。当它不为零时，请检查总和是否为非零。如果是，则减去10。现在，我们要么处于（空）和位置，要么处于（也空）十个位置。向右移动。如果我们处于总和位置，那么我们现在处于非零15位置。如果是这样，请向右移动两次。现在我们在两种情况下都处于同一位置。将十个位置加十，然后从十五个位置减一。

其余的用于输出：

<[[+]-<]<++++++[>++[>++++<-]<-]>>+.

移至求和位置。如果非零（负），则条形码无效；否则，条形码无效。将位置设置为-1。现在添加49以获取正确的ascii值：如果有效，则为1；如果无效，则为0。

Java 8，53字节

打高尔夫球：

b->(3*(b[0]+b[2]+b[4]+b[6])+b[1]+b[3]+b[5]+b[7])%10<1

在lambda中直接计算似乎是最短的解决方案。它适合单个表达式，最大程度地减少了lambda开销，并删除了无关的变量声明和分号。

public class IsMyBarcodeValid {

  public static void main(String[] args) {
    int[][] barcodes = new int[][] { //
        { 2, 0, 3, 7, 8, 2, 4, 0 }, //
        { 3, 3, 7, 6, 5, 1, 2, 9 }, //
        { 7, 7, 2, 3, 4, 5, 7, 5 }, //
        { 0, 0, 0, 0, 0, 0, 0, 0 }, //
        { 2, 1, 0, 3, 4, 9, 8, 4 }, //
        { 6, 9, 1, 6, 5, 4, 3, 0 }, //
        { 1, 1, 9, 6, 5, 4, 2, 1 }, //
        { 1, 2, 3, 4, 5, 6, 7, 8 } };
    for (int[] barcode : barcodes) {
      boolean result = f(b -> (3 * (b[0] + b[2] + b[4] + b[6]) + b[1] + b[3] + b[5] + b[7]) % 10 < 1, barcode);
      System.out.println(java.util.Arrays.toString(barcode) + " = " + result);
    }
  }

  private static boolean f(java.util.function.Function<int[], Boolean> f, int[] n) {
    return f.apply(n);
  }
}

输出：

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

QBasic，54 52字节

gh，无聊的回答竟然是最短的：

INPUT a,b,c,d,e,f,g,h
?(3*a+b+3*c+d+3*e+f+3*g+h)MOD 10=0

这将输入逗号分隔的数字。我最初的54字节解决方案（一次输入一位数字）使用一种“更精细”的方法：

m=3
FOR i=1TO 8
INPUT d
s=s+d*m
m=4-m
NEXT
?s MOD 10=0

C＃（.NET Core），65 62字节

b=>{int s=0,i=0,t=1;while(i<8)s+=b[i++]*(t^=2);return s%10<1;}

在线尝试！

致谢

由于@KevinCruijssen和使用“异或”运算符的巧妙技巧，-3个字节。

去高尔夫

b=>{
    int s=0,i=0,t=1;

    while(i<8)
        s+=b[i++]*(t^=2); // exclusive-or operator alternates t between 3 and 1.

    return s%10<1;
}

C＃（.NET Core），53字节

b=>(3*(b[0]+b[2]+b[4]+b[6])+b[1]+b[3]+b[5]+b[7])%10<1

在线尝试！

@Snowman的答案的直接端口。

MATLAB / 八度，32字节

@(x)~mod(sum([2*x(1:2:7),x]),10)

在线尝试！

尽管我开发了其他Octave答案，但我将在发布此代码和方法时发布它，而无需查看其他答案。

这里我们有一个匿名函数，它将输入作为8个值的数组，如果有效的条形码返回true，否则返回false。

计算结果如下。

              2*x(1:2:7)
             [          ,x]
         sum(              )
     mod(                   ,10)
@(x)~

1. 奇数（一个索引）乘以2。
2. 结果被放在输入数组的前面，给出一个数组，其总和将包含三次奇数位，一次包含偶数位。
3. 我们进行总和，该总和还将包括提供的校验和。
4. 接下来执行模10。如果提供的校验和有效，那么包括校验和值在内的所有乘法数字的总和将为10的倍数。因此，只有有效的条形码会返回0。
5. 如果有效，则将结果取反以获得逻辑输出true。

Excel，37个字节

将“ 8个整数的列表”解释为允许在Excel中使用8个单独的单元格：

=MOD(SUM(A1:H1)+2*(A1+C1+E1+G1),10)=0

Ruby，41字节

接受一个整数数组。-6字节感谢乔丹。

->n{n.zip([3,1]*4){|x,y|$.+=x*y};$.%10<1}

TI-Basic（83系列），18字节

not(fPart(.1sum(2Ans-Ans9^cumSum(binomcdf(7,0

在中将输入作为列表Ans。返回1有效的条形码和0无效。

我的Mathematica答案的一部分。包括屏幕截图代替在线测试环境：

显着特征：binomcdf(7,0用于生成列表{1,1,1,1,1,1,1,1}（从7个成功概率为0的试验中得出的概率列表，对于N = 0,1，...，7，最多将有N个成功）。然后，cumSum(把它变成{1,2,3,4,5,6,7,8}。

这比使用该seq(命令要短一个字节，尽管从历史上看，它的使用速度也要快得多。