EAN-8 штрих - коду включає в себе 7 цифр інформації та 8 - ї контрольної цифрою.

Контрольна сума обчислюється шляхом множення цифр на 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-значний штрих-код, переконатися, чи він дійсний - повернути триєдне значення, якщо контрольна сума дійсна, і помилково вказати інше.

• Ви можете взяти інформацію в будь-якій з наступних форм:
  • Рядок, довжиною 8 символів, що представляє цифри штрих-коду
  • Список 8 цілих чисел, цифри штрих-коду
  • Невід’ємне ціле число (ви можете припустити провідні нулі там, де їх не вказано, тобто 1= 00000001, або запитати введення з заданими нулями)
• Вбудовані, які обчислюють контрольну суму EAN-8 (тобто беруть перші 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 байт

Збережено 2 байти завдяки @ETHProductions та 1 байт завдяки @Craig Ayre.

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⁵ḍ ~ Повна програма.

м2 ~ Модульна 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 байт

Збережено 2 байти, пропустивши другу частину за допомогою jзамість ;s, а також замінивши a ~і+ в першій частині, щоб позбутися а +в другій.

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

Введіть 8 цифр (з провідними 0, якщо це можливо) і нічого іншого.

Виводиться за допомогою коду виходу (відкрийте випадок налагодження на TIO), де 1 відповідає дійсності, а 0 - помилково.

Спробуйте в Інтернеті!

Пояснення

Ця програма використовує різноманітні трюки.

Перш за все, вона бере цифри по черзі через їх значення ASCII. Зазвичай для цього потрібно буде відняти 48 з кожного значення, коли ми читаємо його з вхідних даних. Однак, якщо ми не змінимо його, у нас залишиться 16 (3 + 1 + 3 + 1 + 3 + 1 + 3 + 1) додаткових копій, що становить 48 в нашій сумі, тобто загальна сума буде на 768 більше, ніж що це "повинно бути". Оскільки нас стосується лише сума mod 10, ми можемо просто додати 2 до суми пізніше. Таким чином, ми можемо взяти необроблені значення ASCII, заощадивши 6 байт або близько того.

По-друге, цей код перевіряє, чи будь-який інший символ є EOF, оскільки вхід гарантовано має бути лише 8 символів.

По-третє, #кінець рядка не пропускає перший символ, а пропускає, ;якщо йде з іншого напрямку. Це краще, ніж #;замість цього поставити фронт.

Оскільки друга частина нашої програми запускається лише один раз, нам не потрібно налаштовувати її так, щоб вона пропускала першу половину при запуску назад. Це дозволяє нам скористатися командою стрибок для переходу через другу половину, коли ми виходимо, перш ніж виконувати її, рухаючись назад.

Крок за кроком

Примітка: символи "Непарний" та "Непарний" базуються на системі, що індексується 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;}

Спробуйте в Інтернеті!

Мова Вольфрама (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.

Мова Вольфрама (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;}

-2 байти опосередковано завдяки @RickHitchcock , використовуючи (m=4-m)*iзамість m++%2*2*i+iтого, щоб побачити це у своїй відповіді на JavaScript .
-1 байт опосередковано завдяки @ETHProductions (і @ RickHitchcock ), використовуючи (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

Перевірте всі тестові випадки!

Піт , 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 цілих чисел. Практичний приклад використання нескінченних списків.

Редагувати: Збережено 2 байти завдяки GolfWolf

Сітківка , 23 22 байт

-1 байт завдяки Мартіну Ендеру !

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

Спробуйте в Інтернеті!

Пояснення

Приклад введення: 20378240

(.).
$1$1$&

Замініть кожну пару цифр першою цифрою, повтореною двічі, а потім самою парою. Ми отримуємо2220333788824440

.
$*

Перетворіть кожну цифру в одинакову. З доданими дужками для ясності ми отримуємо(11)(11)(11)()(111)(111)...

M`

Порахуйте кількість збігів порожнього рядка, що на одну більшу кількість, ніж кількість рядків. (За останні два кроки ми в основному взяли суму кожної цифри +1) Результат:60

1$

Match a 1 at the end of the string. We have multiplied digits by 3 and 1 alternately and summed them, for a valid barcode this should be divisible by 10 (last digit 0); but we also added 1 in the last step, so we want the last digit to be 1. Final result: 1.

PowerShell, 85 bytes

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

Try it online! or Verify all test cases

Implements the algorithm as defined. Takes input $a, pulls out each digit with "$a"[0..6] and loops through them with |%{...}. Each iteration, we take the digit, cast it as a string "$_" then cast it as an int + before multiplying it by either 3 or 1 (chosen by incrementing $i modulo 2).

Those results are all gathered together and summed -join'+'|iex. We take that result mod 10, subtract that from 10, and again take the result mod 10 (this second mod is necessary to account for the 00000000 test case). We then check whether that's -equal to the last digit. That Boolean result is left on the pipeline and output is implicit.

Jelly, 16 bytes

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

Try it online!

takes input as a list of digits

APL (Dyalog), 14 bytes

Equivalent with streetster's solution.

Full program body. Prompts for list of numbers from STDIN.

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

Try it online!

Is…

 0= zero equal to

 10| the mod-10 of

 +/ the sum of

 ⎕× the input times

 8⍴3 1 eight elements cyclically taken from [3,1]

?

05AB1E, 9 bytes

3X‚7∍*OTÖ

Try it online!

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 bytes

-10 bytes thanks to cole

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

Try it online!

This uses multiplication of equal sized lists to avoid the zip/multiply combo of the original solution, as well as the "base 1 trick" 1#. to add the products together. The high level approach is similar to the original explanation.

original, 27 bytes

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

Try it online!

explained

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 bytes

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

-21 bytes from Neil

-7 bytes from Nahuel Fouilleul

Try it online!

Developed independently of Steadybox's answer

'f' is a function that takes the barcode as an int, and returns 1 for True and 0 for False.

• f stores the last digit of x in s (s=x%10),

• Then calculates the sum in c (for(i=c=0;x;x/=10)c+=(1+2*i++%4)*x;)

  • c is the sum, i is a counter

  • for each digit including the first, add 1+2*i%4 times the digit (x%10) to the checksum and increment i (the i++ in 3-2*i++%4)

    • 1+2*i%4 is 1 when i is even and 0 when i is odd

• Then returns whether the sum is a multiple of ten, and since we added the last digit (multiplied by 1), the sum will be a multiple of ten iff the barcode is valid. (uses GCC-dependent undefined behavior to omit return).

C, 63 bytes

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

Assumes that 0 is true and any other value is false.

+3 bytes for better return value

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

Add ==0 to the return statement.

Ungolfed

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
}

This uses the alternative definition of EAN checksums where the check digit is chosen such that the checksum of the entire barcode including the check digit is a multiple of 10. Mathematically this works out the same but it's a lot simpler to write.

Initialising variables inside loop as suggested by Steadybox, 63 bytes

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

Removing curly brackets as suggested by Steadybox, 61 bytes

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

Using <1 rather than ==0 for better return value as suggested by Kevin Cruijssen

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

Add <1 to the return statement, this adds only 2 bytes rather than adding ==0 which adds 3 bytes.

JavaScript (Node.js), 47 bytes

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

Although there is a much shorter answer already, this is my first attempt of golfing in JavaScript so I'd like to hear golfing recommendations :-)

Testing

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]));

Alternatively, you can Try it online!

Perl 5, 37 32 + 1 (-p) bytes

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

-5 bytes thanks to Dom Hastings. 37 +1 bytes was

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

try it online

Brainfuck, 228 Bytes

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

Can probably be improved a fair bit. Input is taken 1 digit at a time, outputs 1 for true, 0 for false.

How it works:

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

Put 8 at position 3.

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

Takes input 8 times, changing it from the ascii value to the actual value +2 each time. Inputs are spaced out by ones, which will be removed, to allow for easier multiplication later.

>[->]

Subtract one from each item. Our tape now looks something like

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

With each value 1 more than it should be. This is because zeros will mess up our multiplication process.

Now we're ready to start multiplying.

<<<<

Go to the second to last item.

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

While zero, multiply the item it's at by three, then move two items to the left. Now we've multiplied everything we needed to by three, and we're at the very first position on the tape.

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

Sum the entire list.

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

The value we have is 16 more than the actual value. Fix this by subtracting 16.

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

We need to test whether the sum is a multiple of 10. The maximum sum is with all 9s, which is 144. Since no sum will be greater than 10*15, put 15 and 10 on the tape, in that order and right to the right of the sum.

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

Move to where 15 is. While it's non-zero, test if the sum is non-zero. If it is, subtract 10 from it. Now we're either on the (empty) sum position, or on the (also empty) ten position. Move one right. If we were on the sum position, we're now on the non-zero 15 position. If so, move right twice. Now we're in the same position in both cases. Add ten to the ten position, and subtract one from the 15 position.

The rest is for output:

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

Move to the sum position. If it is non-zero (negative), the barcode is invalid; set the position to -1. Now add 49 to get the correct ascii value: 1 if it's valid, 0 if it's invalid.

Java 8, 53 bytes

Golfed:

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

Direct calculation in the lambda appears to the shortest solution. It fits in a single expression, minimizing the lambda overhead and removing extraneous variable declarations and semicolons.

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);
  }
}

Output:

[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 bytes

Ugh, the boring answer turned out to be the shortest:

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

This inputs the digits comma-separated. My original 54-byte solution, which inputs one digit at a time, uses a "nicer" approach:

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 bytes

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

Try it online!

Acknowledgements

-3 bytes thanks to @KevinCruijssen and the neat trick using the exclusive-or operator.

DeGolfed

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 bytes

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

Try it online!

A direct port of @Snowman's answer.

MATLAB/Octave, 32 bytes

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

Try it online!

I'm going to post this despite the other Octave answer as I developed this code and approach without looking at the other answers.

Here we have an anonymous function which takes the input as an array of 8 values, and return true if a valid barcode, false otherwise..

The result is calculated as follows.

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

1. Odd digits (one indexed) are multiplied by 2.
2. The result is prepended to the input array, giving an array whose sum will contain the odd digits three times, and the even digits once.
3. We do the sum which will also include the supplied checksum within our sum.
4. Next the modulo 10 is performed. If the checksum supplied was valid, the sum of all multiplied digits including the checksum value would end up being a multiple of 10. Therefore only a valid barcode would return 0.
5. The result is inverted to get a logical output of true if valid.

Excel, 37 bytes

Interpreting "A list of 8 integers" as allowing 8 separate cells in Excel:

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

Ruby, 41 Bytes

Takes an array of integers. -6 bytes thanks to Jordan.

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

TI-Basic (83 series), 18 bytes

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

Takes input as a list in Ans. Returns 1 for valid barcodes and 0 for invalid ones.

A port of my Mathematica answer. Includes screenshot, in lieu of an online testing environment:

Notable feature: binomcdf(7,0 is used to generate the list {1,1,1,1,1,1,1,1} (the list of probabilities that from 7 trials with success probability 0, there will be at most N successes, for N=0,1,...,7). Then, cumSum( turns this into {1,2,3,4,5,6,7,8}.

This is one byte shorter than using the seq( command, though historically the point was that it's also significantly faster.