Bir EAN-8 barkodu, 7 basamaklı bilgi ve 8. kontrol toplamı içerir.

Sağlama toplamı, basamakları sırayla 3 ve 1 ile çarparak, sonuçları ekleyerek ve 10'un bir sonraki katından çıkartarak hesaplanır.

Örneğin, rakamları verilen 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

Bu elde edilen basamak toplamı 55 sağlama basamaklı yani, 55 = 5-60

Meydan okuma

Göreviniz, 8 basamaklı bir barkod verildiğinde, geçerli olup olmadığını doğrulamaktır - sağlama toplamı geçerliyse bir gerçeğe uygun değer döndürmek ve aksi takdirde sahte olur.

• Aşağıdaki formlardan birinde girdi alabilirsiniz:
  • Barkod hanelerini temsil eden, 8 karakter uzunluğunda bir dize
  • 8 tamsayının bir listesi, barkodun rakamları
  • Negatif olmayan bir tam sayı (hiç kimsenin verilmediği baştaki sıfırları varsayabilirsin, yani 1= 00000001veya verilen sıfırlarla giriş talep edebilirsiniz)
• EAN-8 sağlama toplamını hesaplayan (yani, ilk 7 basamağı ve sonunu hesaplayanlar) yasaklanmıştır.
• Bu kod golf , yani en kısa program (bayt cinsinden) kazanır!

Test Kılıfları

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

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

Jöle , 7 bayt

s2Sḅ3⁵ḍ

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

@ETHProductions sayesinde 2 byte, @Craig Ayre sayesinde 1 byte kaydedildi.

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

Girdiyi basamak listesi olarak alır.

Sağlama toplamı dahil tüm basamakların toplamını belirler.

Toplam 10'un katı ise, geçerli bir barkoddur.

Test Kılıfları

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 bayt

mypetlion 19 bayt kurtardı

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

Çevrimiçi deneyin!

Jöle , 8 bayt

m2Ḥ+µS⁵ḍ

Test odasını dene.

Jöle , 9 bayt

JḂḤ‘×µS⁵ḍ

Çevrimiçi deneyin veya test takımını deneyin.

Bu nasıl çalışır

m2Ḥ + µS⁵ḍ ~ Tam program.

m2 ~ Modüler 2. Girişin her ikinci elemanını döndür.
  Each ~ Her iki katı.
   + µ ~ Girişi ekleyin ve yeni bir monadik zincir başlatın.
     S ~ Sum.
      ~ 10 ile bölünebilir mi?

JḂḤ '× µS⁵ḍ ~ Tam program (monadik).

J ~ 1 indeksli uzunluk aralığı.
 Bit ~ Bit; Modulo her aralıktaki sayıyı 2'ye kadar.
  Each ~ Her iki katı.
   '~ Her artış.
    × ~ Giriş ile çift yönlü çarpma.
     µ ~ Yeni bir monadik zincir başlatır.
      S ~ Sum.
       Sum ~ Toplam 10 ile bölünebilir mi?

Barkodun ilk 7 basamağının ve sağlama toplamının sonucunun geçerli olması için 10 katına eklemesi gerekir . Bu nedenle sağlama toplamı, tüm listeye uygulanan algoritma 10 ile bölünebiliyorsa geçerlidir .

MATL , 10 bayt

@Zgarb'a bir hatayı işaret ettiği için teşekkürler , şimdi düzeltildi.

IlhY"s10\~

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

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 bayt

İkinci kısmı s jyerine kullanarak atlamanın ;yanı sıra , ikinci kısımda kurtulmak için a ~ve +birinci kısımları değiştirerek 2 bayt kurtarıldı +.

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

Giriş, 8 basamaklıdır (eğer varsa baştaki 0 ​​ile) ve başka bir şey yoktur.

Çıkış kodu ile çıkışlar (TIO'da hata ayıklama açılır penceresini açın), 1 doğru ve 0 yanlış.

Çevrimiçi deneyin!

açıklama

Bu program çeşitli hileler kullanır.

Her şeyden önce, ASCII değerleri üzerinden rakamları birer birer alır. Normalde bu, girdiden okuduğumuz gibi her değerden 48'in çıkarılmasını gerektirir. Bununla birlikte, değiştirmezsek, toplamda 16 (3 + 1 + 3 + 1 + 3 + 1 + 3 + 1) 48 adet fazladan kopya kalır ve bu da toplamımızın 768 daha büyük olacağı anlamına gelir. "olması gerektiği". Sadece toplam mod 10 ile ilgilendiğimiz için, sonradan toplamı 2 ekleyebiliriz. Böylece, ham ASCII değerlerini alabiliriz, böylece 6 bayt tasarruf sağlayabiliriz.

İkincisi, bu kod yalnızca diğer karakterlerin bir EOF olup olmadığını denetler, çünkü girişin yalnızca 8 karakter uzunluğunda olması garanti edilir.

Üçüncüsü, #satırın sonundaki ilk karakteri atlamaz, ancak ;diğer yönden gelenleri atlar . Bunun #;yerine cepheye koymaktan daha iyidir .

Programımızın ikinci kısmı yalnızca bir kez çalıştırıldığından, geriye doğru çalışırken ilk yarıyı atlayacak şekilde ayarlamak zorunda değiliz. Bu, geri gitmeden çalıştırmadan önce çıkarken, ikinci yarının üstünden atlamak için jump komutunu kullanmamızı sağlar.

Adım adım

Not: "Tek" ve "Çift" karakterleri 0 dizinli bir sistemi temel alır. İlk karakter, dizin 0 ile eşit bir karakterdir.

~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 bayt

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

Çevrimiçi deneyin!

C (gcc), 72 bayt

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

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 26 21 bayt

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

Çevrimiçi deneyin!

Girişi 8 basamaklı bir liste halinde alır.

Nasıl çalışır

2-9^Range@8eşittir modulo 10 2-(-1)^Range@8, ki bu {3,1,3,1,3,1,3,1}. Bu listenin nokta ürününü girdi ile alıyoruz ve sonucun 10'a bölünebilir olup olmadığını kontrol ediyoruz.

Wolfram Dili (Mathematica) , 33 bayt ve rekabet etmeyen

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

Çevrimiçi deneyin!

Bir dize olarak girdi alır. 1Geçerli barkodlar ve 0geçersiz olanlar için döndürür .

Nasıl çalışır

Yerleşik olarak bulabileceğim en iyi şey (çünkü Mathematica tamamen bunlarla ilgilidir).

İçinde biraz #~BarcodeImage~"EAN8";1, daha sonra tamamen göz ardı eder ve barkod geçersiz ise değerlendirir Ancak 1'e, daha sonra, EAN8 barkod bir görüntü üretir BarcodeImage, bir uyarı oluşturur Checkbu durumda 0 dönen, yakalar.

Java 8, 58 56 55 bayt

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

@RickHitchcock sayesinde dolaylı olarak -2 bayt , JavaScript cevabını gördükten sonra kullanmak (m=4-m)*iyerine . -1 byte dolaylı olarak @ETHProductions (ve @RickHitchcock ) kullanarak yerine .m++%2*2*i+i
(m^=2)*i(m=4-m)*i

Açıklama:

Burada dene.

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 bayt

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

Çevrimiçi deneyin!

İhtiyacı olan 0s, basamakların listesini alır.

Pyth , 8 bayt

!es+*2%2

Tüm test durumlarını doğrulayın!

Pyth , 13 bayt

Girişin her zaman tam olarak 8 rakamı olduğunu varsayabiliriz:

!es.e*bhy%hk2

Tüm test durumlarını doğrulayın!

Bu nasıl çalışıyor?

! es + * 2% 2 ~ Tam program.

      % 2 ~ Giriş [:: 2]. Girişin her ikinci elemanı.
    * 2 ~ Double (listeyi iki kez tekrarla).
   + ~ Girişi ekleyin.
  s ~ Sum.
 e ~ Son basamak.
! Mantıksal DEĞİL.

! es.e * sbhy% hk2 ~ Tam program.

               ~ Girişi bir dizeye dönüştürün.
   .e ~ Geçerli harita değerini b olarak ve dizini k olarak kaydederek numaralandırılmış harita.
          % hk2 ~ Dizinin ters paritesi. (k + 1)% 2.
        hy ~ Çift, artış. Bu, tek tam sayılarını 1'e, hatta 3'e eşleştirir.
      b ~ Geçerli hane.
     * ~ Çarpın.
  s ~ Sum.
 e ~ Son basamak.
! Mantıksal olumsuzlama.

Eğer uygulandıktan sonra ilk 7 hanenin toplamı algoritma 10'dan çıkarılır ve sonra son haneye kıyasla, bu, algoritma uygulandıktan sonra tüm basamakların toplamının 10 katı olup olmadığını kontrol etmeye eşdeğerdir .

Haskell , 40 38 bayt

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

Çevrimiçi deneyin!

8 tamsayının listesi olarak girdi alır. Sonsuz listeler kullanmanın pratik bir örneği.

Düzenleme: GolfWolf sayesinde 2 bayt kaydedildi

Retina , 23 22 bayt

Martin Ender'e -1 bayt !

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

Çevrimiçi deneyin!

açıklama

Örnek giriş: 20378240

(.).
$1$1$&

Her hane çiftini, iki kez tekrar eden ilk hane ve ardından çiftin yerine koyun. Alırız2220333788824440

.
$*

Her basamağı birliğe dönüştür. Netlik için parantez eklendiğinde,(11)(11)(11)()(111)(111)...

M`

Boş dizginin eşleşme sayısını, dizgideki sayıdan daha fazla olan sayın. (Son iki adımda temelde her bir basamağın toplamını attık +1) Sonuç:60

1$

1Dizenin sonunda bir a eşleştirin. Rakamları sırayla 3 ve 1 ile çarptık ve topladık, geçerli bir barkod için bu 10'a bölünmelidir (son basamak 0); ancak son adımda 1 tane daha ekledik, bu yüzden son basamağın 1 olmasını istiyoruz 1.

PowerShell , 85 bayt

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

Çevrimiçi deneyin! veya Tüm test durumlarını doğrula

Algoritmayı tanımlandığı şekilde uygular. Girdiyi alır $a, her bir rakamı dışarı çeker "$a"[0..6]ve içlerinden geçirir |%{...}. Her yineleme, basamağı alırız, bir dizge olarak atarız, "$_"sonra +ya 3da ile çarpmadan önce bir int a atarız 1(( $imodulo artırılarak seçilir 2).

Bu sonuçların hepsi bir araya toplanır ve toplanır -join'+'|iex. Bu sonuç modunu alıyoruz 10, bunu 10çıkarıyoruz ve tekrar sonuç modunu alıyoruz 10(bu ikinci mod, 00000000test durumunu hesaba katmak için gereklidir ). Daha sonra -eqbunun son haneye kadar olup olmadığını kontrol ettik . Bu Boolean sonucu boru hattında bırakılır ve çıktı kesindir.

Jöle , 16 bayt

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

Çevrimiçi deneyin!

basamak listesi olarak girdi alır

APL (Dyalog) , 14 bayt

Streetster'ın çözümü ile eşdeğerdir .

Tam program gövdesi. STDIN’deki numaraların listesini ister.

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

Çevrimiçi deneyin!

Is ...

 0= sıfıra eşit

 10| mod-10 arasında

 +/ toplamı

 ⎕× giriş zamanları

 8⍴3 1 periyodik olarak alınan sekiz element [3,1]

?

05AB1E , 9 bayt

3X‚7∍*OTÖ

Çevrimiçi deneyin!

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 bayt

Cole sayesinde -10 bayt

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

Çevrimiçi deneyin!

Bu, orijinal çözeltinin sıkıştırılmasını / çoğaltılmasını önlemek için eşit boyutlu listelerin çarpımını 1#.ve ürünleri bir araya getirmek için "temel 1 numarası" nı kullanır. Yüksek seviyeli yaklaşım orijinal açıklamaya benzer.

orijinal, 27 bayt

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

Çevrimiçi deneyin!

açıkladı

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 bayt

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

Dan -21 bayt Neil

-7 Nahuel Fouilleul'dan gelen bayt sayısı

Çevrimiçi deneyin!

Bağımsız olarak geliştirilen Steadybox'ın cevabından

'f' barkodu bir olarak alan intve 1Doğru ve 0Yanlış için geri dönen bir fonksiyondur .

• fxin s( s=x%10) in son basamağını saklar ,

• Sonra c( for(i=c=0;x;x/=10)c+=(1+2*i++%4)*x;) içindeki toplamı hesaplar

  • ctoplamı, ibir sayaç

  • ilki dahil her hane için, sağlama toplamına 1+2*i%4( x%10) basamağını ( ) rakamını ekleyin i( i++giriş 3-2*i++%4)

    • 1+2*i%41 'dir i, hatta 0 olduğunda itek sayı

• Sonra toplamın on katı olup olmadığını döndürür ve son basamağı eklediğimizden (1 ile çarpılır), barkod geçerli olduğunda toplamın on katı olacaktır. (atlamak için GCC'ye bağlı tanımsız davranış kullanır return).

C, 63 bayt

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

Varsayar 0olan trueve başka herhangi bir değerdirfalse .

Daha iyi dönüş değeri için +3 bayt

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

ekle ==0içinreturn açıklamada.

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
}

Bu, kontrol hanesinin seçili olduğu EAN sağlama toplamlarının alternatif tanımını kullanır; öyle ki, kontrol hanesini de içeren tüm barkodun sağlama toplamı 10 katıdır. Matematiksel olarak bu aynı şekilde çalışır ancak yazması çok daha kolaydır.

Değişkenlerin Steadybox tarafından önerildiği şekilde döngü içinde başlatılması, 63 bayt

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

Kıvırcık parantezlerin Steadybox tarafından önerildiği şekilde kaldırılması, 61 bayt

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

Kevin Cruijssen tarafından önerildiği gibi daha iyi getiri değeri <1yerine kullanmak==0

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

Ekle <1için returnaçıklamada, bu eklenmesi yerine, sadece 2 bayt ekler ==03 bayt ekler hangi.

JavaScript (Node.js) , 47 bayt

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

Zaten çok daha kısa bir cevap olsa da, bu benim ilk JavaScript girişimim ve bu yüzden golf önerilerini dinlemek istiyorum :-)

Test yapmak

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

Alternatif olarak, çevrimiçi deneyebilirsiniz!

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

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

Dom Hastings sayesinde -5 bayt. 37 +1 bayt

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

çevrimiçi dene

Brainfuck, 228 Bayt

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

Muhtemelen adil bir bit geliştirilebilir. Giriş bir defada 1 hane alınır, doğru çıktı için 1, yanlış yanlış için 0 olur.

Nasıl çalışır:

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

8 konumuna 3 konumuna getirin.

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

Her defasında ascii değerden gerçek +2 değerine değiştirerek girişi 8 kez alır. Girdiler, daha sonra kolayca çarpılmasını sağlamak için kaldırılacak olanlarla ayrılmıştır.

>[->]

Her maddeden bir tane çıkarın. Kasetimiz şimdi bir şeye benziyor

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

Her değerde 1 olması gerekenden daha fazla. Bunun sebebi, sıfırların çarpma sürecimizi bozmasıdır.

Şimdi çarpmaya başlamak için hazırız.

<<<<

En son ikinci öğeye git.

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

Sıfır iken, öğeyi üç ile çarpın, ardından iki öğeyi sola kaydırın. Şimdi ihtiyacımız olan her şeyi üçe katladık ve kasetteki ilk pozisyondayız.

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

Tüm listeyi toplayın.

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

Elimizdeki değer 16 gerçek değerden daha fazla. 16'yı çıkararak bunu düzelt.

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

Toplamın 10 katı olup olmadığını test etmemiz gerekir. Maksimum toplam, 9'luk 9'dur, 144'dür. Toplam 10 * 15'ten büyük olamayacağından, kasette 15 ve 10'u bu sıraya ve sağa koymak toplamın hakkı.

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

15 olduğu yere git. Sıfır olmasa da, toplamın sıfır olmadığını test edin. Eğer öyleyse, ondan 10 çıkarın. Şimdi ya (boş) toplam konumunda ya da (aynı zamanda boş) on konumundayız. Bir tane sağa hareket ettirin. Toplam pozisyonundaysak, şimdi sıfır olmayan 15 pozisyonundayız. Eğer öyleyse, iki kez sağa hareket ettirin. Şimdi her iki durumda da aynı pozisyondayız. On konumuna on ekleyin ve birini 15 konumundan çıkarın.

Gerisi çıktı içindir:

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

Toplam konumuna getirin. Sıfır değilse (negatif), barkod geçersiz; konumunu -1 olarak ayarlayın. Şimdi doğru ascii değerini almak için 49 ekleyin: eğer geçerliyse 1, eğer geçersizse 0.

Java 8, 53 bayt

golfed:

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

Lambda'da doğrudan hesaplama en kısa çözüme ulaşır. Tek bir ifadeye uyar, lambda ek yükünü en aza indirir ve değişken değişken bildirimlerini ve noktalı virgülleri kaldırır.

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

Çıktı:

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

Ah, sıkıcı cevabın en kısa olduğu ortaya çıktı:

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

Bu, virgülle ayrılmış basamakları girer. Her seferinde bir rakam girilen orijinal 54 baytlık çözümüm "daha güzel" bir yaklaşım kullanıyor:

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 bayt

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

Çevrimiçi deneyin!

Teşekkür

@KevinCruijssen ve exclusive-ya da işlecini kullanan zarif numara sayesinde -3 bayt.

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 bayt

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

Çevrimiçi deneyin!

@ Snowman'ın cevabının direkt limanı .

MATLAB / Octave , 32 bayt

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

Çevrimiçi deneyin!

Bu kodu ve yaklaşımı diğer cevaplara bakmadan geliştirdiğim için diğer Octave cevabına rağmen bunu göndereceğim.

Burada girişi 8 değerlik bir dizi olarak alan ve geçerli bir barkod varsa true döndüren adsız bir işleve sahibiz.

Sonuç aşağıdaki gibi hesaplanır.

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

1. Tek rakam (bir indeksli) 2 ile çarpılır.
2. Sonuç, toplamı üç kez tek sayıları ve çift rakamları bir kez içerecek bir dizi vererek giriş dizisine hazırlanır.
3. Verilen sağlama toplamını da içerecek toplamı, toplamımız içinde yaparız.
4. Ardından modulo 10 gerçekleştirilir. Sağlanan sağlama toplamı geçerliyse, sağlama toplamı değeri de dahil olmak üzere tüm çarpılmış basamakların toplamı 10'un katı olur. Bu nedenle yalnızca geçerli bir barkod 0 döndürür.
5. Sonuç geçerliyse, doğru bir mantıksal çıktı elde etmek için ters çevrilir.

Excel, 37 bayt

Excel'de 8 ayrı hücreye izin verdiğine "8 tamsayının listesi" yorumlanması:

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

Ruby, 41 Bayt

Bir dizi tamsayı alır. Jordan sayesinde -6 bayt.

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

TI-Basic (83 serisi), 18 bayt

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

Girişi liste halinde alır Ans. 1Geçerli barkodlar ve 0geçersiz olanlar için döndürür .

Mathematica cevabımın bir limanı . Çevrimiçi bir test ortamı yerine ekran görüntüsünü içerir:

Dikkate değer özellik: binomcdf(7,0listeyi oluşturmak için kullanılır {1,1,1,1,1,1,1,1}(başarı olasılığı 0 olan 7 denemeden, N = 0,1, ..., 7 için en fazla N başarısı olacak olasılıkların listesi). Sonra cumSum(bunu şuna dönüştürür {1,2,3,4,5,6,7,8}.

Bu seq(komutun kullanılmasından daha kısa bir bayt olmasına rağmen, tarihsel olarak önemli olan daha hızlı olmasıydı.