In der Kryptographie ist PKCS # 7-Auffüllung ein Auffüllschema, das eine Anzahl von Bytes N ≥ 1 hinzufügt, wobei der Wert jedes hinzugefügten Bytes gleich N ist.

Beispiel: Hello, World!13 Byte sind hexadezimal wie folgt:

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

Wenn wir PKCS # 7 Pad auf Länge 16 wählen, dann ist das Ergebnis:

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

Und wenn wir uns dafür entscheiden, auf Länge 20 aufzufüllen, lautet das Ergebnis:

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

Beachten Sie, dass wir im ersten Beispiel drei 03Bytes und im zweiten sieben 07Bytes hinzufügen .

Ihre Aufgabe besteht darin, zu überprüfen, ob eine Zeichenfolge (oder ein ganzzahliges Array) die richtige PKCS # 7-Auffüllung aufweist. Das heißt, wenn das letzte Byte der Eingabezeichenfolge N ist, sollte Ihr Programm prüfen, ob die letzten N Bytes der Zeichenfolge N entsprechen.

Eingang

Eine einzelne nicht leere ASCII-Zeichenfolge, die Zeichen zwischen den Codepunkten 1 und 127 enthält. Wenn Sie möchten, können Sie die Eingabe stattdessen als Array von Ganzzahlen annehmen.

Ausgabe

Ein wahrer Wert, wenn die Eingabezeichenfolge eine gültige PKCS # 7-Auffüllung aufweist, andernfalls ein falscher Wert.

Beide Funktionen und vollständige Programme sind akzeptabel. Dies ist Codegolf , daher ist es das Ziel, die Anzahl der Bytes in Ihrem Code zu minimieren.

Testfälle

Die Integer-Array-Version der Eingaben wird hier dargestellt. Die String-Version würde für viele der folgenden Testfälle nicht druckbare Zeichen enthalten:

Wahrheit:

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

Falsch:

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

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

s[-1]ist das letzte Mitglied der Liste s. Überprüft, ob die letzten s[-1]Elemente des Eingabearrays mit einem Array sidentisch sind, das so s[-1]oft wiederholt wurde.

Nimmt die Eingabe als Array von Ganzzahlen. Dies ist ein Lambda-Ausdruck; Um es zu verwenden, weisen Sie es mit einem Präfix lambdazu f=.

Probieren Sie es auf Ideone!

Zu testen:

>>> 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 Bytes dank Leaky Nun eingespart!

Dank Dennis ein Byte gespart!

Brachylog , 14 Bytes

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

Probieren Sie es online!

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

gFer8

RLE bei der Eingabe, nimm das letzte Paar und überprüfe, ob die Anzahl der Wiederholungen größer oder gleich dem Wert ist.

Probieren Sie es online aus: Demo oder Test Suite

Gelee , 5 Bytes

ŒgṪṫṪ

Eingabe ist ein Array von Codepunkten, Ausgabe ist ein nicht leeres Array (wahr) oder ein leeres Array (falsch).

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Vielen Dank an Sp3000 für das Speichern von 1 Byte.

{e`W=:/}

Nimmt eine Ganzzahlliste als Eingabe und gibt 0(falsch) oder eine positive Ganzzahl (wahr) zurück.

Testsuite.

Erläuterung

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 Bytes

Keine Lauflängencodierungen für osabie :(

¤sR¬£¬QOQ

Erläuterung:

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

Mit einem Beispiel:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

MATL , 10 Bytes

Vielen Dank an @Adnan, dass er ein Problem mit einer früheren Version des Codes bemerkt hat

P0hG0):)&=

Wenn die Eingabe korrekt aufgefüllt ist, ist die Ausgabe ein Array, das nur Einsen enthält, was wahr ist . Wenn die Auffüllung nicht korrekt ist, ist die Ausgabe ein Array, das mindestens eine Null enthält, und ist daher falsch .

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

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 Bytes

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

Teilen Sie die Eingabe in Läufe gleicher Elemente auf, extrahieren Sie den letzten und überprüfen Sie, ob sein erstes Element kleiner oder gleich der Länge dieses Laufs ist.

Haskell, 50 Bytes

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

Nimmt ein Array von Ganzzahlen als Eingabe.

J, 13 Bytes

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

Nimmt die Liste als einzelnes Argument und gibt aus, 1ob sie wahr und 0falsch ist.

Verwendung

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

Erläuterung

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

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

Die Eingabe ist eine Liste von ganzen Zahlen, die Ausgabe ist 1 für wahr und leer für falsch.

Erläuterung

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

Die Schleife endet nicht sofort, wenn ein Wert angetroffen wird, der zu einer falschen Rückkehr führen würde. Es wird stattdessen auf den anderen Stapel umgeschaltet, der leer ist und den Rest seiner Iterationen damit verbringt, 0 und 0 zu vergleichen.

Batch, 101 Bytes

@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

Übernimmt Eingaben als Befehlszeilenparameter, durchläuft sie alle, damit der letzte eingegeben werden kann n, durchläuft sie alle erneut, um die Anzahl der nachfolgenden ns zu zählen, und gibt schließlich aus, 1ob die Anzahl mindestens gleich ist n. Wenn alternativ Drucken 0oder ein Wert ungleich Null zulässig ist, ändern Sie für 93 Byte die letzte Zeile in @cmd/cset/ac/n.

Haskell, 49 Bytes

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

Probieren Sie es auf Ideone.

Kürzere Version, die Truefür Wahrhaftigkeit und / Falseoder eine Ausnahme für Falschheit zurückgibt:

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

Dyalog APL , 10 Bytes

(⊃∧.=⊃↑⊢)⌽

⊃Ist das erste
∧.=all-gleich
⊃dem ersten
↑ n aus
⊢dem
⌽umgekehrten Argument?

TryAPL online!

Javascript (ES6), 51 47 41 Bytes

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

Beispiele:

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 Bytes

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

Eingabe: Ein Zeiger auf ein nullterminiertes Array.
Ausgabe: Gibt 0für eine ungültige Auffüllung und für eine gültige Nicht-Null-Angabe zurück (das letzte Element im Array).

Beispiele:

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

Gibt:

3
2
0
0

Dies setzt undefiniertes Verhalten voraus. Wenn die Auffüllung gültig ist, gibt es keine return-Anweisung, aber wenn Sie gcc -std=c99diese verwenden, wird das letzte Element des Arrays zurückgegeben, das übergeben wurde (zumindest auf meinem Computer).

Perl 5 , 30 Bytes

Beinhaltet +1für-p

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

Probieren Sie es online!

Brachylog , 6 Bytes

a₁=.l∈

Probieren Sie es online!

Die Ausgabe erfolgt durch Erfolg oder Misserfolg eines Prädikats, wie es die Brachylog v1-Antwort von Leaky Nun tut. Geht ähnlich vor, kommt aber viel kürzer raus.

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 Bytes

ḅt.l≥∈

Probieren Sie es online!

Eine alternative Version, die in der gleichen Länge herauskommt und sich von Dennis 'Jelly-Antwort inspirieren lässt.

 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 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Die Eingabe ist eine durch Zeilenvorschub getrennte Liste von Ganzzahlen. Druckt 0oder1 .

Probieren Sie es online!(Die erste Zeile aktiviert eine Testsuite, bei der es einen durch Leerzeichen getrennten Testfall pro Zeile gibt.)

Eine alternative Idee, die bei 35 Bytes endet und 0eine positive Ganzzahl ausgibt:

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

Pyke, 7 Bytes

eQ>}lt!

Probieren Sie es hier aus!

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

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

Gehirn-Flak 84 Bytes

100000000 schlagen mich hier

Probieren Sie es online!

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

Übernimmt die Eingabe als Array von Ganzzahlen.

Erklärung zu kommen.

Hier ist eine 64-Byte-Version, die das Nicht der Antwort ausgibt:

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