Nella crittografia, il padding PKCS # 7 è uno schema di padding che aggiunge un numero di byte N ≥ 1, in cui il valore di ciascun byte aggiunto è uguale a N.

Ad esempio, Hello, World!che ha 13 byte, è il seguente in esadecimale:

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

Se scegliamo il pad PKCS # 7 alla lunghezza 16, il risultato è:

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

E se scegliamo di riempire fino alla lunghezza 20, il risultato è:

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

Si noti che nel primo esempio aggiungiamo tre 03byte e nel secondo aggiungiamo sette 07byte.

Il tuo compito sarà convalidare se una stringa (o un array intero) ha il padding PKCS # 7 corretto. Cioè, se l'ultimo byte della stringa di input è N, il programma dovrebbe verificare che gli ultimi N byte della stringa siano uguali a N.

Ingresso

Una singola stringa ASCII non vuota contenente caratteri tra i punti di codice 1 e 127 inclusi. Se lo desideri, puoi invece prendere l'input come una matrice di numeri interi.

Produzione

Un valore true se la stringa di input ha un padding PKCS # 7 valido, altrimenti un valore falsy.

Sono accettabili sia funzioni che programmi completi. Questo è code-golf , quindi l'obiettivo è ridurre al minimo il numero di byte nel codice.

Casi test

La versione di array di numeri interi di input è presentata qui - la versione di stringa avrebbe caratteri non stampabili per molti dei seguenti casi di test:

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 byte

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

s[-1]è l'ultimo membro dell'elenco s. Verifica che gli ultimi s[-1]membri dell'array di input ssiano gli stessi di un array s[-1]ripetuto più volte.

Accetta l'input come una matrice di numeri interi. Questa è un'espressione lambda; per usarlo, assegnalo con il prefisso lambdacon f=.

Provalo su Ideone!

Testare:

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

Salvato 13 byte grazie a Leaky Nun!

Salvataggio di un byte grazie a Dennis!

Brachylog , 14 byte

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

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

gFer8

RLE sull'input, prende l'ultima coppia e controlla se il numero di ripetizioni è maggiore o uguale al valore.

Provalo online: Dimostrazione o Test Suite

Gelatina , 5 byte

ŒgṪṫṪ

L'input è un array di punti di codice, l'output è un array non vuoto (vero) o un array vuoto (falso).

Provalo online! o verifica tutti i casi di test .

Come funziona

Œ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

Grazie a Sp3000 per il salvataggio di 1 byte.

{e`W=:/}

Accetta un elenco intero come input e restituisce 0(falsy) o un numero intero positivo (verità).

Suite di test.

Spiegazione

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

Nessuna codifica di lunghezza per osabie :(

¤sR¬£¬QOQ

Spiegazione:

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

Con un esempio:

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

Utilizza la codifica CP-1252 . Provalo online!

MATL , 10 byte

Grazie a @Adnan per aver notato un problema con una versione precedente del codice

P0hG0):)&=

Quando l'input ha il padding corretto, l'output è un array contenente solo quelli, il che è vero . Quando ha un padding errato, l'output è un array contenente almeno uno zero, e quindi è falsy .

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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 byte

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

Dividi l'input in serie di elementi uguali, estrai l'ultimo e verifica che il suo primo elemento sia minore o uguale alla lunghezza di quella sequenza.

Haskell, 50 byte

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

Accetta una matrice di numeri interi come input.

J, 13 byte

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

Prende l'elenco come singolo argomento e genera 1se è veritiero e 0se falso.

uso

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

Spiegazione

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

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

L'input è un elenco di numeri interi, l'output è 1 per verità e vuoto per falsità.

Spiegazione

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

Il ciclo non termina immediatamente quando viene rilevato un valore che provocherebbe un ritorno falso. Viene invece passato all'altro stack che è vuoto e passa il resto delle sue iterazioni confrontando 0 e 0.

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

Prende l'input come parametri della riga di comando, li ricopre tutti in modo che possa inserirne l'ultimo n, li ricopre tutti per contare la corsa di ns finali , infine stampa 1se il conteggio è almeno uguale a n. In alternativa, se 0è accettabile la stampa o un valore diverso da zero, per 93 byte, modificare l'ultima riga in @cmd/cset/ac/n.

Haskell, 49 byte

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

Provalo su Ideone.

Versione più breve che ritorna True verità e / Falseo un'eccezione per falsità:

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

Dyalog APL , 10 byte

(⊃∧.=⊃↑⊢)⌽

⊃È il primo
∧.=tutto uguale al
⊃primo
↑ n preso da
⊢ da
⌽ argomento inverso?

ProvaAPL online!

Javascript (ES6), 51 47 41 byte

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

Esempi:

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: un puntatore a un array con terminazione null.
Uscita: ritorna0 per riempimento non valido e diverso da zero per valido (l'ultimo elemento dell'array)

Esempi:

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

dà:

3
2
0
0

Questo si basa su un comportamento indefinito. Se il padding è valido non esiste alcuna istruzione return, ma l'utilizzo di gcc -std=c99questo restituisce l'ultimo elemento dell'array che è stato passato (almeno sulla mia macchina).

Perl 5 , 30 byte

Include +1per-p

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

Provalo online!

Brachylog , 6 byte

a₁=.l∈

Provalo online!

Produce attraverso successo o fallimento predicato, come fa la risposta Brachylog v1 di Leaky Nun. Adotta anche un approccio simile, ma risulta molto più breve.

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

Provalo online!

Una versione alternativa che esce alla stessa lunghezza e che trae ispirazione dalla risposta di Jelly di Dennis.

 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 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

L'input è un elenco di numeri interi separati da avanzamento riga. Stampe 0o 1.

Provalo online!(La prima riga abilita una suite di test, in cui esiste un caso di test separato da spazi per riga.)

Un'idea alternativa che finisce con 35 byte e stampa 0o un numero intero positivo:

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

Pyke, 7 byte

eQ>}lt!

Provalo qui!

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

Brain-Flak 84 byte

100000000 mi ha battuto qui

Provalo online!

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

Accetta input come array di numeri interi.

Spiegazione a venire.

Ecco una versione a 64 byte che genera il non della risposta:

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