En cryptographie, le remplissage PKCS # 7 est un schéma de remplissage qui ajoute un nombre d'octets N ≥ 1, où la valeur de chaque octet ajouté est égale à N.

Par exemple, Hello, World!qui a 13 octets, est le suivant en hexadécimal:

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

Si nous choisissons de PKCS # 7 pad à la longueur 16, alors le résultat est:

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

Et si nous choisissons de remplir la longueur 20, le résultat est:

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

Notez que dans le premier exemple, nous ajoutons trois 03octets, et dans le second, nous ajoutons sept 07octets.

Votre tâche consistera à valider si une chaîne (ou un tableau d'entiers) a un remplissage PKCS # 7 correct. Autrement dit, si le dernier octet de la chaîne d'entrée est N, votre programme doit vérifier que les N derniers octets de la chaîne sont égaux à N.

Contribution

Une seule chaîne ASCII non vide contenant des caractères entre les points de code 1 et 127 inclus. Si vous le souhaitez, vous pouvez prendre l'entrée comme un tableau d'entiers à la place.

Sortie

Une valeur vraie si la chaîne d'entrée a un remplissage PKCS # 7 valide, sinon une valeur fausse.

Les fonctions et les programmes complets sont acceptables. Il s'agit de code-golf , donc l'objectif est de minimiser le nombre d'octets dans votre code.

Cas de test

La version du tableau d'entiers d'entrées est présentée ici - la version de chaîne aurait des caractères non imprimables pour la plupart des cas de test suivants:

Vérité:

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

Faux:

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

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

s[-1]est le dernier membre de la liste s. Vérifie que les derniers s[-1]membres du tableau d'entrée ssont les mêmes qu'un tableau de s[-1]répétitions autant de fois.

Prend l'entrée comme un tableau d'entiers. Il s'agit d'une expression lambda; pour l'utiliser, affectez-le en préfixant lambdaavec f=.

Essayez-le sur Ideone!

Tester:

>>> 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 octets enregistrés grâce à Leaky Nun!

Enregistré un octet grâce à Dennis!

Brachylog , 14 octets

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

Essayez-le en ligne!

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

gFer8

RLE en entrée, prenez la dernière paire et vérifiez si le nombre de répétitions est supérieur ou égal à la valeur.

Essayez-le en ligne: démonstration ou suite de tests

Gelée , 5 octets

ŒgṪṫṪ

L'entrée est un tableau de points de code, la sortie est un tableau non vide (véridique) ou un tableau vide (faux).

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça marche

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

Merci à Sp3000 pour avoir économisé 1 octet.

{e`W=:/}

Prend une liste entière comme entrée et retourne 0(fausse) ou un entier positif (vrai).

Suite de tests.

Explication

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 octets

Aucun encodage de longueur pour osabie :(

¤sR¬£¬QOQ

Explication:

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

Avec un exemple:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne!

MATL , 10 octets

Merci à @Adnan d'avoir remarqué un problème avec une version antérieure du code

P0hG0):)&=

Lorsque l'entrée a un remplissage correct, la sortie est un tableau ne contenant que des éléments, ce qui est vrai . Lorsqu'il a un remplissage incorrect, la sortie est un tableau contenant au moins un zéro, tout comme la fausse .

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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 octets

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

Divisez l'entrée en séries d'éléments égaux, extrayez le dernier et vérifiez que son premier élément est inférieur ou égal à la longueur de cette série.

Haskell, 50 octets

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

Prend un tableau d'entiers en entrée.

J, 13 octets

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

Prend la liste comme un seul argument et 1affiche si elle est véridique et 0si falsey.

Usage

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

Explication

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

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

L'entrée est une liste d'entiers, la sortie est 1 pour véridique et vide pour falsey.

Explication

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

La boucle ne se termine pas immédiatement lorsqu'une valeur qui entraînerait un retour de falsey est rencontrée. Au lieu de cela, il est basculé vers l'autre pile qui est vide et passe le reste de ses itérations à comparer 0 et 0.

Lot, 101 octets

@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

Prend l'entrée en tant que paramètres de ligne de commande, les boucle sur tous afin qu'il puisse obtenir le dernier n, les boucle à nouveau pour compter la série de ns finaux , pour finalement imprimer 1si le nombre est au moins égal à n. Alternativement, si l'impression 0ou une valeur non nulle est acceptable, alors pour 93 octets, remplacez la dernière ligne par @cmd/cset/ac/n.

Haskell, 49 octets

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

Essayez-le sur Ideone.

Version plus courte qui revient Truepour la vérité et Falseou une exception pour la fausse:

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

Dyalog APL , 10 octets

(⊃∧.=⊃↑⊢)⌽

⊃Le premier
∧.=tout égal au
⊃premier
↑ n est-il tiré de
⊢l'
⌽argument inversé?

TryAPL en ligne!

Javascript (ES6), 51 47 41 octets

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

Exemples:

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 octets

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

Entrée: un pointeur vers un tableau terminé par null.
Sortie: renvoie 0pour un remplissage non valide et non nul pour valide (le dernier élément du tableau)

Exemples:

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

Donne:

3
2
0
0

Cela dépend d'un comportement non défini. Si le remplissage est valide, il n'y a pas de déclaration de retour, mais son utilisation gcc -std=c99renvoie le dernier élément du tableau qui a été transmis (au moins sur ma machine).

Perl 5 , 30 octets

Comprend +1pour-p

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

Essayez-le en ligne!

Brachylog , 6 octets

a₁=.l∈

Essayez-le en ligne!

Sorties par succès ou échec de prédicat, comme le fait la réponse Brachylog v1 de Leaky Nun. Adopte également une approche similaire, mais sort beaucoup plus court.

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 octets

ḅt.l≥∈

Essayez-le en ligne!

Une version alternative qui sort dans la même longueur qui s'inspire de la réponse de 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.

Rétine , 34 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

L'entrée est une liste d'entiers séparés par des sauts de ligne. Imprime 0ou 1.

Essayez-le en ligne! (La première ligne active une suite de tests, où il y a un cas de test séparé par espace par ligne.)

Une idée alternative qui se termine à 35 octets et imprime 0ou un entier positif:

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

Pyke, 7 octets

eQ>}lt!

Essayez-le ici!

Javascript (ES5), 89 octets

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

Non golfé:

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 octets

100000000 me battre ici

Essayez-le en ligne!

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

Prend l'entrée comme un tableau d'entiers.

Explication à venir.

Voici une version 64 octets qui sort le non de la réponse:

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