Kriptografide, PKCS # 7 dolgusu , eklenen her bir baytın değerinin N'ye eşit olduğu sayıda byte N ≥ 1 ekleyen bir dolgu şemasıdır.

Örneğin Hello, World!, 13 bayt olan, hex cinsinden şöyledir:

48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21

PKCS # 7 yastığının uzunluğu 16'yı seçersek, sonuç şöyledir:

48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21 03 03 03

Ve eğer uzunluğu 20'ye kadar kaydırmayı seçersek, sonuç şöyledir:

48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21 07 07 07 07 07 07 07

İlk örnekte üç 03bayt eklediğimizi , ikincisinde yedi 07bayt eklediğimizi unutmayın .

Göreviniz bir dizginin (veya tamsayı dizisinin) PKCS # 7 dolgusuna sahip olup olmadığını doğrulamak olacaktır . Diğer bir deyişle, giriş dizesinin son baytı N ise, programınız dizenin son N baytının N'ye eşit olduğunu kontrol etmelidir.

Giriş

1 ile 127 arasındaki kod noktaları arasında karakter içeren tek bir boş ASCII dizgisi. İsterseniz girdi yerine bir tamsayı dizisi olarak girebilirsiniz.

Çıktı

Bir truthy değeri girdi dizesi geçerli PKCS # 7 doldurma, aksi bir falsy değeri varsa.

Hem fonksiyonlar hem de tam programlar kabul edilebilir. Bu kod-golf , bu nedenle amaç kodunuzdaki bayt sayısını en aza indirmektir.

Test durumları

Girdilerin tamsayı dizi sürümü burada sunulmuştur; dize sürümünde aşağıdaki test durumlarının çoğu için yazdırılamayan karakterler bulunur:

Truthy:

[1]
[1, 1]
[2, 1]
[2, 2]
[5, 6, 5, 3, 3, 3]
[1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2]
[95, 115, 80, 32, 71, 7, 122, 49, 13, 7, 7, 7, 7, 7, 7, 7, 7]
[27, 33, 54, 65, 97, 33, 52, 55, 60, 1, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]
[15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15]

Falsy:

[2]
[1, 2]
[5, 5, 5, 5]
[5, 6, 5, 4, 4, 4]
[3, 3, 3, 94, 3, 3]
[1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 127]
[50, 39, 94, 105, 49, 29, 74, 102, 2, 106, 44, 7, 7, 7, 7, 7, 7]
[26, 27, 59, 25, 122, 110, 20, 30, 114, 6, 9, 62, 121, 42, 22, 60, 33, 12]

Python, 47 34 33 bayt

lambda s:s[-1:]*s[-1]==s[-s[-1]:]

s[-1]listenin son üyesidir s. s[-1]Giriş dizisinin son üyelerinin, birçok kez tekrarlanan sbir diziyle aynı olup olmadığını denetler s[-1].

Bir tamsayı dizisi olarak girdiyi alır. Bu bir lambda ifadesidir; kullanmak, önek olarak atamak lambdaile f=.

Ideone'da dene!

Test etmek için:

>>> f=lambda s:s[-1:]*s[-1]==s[-s[-1]:]
>>> f([27, 33, 54, 65, 97, 33, 52, 55, 60, 1, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10])
True
>>> f([50, 39, 94, 105, 49, 29, 74, 102, 2, 106, 44, 7, 7, 7, 7, 7, 7])
False

Leaky Nun sayesinde 13 byte kurtarıldı!

Dennis sayesinde bir bayt kaydedildi!

Brachylog , 14 bayt

~c[A:B]t#=h~lB

Çevrimiçi deneyin!

~c[A:B]t#=h~lB
~c[A:B]                input is concatenation of A and B
       t               B
        #=             has all equal elements
          h~lB         the first item of B is the length of B

Pyth, 5 bayt

gFer8

Girişte RLE, son çifti alın ve tekrar sayısının değerden büyük veya eşit olup olmadığını kontrol edin.

Çevrimiçi deneyin: Gösteri veya Test Paketi

Jöle , 5 bayt

ŒgṪṫṪ

Giriş bir kod noktası dizisidir, çıktı boş olmayan bir dizidir (truthy) veya boş bir dizidir (sahte).

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

Nasıl çalışır

ŒgṪṫṪ  Main link. Argument: A (array)

Œg     Group all runs of consecutive, equal integers.
  Ṫ    Tail; yield the last run. It should consist of n or more occurrences of n.
    Ṫ  Tail; yield n, the last element of A.
   ṫ   Dyadic tail; discard everything after the n-th element of the last run.
       If the last run was long enough, this will yield a non-empty array (truthy);
       if not, the result will be an empty array (falsy).

CJam, 9 8 bayt

1 byte tasarruf için Sp3000 teşekkürler.

{e`W=:/}

Bir tamsayı listesini giriş olarak alır ve döner 0(yanlış) veya pozitif bir tamsayı (truthy).

Test odası.

açıklama

e`   e# Run-length encoding, yielding pairs of run-length R and value V.
W=   e# Get the last pair.
:/   e# Compute R/V, which is positive iff R ≥ V. Works, because V is guaranteed
     e# to be non-zero.

05AB1E , 9 bayt

Osabie için çalışma boyu kodlaması yok :(

¤sR¬£¬QOQ

Açıklama:

¤           # Get the last element of the array
 s          # Swap the two top elements
  R         # Reverse the array
   ¬        # Get the first element
    £       # Substring [0:first element]
     ¬      # Get the first element
      Q     # Check if they are equal
       OQ   # Sum up and check if equal

Bir örnekle:

¤           # [5, 6, 5, 3, 3, 3]  3
 s          # 3  [5, 6, 5, 3, 3, 3]
  R         # 3  [3, 3, 3, 5, 6, 5]
   ¬        # 3  [3, 3, 3, 5, 6, 5]  3
    £       # 3  [3, 3, 3]
     ¬      # 3  [3, 3, 3]  3
      Q     # 3  [1, 1, 1]
       OQ   # 3==3 which results into 1

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

MATL , 10 bayt

Kodun daha eski bir sürümüyle ilgili bir sorun fark ettiği için @Adnan'a teşekkür ederiz

P0hG0):)&=

Girdi doğru yastığa sahipse , çıktı yalnızca truthy olanları içeren bir dizidir . Hatalı dolgusu olduğunda, çıktı en az sıfır içeren bir dizidir ve bu nedenle sahtedir .

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

açıklama

P     % Implicitly take numeric array as input. Reverse the array
0h    % Append a 0. This ensures falsy output if input array is too short
G0)   % Push input again. Get its last element
:     % Range from 1 to that
)     % Apply as index into the array
&=    % 2D array of all pairwise equality comparisons. Implicitly display

Mathematica, 29 bayt

#&@@#<=Length@#&@*Last@*Split

Girdiyi eşit elemanlardan oluşan parçalara bölün, sonuncuyu çıkarın ve ilk elemanının bu çalışmanın uzunluğuna eşit ya da ondan daha az olduğunu kontrol edin.

Haskell, 50 bayt

import Data.List
((>=)<$>head<*>length).last.group

Giriş olarak bir dizi tamsayı alır.

J, 13 bayt

#~@{:-:{:{.|.

Listeyi tek bir argüman 1olarak alır ve 0eğer aceleci ve falsey ise çıktılar .

kullanım

   f =: #~@{:-:{:{.|.
   f 5 6 5 3 3 3
1
   f 5 6 5 4 4 4
0

açıklama

#~@{:-:{:{.|.  Input: array A
           |.  Reverse A
       {:      Get the last value in A
         {.    Take that many values from the reverse of A
   {:          Get the last value in A
#~@            Make a list with that many copies of the last value
     -:        Test if the list of copies matches the sublist of A and return

Brain-Flak , 54 bayt

(({})[()]){({}[()]<({}[({})]){<>}{}>)}{}{<>(<(())>)}{}

Girdi, tamsayıların bir listesidir, çıktılar gerçek için 1'dir ve falsey için boştur.

açıklama

(({})[()]){ Loop a number of times equal to the last integer in the input - 1
    ({}[()] Handle loop counter
        < Silently...
            ({}[({})]) Replace the last code point in the string with its difference with the code point before it
            {<>} If the difference is not zero then switch stacks
            {} Discard the difference
        > End silently
    ) Handle loop counter
} End loop
{} Discard the loop counter
{<>(<(())>)} If the top of the current stack is not 0 (which means we have not switched stacks push 0 then 1
{} Discard the top of the stack (either nothing if falsey or 0 if truthy)

Bir falsey dönüşüyle ​​sonuçlanacak bir değerle karşılaşıldığında döngü hemen bitmez. Bunun yerine, boş olan ve yinelemelerinin geri kalanını 0 ve 0'ı karşılaştırarak geçiren diğer yığına geçirilir.

Toplu iş, 101 bayt

@for %%a in (%*)do @set/an=%%a,c=0
@for %%a in (%*)do @set/ac+=1,c*=!(n-%%a)
@if %c% geq %n% echo 1

Komut satırı parametreleri olarak girdiyi alır, hepsinin üzerinden geçen, sonuncuyu alabilmesi için nüstünden tekrar geçirir, takip edenlerin çalışmasını saymak için tekrar tekrar çevrir ve sayım en az eşitse nyazdırılır . Alternatif olarak, yazdırma veya sıfır olmayan bir değer kabul edilebilirse, 93 bayt için son satırı değiştirin .1n0@cmd/cset/ac/n

Haskell, 49 bayt

f s|x<-(==last s)=x.length.fst.span x.reverse$s

Ideone'da dene.

TrueGerçeğe ve daha sonra sahte Falsebir istisna için dönen daha kısa sürüm :

((==).head>>=all).(head>>=take).reverse

Dyalog APL , 10 bayt

(⊃∧.=⊃↑⊢)⌽

⊃İlk mi
∧.=üzere tüm eşittir
⊃birinci
↑ n alınan ters argüman?
⊢
⌽

TryAPL çevrimiçi!

Javascript (ES6), 51 47 41 bayt

a=>(r=k=>a.pop()^n?k<2:r(k-1))(n=a.pop())

Örnekler:

let f =
a=>(r=k=>a.pop()^n?k<2:r(k-1))(n=a.pop())

console.log(f([5, 6, 5, 3, 3, 3]))
console.log(f([5, 6, 5, 4, 4, 4]))

C 91 Bayt

int f(int*l){int n;for(n=0;l[++n];);l+=n-1;for(int i=*l;i;)if(l[-i--+1]^*l||n<*l)return 0;}

Giriş: boş sonlandırılmış bir diziye bir işaretçi.
Çıktı: 0geçersiz dolgu için döndürür , geçerli için sıfır olmaz

Örnekler:

int a[] = {5, 6, 5, 3, 3, 3, 0};
printf("%d\n", f(&a[5], 6));

int b[] = {1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 0};
printf("%d\n", f(&b[11],12 ));

int m[] = {5, 6, 5, 4, 4, 4, 0};
printf("%d\n", f(&m[5], 6));

int n[] = {3, 3, 3, 94, 3, 3, 0};
printf("%d\n", f(&n[5], 6));

verir:

3
2
0
0

Bu tanımsız davranışa dayanır. Dolgu geçerliyse, return ifadesi yoktur, ancak bunu kullanmak gcc -std=c99, iletilen dizinin son öğesini döndürür (en azından makinemde).

Perl 5 , 30 bayt

içerir +1için-p

#!/usr/bin/perl -p
$_=/(.)\1*\z/s+length$&>ord$1

Çevrimiçi deneyin!

Brachylog , 6 bayt

a₁=.l∈

Çevrimiçi deneyin!

Leaky Nun's Brachylog v1'in cevap verdiği gibi, çıkışın başarılı ya da başarısız olduğunu gösterir. Aynı şekilde benzer bir yaklaşım izliyor, ancak çok daha kısa çıkıyor.

a₁        There exists a suffix of the input
  =       the elements of which are all equal
   .      which is the output variable
    l     the length of which
     ∈    is an element of
          the output variable.

Brachylog , 6 bayt

ḅt.l≥∈

Çevrimiçi deneyin!

Dennis'in Jelly cevabından ilham alan aynı uzunlukta çıkan alternatif bir versiyon.

 t        The last
ḅ         block of consecutive equal elements of the input
  .       is the output variable
   l      the length of which
    ≥     is greater than or equal to
     ∈    an element of
          the output variable.

Retina , 34 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

.+
$*
\b(1(1)*)(?<-2>¶\1)*$(?(2)!)

Giriş, satır besleme ayrılmış bir tam sayı listesidir. 0Veya yazdırır 1.

Çevrimiçi deneyin! (İlk satır, her satırda bir boşlukla ayrılmış bir test vakasının bulunduğu bir test paketini etkinleştirir.)

35 baytta biten ve basılan 0veya pozitif bir tamsayı olan alternatif bir fikir :

.+
$*
\b(?=(1+)(¶\1)*$)(?<-2>1)*1\b

Pyke, 7 bayt

eQ>}lt!

Burada dene!

Javascript (ES5), 89 bayt

function(b){for(var d=b[b.length-1],c=0;c<d;c++)if(b[b.length-c-1]!=d)return!1;return!0};

Ungolfed:

function a(arr){
var b=arr[arr.length-1];
for(var i=0;i<b;i++){
    if(arr[arr.length-i-1]!=b)return false;
}
return true;
}

Brain-Flak 84 bayt

100000000 beni burada yendi

Çevrimiçi Deneyin!

((({}))){({}[()]<(({})<([{}]{}<>)<>>)>)}<>([])({<{}>{}<([])>}{}<(())>){((<{}{}>))}{}

Girdiyi tamsayı dizisi olarak alır.

Gelecek açıklama.

İşte cevabını çıkarmayan 64 baytlık bir versiyon:

((({}))){({}[()]<(({})<([{}]{}<>)<>>)>)}<>([])({<{}>{}<([])>}{})