ในวิทยาการเข้ารหัสลับการหุ้ม PKCS # 7เป็นโครงร่างการขยายซึ่งเพิ่มจำนวนไบต์ N ≥ 1 โดยที่ค่าของแต่ละไบต์ที่เพิ่มมีค่าเท่ากับ N

ตัวอย่างเช่นHello, World!ซึ่งมี 13 ไบต์มีดังต่อไปนี้ในฐานสิบหก:

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

ถ้าเราเลือกที่จะ PKCS # 7 ความยาว 16 แผ่นผลที่ได้คือ:

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

และถ้าเราเลือกที่จะยาวถึง 20 แผ่นผลลัพธ์ก็คือ:

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

โปรดทราบว่าในตัวอย่างแรกเราเพิ่มสาม03ไบต์และในวินาทีที่เราเพิ่มเจ็ด07ไบต์

งานของคุณคือการตรวจสอบว่าสตริง (หรืออาร์เรย์จำนวนเต็ม) มีการเติม PKCS # 7 ที่ถูกต้อง นั่นคือถ้าไบต์สุดท้ายของสตริงอินพุตคือ N ดังนั้นโปรแกรมของคุณควรตรวจสอบว่าไบต์สุดท้ายของสตริงเท่ากับ N

อินพุต

สตริง ASCII ที่ไม่ว่างเปล่าซึ่งมีอักขระระหว่างรหัสจุด 1 ถึง 127 หากคุณต้องการคุณอาจป้อนข้อมูลเป็นอาร์เรย์จำนวนเต็มแทน

เอาท์พุต

truthyค่าถ้าสายป้อนมี PKCS # 7 ที่ถูกต้อง padding มิฉะนั้นค่า falsy

ทั้งฟังก์ชั่นและโปรแกรมเต็มรูปแบบเป็นที่ยอมรับ นี่คือโค้ดกอล์ฟดังนั้นจุดประสงค์คือเพื่อลดจำนวนไบต์ในรหัสของคุณ

กรณีทดสอบ

อินพุตของอาร์เรย์จำนวนเต็มมีการแสดงไว้ที่นี่ - รุ่นสตริงจะมีอักขระที่ไม่สามารถพิมพ์ได้สำหรับกรณีทดสอบต่อไปนี้จำนวนมาก:

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 ไบต์

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

s[-1]sเป็นสมาชิกคนสุดท้ายของรายการ ตรวจสอบว่าs[-1]สมาชิกสุดท้ายของอาร์เรย์อินพุตsเหมือนกันกับอาร์เรย์s[-1]ซ้ำหลายครั้ง

รับอินพุตเป็นอาร์เรย์ของจำนวนเต็ม นี่คือการแสดงออกแลมบ์ดา; ที่จะใช้มันกำหนดโดย prefixing ด้วยlambdaf=

ลองใช้กับ Ideone!

ทดสอบ:

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

บันทึก 13 ไบต์ขอบคุณ Leaky Nun!

บันทึกเป็นไบต์ขอบคุณ Dennis!

Brachylogขนาด 14 ไบต์

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

ลองออนไลน์!

~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 ไบต์

gFer8

RLE ที่อินพุทรับคู่สุดท้ายแล้วตรวจสอบว่าจำนวนการซ้ำมีค่ามากกว่าหรือเท่ากับค่า

ลองใช้ออนไลน์: การสาธิตหรือชุดทดสอบ

เยลลี่ 5 ไบต์

ŒgṪṫṪ

อินพุตเป็นอาร์เรย์ของรหัสจุดเอาต์พุตเป็นอาร์เรย์ที่ไม่ว่างเปล่า (ความจริง) หรืออาร์เรย์ว่างเปล่า (เท็จ)

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

Œ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 ไบต์

ขอบคุณ Sp3000 สำหรับการบันทึก 1 ไบต์

{e`W=:/}

ใช้รายการจำนวนเต็มเป็นอินพุตและส่งคืน0(เท็จ) หรือจำนวนเต็มบวก (จริง)

ชุดทดสอบ

คำอธิบาย

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 ไบต์

ไม่มีการเข้ารหัสความยาวสำหรับ osabie :(

¤sR¬£¬QOQ

คำอธิบาย:

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

ด้วยตัวอย่าง:

¤           # [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 ลองออนไลน์!

MATL 10 ไบต์

ขอบคุณ @Adnan สำหรับการสังเกตปัญหาเกี่ยวกับรหัสรุ่นก่อนหน้า

P0hG0):)&=

เมื่อป้อนข้อมูลที่มีช่องว่างภายในที่ถูกต้อง, การส่งออกเป็นอาร์เรย์ที่มีคนเดียวซึ่งเป็นtruthy เมื่อมันมีช่องว่างที่ไม่ถูกต้องออกเป็นอาร์เรย์ที่มีอย่างน้อยเป็นศูนย์และเพื่อให้เป็นfalsy

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย

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 ไบต์

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

แยกอินพุตเป็นส่วนขององค์ประกอบเท่ากันแยกส่วนสุดท้ายและตรวจสอบว่าองค์ประกอบแรกนั้นน้อยกว่าหรือเท่ากับความยาวของการรันนั้น

Haskell, 50 ไบต์

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

รับอาร์เรย์จำนวนเต็มเป็นอินพุต

J, 13 ไบต์

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

ใช้รายการเป็นอาร์กิวเมนต์เดียวและส่งออก1ถ้ามันเป็นความจริงและ0ถ้าเท็จ

การใช้

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

คำอธิบาย

#~@{:-:{:{.|.  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 ไบต์

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

อินพุตเป็นรายการของจำนวนเต็มเอาต์พุตเป็น 1 สำหรับความจริงและว่างเปล่าสำหรับเท็จ

คำอธิบาย

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

การวนซ้ำไม่สิ้นสุดทันทีเมื่อพบค่าที่จะส่งผลให้เกิดการปลอมแปลงกลับ มันถูกเปลี่ยนเป็นสแต็กอื่นแทนซึ่งว่างเปล่าและใช้เวลาที่เหลือของการวนซ้ำเมื่อเปรียบเทียบกับ 0 และ 0

แบตช์ 101 ไบต์

@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

จะเข้าเป็นพารามิเตอร์บรรทัดคำสั่งลูปมากกว่าพวกเขาทั้งหมดเพื่อที่จะสามารถได้รับคนสุดท้ายเข้าไปในnห่วงมากกว่าพวกเขาทั้งหมดอีกครั้งในการนับการทำงานของต่อท้ายns ที่สุดพิมพ์ถ้านับเป็นอย่างน้อยเท่ากับ1 nอีกวิธีหนึ่งคือถ้าพิมพ์0หรือค่าที่ไม่ใช่ศูนย์เป็นที่ยอมรับแล้ว 93 @cmd/cset/ac/nไบต์เปลี่ยนบรรทัดสุดท้ายที่จะ

Haskell, 49 ไบต์

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

ลองใช้กับ Ideone

เวอร์ชั่นที่สั้นกว่าซึ่งให้ผลตอบแทนTrueตามความเป็นจริงและFalseหรือเป็นข้อยกเว้นสำหรับความเท็จ:

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

Dyalog APL ขนาด 10 ไบต์

(⊃∧.=⊃↑⊢)⌽

⊃เป็นครั้งแรกที่
∧.=มีค่าเท่ากับn
⊃แรกที่นำมาจากการโต้แย้งกลับกัน?
↑
⊢
⌽

ลองใช้ออนไลน์!

Javascript (ES6), 51 47 41 ไบต์

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

ตัวอย่าง:

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 ไบต์

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

อินพุต: ตัวชี้ไปยังอาร์เรย์ที่สิ้นสุดด้วยค่า null
เอาท์พุท: ส่งกลับ0สำหรับการเติมที่ไม่ถูกต้องและไม่เป็นศูนย์สำหรับการใช้งานได้ (องค์ประกอบสุดท้ายในอาร์เรย์)

ตัวอย่าง:

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

ให้:

3
2
0
0

สิ่งนี้ขึ้นอยู่กับพฤติกรรมที่ไม่ได้กำหนด ถ้า padding ถูกต้องจะไม่มีคำสั่ง return แต่การใช้gcc -std=c99นี้จะคืนค่าองค์ประกอบสุดท้ายของอาร์เรย์ที่ส่งผ่านไป (อย่างน้อยในเครื่องของฉัน)

Perl 5 , 30 ไบต์

รวม+1สำหรับ-p

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

ลองออนไลน์!

Brachylogขนาด 6 ไบต์

a₁=.l∈

ลองออนไลน์!

แสดงผลผ่านความสำเร็จหรือความล้มเหลวของภาครัฐดังที่คำตอบ Brachylog v1 ของ Leaky Nun ทำได้ ใช้แนวทางที่คล้ายกันเช่นกัน แต่สั้นกว่านั้นมาก

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 ไบต์

ḅt.l≥∈

ลองออนไลน์!

รุ่นอื่นที่มีความยาวเท่ากันซึ่งได้แรงบันดาลใจจากคำตอบของเดนนิสเยลลี่

 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.

เรติน่า 34 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

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

อินพุตเป็นรายการจำนวนเต็มที่คั่นด้วย linefeed พิมพ์หรือ01

ลองออนไลน์! (บรรทัดแรกเปิดใช้งานชุดการทดสอบซึ่งมีกรณีทดสอบหนึ่งรายการที่คั่นด้วยช่องว่างต่อบรรทัด)

แนวคิดทางเลือกที่ลงท้ายด้วย 35 ไบต์และพิมพ์0หรือจำนวนเต็มบวก:

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

Pyke ขนาด 7 ไบต์

eQ>}lt!

ลองที่นี่!

Javascript (ES5), 89 ไบต์

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 ไบต์

100000000 เอาชนะฉันที่นี่

ลองออนไลน์!

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

รับอินพุตเป็นอาร์เรย์ของจำนวนเต็ม

คำอธิบายที่จะมา

นี่คือรุ่น 64 ไบต์ที่ส่งออกไม่ใช่คำตอบ:

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