Trong mật mã, phần đệm PKCS # 7 là sơ đồ đệm có thêm một số byte N 1, trong đó giá trị của mỗi byte được thêm bằng với N.

Ví dụ, Hello, World!có 13 byte, như sau trong hex:

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

Nếu chúng tôi chọn pad PKCS # 7 đến chiều dài 16, thì kết quả là:

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

Và nếu chúng ta chọn đệm đến độ dài 20, thì kết quả là:

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

Lưu ý rằng trong ví dụ đầu tiên, chúng tôi thêm ba 03byte và trong lần thứ hai, chúng tôi thêm bảy 07byte.

Nhiệm vụ của bạn sẽ là xác thực xem một chuỗi (hoặc mảng số nguyên) có phần đệm PKCS # 7 chính xác hay không. Nghĩa là, nếu byte cuối cùng của chuỗi đầu vào là N, thì chương trình của bạn sẽ kiểm tra xem N byte cuối cùng của chuỗi có bằng N.

Đầu vào

Một chuỗi ASCII không trống duy nhất chứa các ký tự nằm giữa các điểm mã 1 và 127. Nếu bạn muốn, bạn có thể lấy đầu vào là một mảng các số nguyên thay thế.

Đầu ra

Một truthy giá trị nếu chuỗi đầu vào có hợp lệ PKCS # 7 đệm, nếu không một giá trị falsy.

Cả hai chức năng và chương trình đầy đủ đều được chấp nhận. Đây là mã golf , vì vậy mục đích là để giảm thiểu số lượng byte trong mã của bạn.

Các trường hợp thử nghiệm

Phiên bản mảng số nguyên của các đầu vào được trình bày ở đây - phiên bản chuỗi sẽ có các ký tự không thể in được cho nhiều trường hợp kiểm tra sau:

Sự thật:

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

Giả mạo:

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

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

s[-1]là thành viên cuối cùng của danh sách s. Kiểm tra xem các s[-1]thành viên cuối cùng của mảng đầu vào scó giống như một mảng s[-1]lặp lại nhiều lần không.

Đưa đầu vào như một mảng các số nguyên. Đây là một biểu thức lambda; để sử dụng nó, gán nó bằng cách thêm tiền tố lambdavào f=.

Hãy thử nó trên Ideone!

Để kiểm tra:

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

Đã lưu 13 byte nhờ Leaky Nun!

Đã lưu một byte nhờ Dennis!

Brachylog , 14 byte

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

Hãy thử trực tuyến!

~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

Bình thường, 5 byte

gFer8

RLE trên đầu vào, lấy cặp cuối cùng và kiểm tra xem số lần lặp lại lớn hơn hoặc bằng giá trị.

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Thạch , 5 byte

ŒgṪṫṪ

Đầu vào là một mảng các điểm mã, đầu ra là một mảng không trống (trung thực) hoặc một mảng trống (giả).

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

Œ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 byte

Cảm ơn Sp3000 vì đã tiết kiệm 1 byte.

{e`W=:/}

Lấy danh sách số nguyên làm đầu vào và trả về 0(giả) hoặc số nguyên dương (trung thực).

Bộ thử nghiệm.

Giải trình

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 byte

Không mã hóa độ dài chạy cho osabie :(

¤sR¬£¬QOQ

Giải trình:

¤           # 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

Với một ví dụ:

¤           # [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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

MATL , 10 byte

Cảm ơn @Adnan vì đã nhận thấy sự cố với phiên bản mã trước đó

P0hG0):)&=

Khi đầu vào có phần đệm chính xác, đầu ra là một mảng chỉ chứa những phần tử, đó là sự thật . Khi nó có đệm không chính xác, sản lượng là một mảng chứa ít nhất một số không, và như vậy là falsy .

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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

Toán học, 29 byte

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

Chia đầu vào thành các phần tử bằng nhau, trích xuất phần cuối cùng và kiểm tra xem phần tử đầu tiên của nó nhỏ hơn hoặc bằng độ dài của phần chạy đó.

Haskell, 50 byte

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

Lấy một mảng các số nguyên làm đầu vào.

J, 13 byte

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

Đưa danh sách thành một đối số duy nhất và đầu ra 1nếu nó là sự thật và 0nếu falsey.

Sử dụng

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

Giải trình

#~@{:-:{:{.|.  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 byte

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

Đầu vào là danh sách các số nguyên, đầu ra là 1 cho trung thực và trống cho falsey.

Giải trình

(({})[()]){ 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)

Vòng lặp không kết thúc ngay lập tức khi gặp một giá trị dẫn đến kết quả trả về falsey. Thay vào đó, nó được chuyển sang ngăn xếp khác trống và dành phần còn lại của các lần lặp so sánh 0 và 0.

Mẻ, 101 byte

@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

Đưa đầu vào dưới dạng tham số dòng lệnh, lặp lại tất cả để có thể đưa cái cuối cùng vào n, lặp lại tất cả chúng để đếm số lần chạy của ns, cuối cùng là in 1nếu số lượng ít nhất bằng n. Ngoài ra, nếu in 0hoặc giá trị khác không được chấp nhận, thì với 93 byte, hãy thay đổi dòng cuối cùng thành @cmd/cset/ac/n.

Haskell, 49 byte

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

Hãy thử nó trên Ideone.

Phiên bản ngắn hơn trả về Truecho sự thật và Falsehoặc một ngoại lệ cho giả mạo:

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

APL Dyalog , 10 byte

(⊃∧.=⊃↑⊢)⌽

⊃Là lần đầu tiên
∧.=tất cả các-tương đương với
⊃người đầu tiên
↑ n lấy từ
⊢các
⌽luận cứ đảo ngược?

Dùng thử trực tuyến!

Javascript (ES6), 51 47 41 byte

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

Ví dụ:

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 byte

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

Input: một con trỏ tới một mảng kết thúc null.
Đầu ra: trả về 0cho phần đệm không hợp lệ và khác không cho hợp lệ (phần tử cuối cùng trong mảng)

Ví dụ:

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

Cung cấp:

3
2
0
0

Điều này không dựa trên hành vi không xác định. Nếu phần đệm hợp lệ thì không có câu lệnh return, nhưng sử dụng gcc -std=c99phần tử này sẽ trả về phần tử cuối cùng của mảng được truyền vào (ít nhất là trên máy của tôi).

Perl 5 , 30 byte

Bao gồm +1cho-p

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

Hãy thử trực tuyến!

Brachylog , 6 byte

a₁=.l∈

Hãy thử trực tuyến!

Đầu ra thông qua dự đoán thành công hay thất bại, như câu trả lời Brachylog v1 của Leaky Nun đã làm. Cũng có một cách tiếp cận tương tự, nhưng ngắn hơn rất nhiều.

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 byte

ḅt.l≥∈

Hãy thử trực tuyến!

Một phiên bản thay thế có cùng độ dài lấy một số cảm hứng từ câu trả lời của Dennis 'Jelly.

 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.

Võng mạc , 34 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Đầu vào là một danh sách các số nguyên được phân tách bằng dòng. In 0hoặc 1.

Hãy thử trực tuyến!(Dòng đầu tiên cho phép một bộ thử nghiệm, trong đó có một trường hợp thử nghiệm được phân tách bằng dấu cách trên mỗi dòng.)

Một ý tưởng thay thế kết thúc ở 35 byte và in 0hoặc một số nguyên dương:

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

Pyke, 7 byte

eQ>}lt!

Hãy thử nó ở đây!

Javascript (ES5), 89 byte

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

Ung dung:

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 byte

100000000 đánh tôi ở đây

Dùng thử trực tuyến!

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

Lấy đầu vào là mảng số nguyên.

Giải thích sắp tới.

Đây là phiên bản 64 byte cho kết quả không phải là câu trả lời:

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