25

क्रिप्टोग्राफी में, पीकेसीएस # 7 पैडिंग एक पैडिंग योजना है जो कई बाइट्स एन, 1 को जोड़ती है, जहां प्रत्येक जोड़ा बाइट का मूल्य एन के बराबर है।

उदाहरण के लिए, 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 बाइट N के बराबर हैं।

इनपुट

कोड अंक 1 और 127 के बीच एक एकल नॉनमॉपी ASCII स्ट्रिंग जिसमें वर्ण शामिल हैं। यदि आप चाहें, तो आप इसके बजाय पूर्णांक के एक सरणी के रूप में इनपुट ले सकते हैं।

उत्पादन

एक सत्य मान यदि इनपुट स्ट्रिंग में PKCS # 7 पैडिंग मान्य है, तो एक मिथ्या मूल्य।

दोनों कार्य और पूर्ण कार्यक्रम स्वीकार्य हैं। यह कोड-गोल्फ है , इसलिए उद्देश्य आपके कोड में बाइट्स की संख्या को कम करना है।

परीक्षण के मामलों

इनपुट्स के पूर्णांक सरणी संस्करण को यहां प्रस्तुत किया गया है - स्ट्रिंग संस्करण में निम्नलिखित परीक्षण मामलों में से कई के लिए अनपेक्षित वर्ण होंगे:

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]

— Sp3000
स्रोत

है [1 2 3 3 3 3]truthy या falsey? मुझे लगता है कि यह सच होना चाहिए लेकिन मैं सकारात्मक नहीं हूं।

— डीजेमैकेम

@DJMcMayhem ट्रुथ

— जक्यूब

@DJMcMayhem ट्रुथ (यह सत्य परीक्षण के मामले को समाप्त करता है 7)। आप इसके बारे में सोच सकते हैं, अलग करने के बाद, आप समाप्त करेंगे [1 2 3]।

— Sp3000

निश्चित रूप से आप हैलो के बाद अल्पविराम लगाने का मतलब है। (यह हेक्स में है।)

— रीसी

@rici सूचना के लिए धन्यवाद, निश्चित!

— बजे Sp3000

8

पायथन, 47 34 33 बाइट्स

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

s[-1]सूची का अंतिम सदस्य है s। जाँचता है कि s[-1]इनपुट सरणी के अंतिम सदस्य कई बार दोहराए गए sसरणी के समान हैं s[-1]।

पूर्णांक के एक सरणी के रूप में इनपुट लेता है। यह एक लंबोदर अभिव्यक्ति है; इसका उपयोग करने के लिए, इसके lambdaसाथ उपसर्ग लगाकर असाइन करें f=।

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 बाइट्स लीक लियुन की बदौलत!

डेनिस के लिए एक बाइट धन्यवाद बचा लिया!

— तांबा
स्रोत

def f(s)=एक बाइट कम है।

— थ्री एफएक्स

2

@ThreeFx आपको वापस जाने की आवश्यकता है?

— लीक नून

@ThreeFx हां, लेकिन फिर मुझे लिखना होगा return। lambdaसंस्करण 7 बाइट्स कम है।

— कॉपर

आप सही हे। माफ़ कीजिये।

— थ्री एफएक्स

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

— लीक नून

7

ब्रेकीलॉग , 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

— लीक नन
स्रोत

7

अजगर, 5 बाइट्स

gFer8

इनपुट पर RLE, अंतिम जोड़ी लें और जांचें कि क्या दोहराव की संख्या मूल्य से अधिक या बराबर है।

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

— Jakube
स्रोत

7

जेली , 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).

— डेनिस
स्रोत

6

CJam, 9 8 बाइट्स

1 बाइट बचाने के लिए Sp3000 का धन्यवाद।

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

— मार्टिन एंडर
स्रोत

6

05AB1E , 9 बाइट्स

ओसबी के लिए कोई रन-लंबाई एन्कोडिंग नहीं :(

¤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 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

5

MATL , 10 बाइट्स

कोड के पुराने संस्करण के साथ किसी समस्या को नोट करने के लिए @ Adnan का धन्यवाद

P0hG0):)&=

जब इनपुट में सही पैडिंग होती है, तो आउटपुट एक सरणी होती है, जिसमें केवल वही होता है, जो सत्य है । यह गलत गद्दी है, तो उत्पादन कम से कम एक शून्य से युक्त एक सरणी है, और इसलिए है 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

— लुइस मेंडो
स्रोत

@ अदनान अब काम कर रहा है

— लुइस

अच्छा, अच्छा लग रहा है :)

— अदनान

2

इसके अलावा, 25k पर बधाई! : 3

— अदनान

4

गणितज्ञ, 29 बाइट्स

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

इनपुट को समान तत्वों के रनों में विभाजित करें, अंतिम निकालें, और जांचें कि इसका पहला तत्व उस रन की लंबाई से कम या उसके बराबर है।

— मार्टिन एंडर
स्रोत

3

हास्केल, 50 बाइट्स

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

इनपुट के रूप में पूर्णांकों की एक सरणी लेता है।

— ThreeFx
स्रोत

जब तक आप REPL में न हों, आपको Data.List को आयात करना होगा।

— xnor

2

जे, 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

— मील की दूरी पर
स्रोत

@randomra मामला जैसे 3 4 3 3 3होता है ~.के रूप में 3 4तो यह है कि की अंतिम पंक्ति =है 0 1 0 0 0। मुझे लगता है कि रिवर्स पर {:*/@{.0{=@|.काम करना चाहिए जैसा कि काम करना चाहिए, लेकिन यह 13 बाइट्स के रूप में भी समाप्त होता है।

— मील

सही, अच्छा कैच। मैंने यह खो दिया।

— बेतरतीब

2

ब्रेन-फ्लैक , 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 की तुलना में इसके बाकी पुनरावृत्तियों को खर्च करता है।

— 0 '
स्रोत

1

अरे अरे, आपको यहाँ देखकर अच्छा लगा! साइट पर आपका स्वागत है!

— DJMcMayhem

1

बैच, 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, इन सभी पर लूप्स फिर से अनुगामी nएस के रन की गिनती करने के लिए , अंत में छपाई 1अगर गिनती कम से कम के बराबर है n। वैकल्पिक रूप से यदि मुद्रण 0या गैर-शून्य मान स्वीकार्य है, तो 93 बाइट्स के लिए, अंतिम पंक्ति को बदल दें @cmd/cset/ac/n।

— नील
स्रोत

1

हास्केल, 49 बाइट्स

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

Ideone पर इसे आज़माएं।

छोटा संस्करण जो Trueसत्य के लिए लौटता है और Falseया झूठे के लिए एक अपवाद है:

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

— Laikoni
स्रोत

1

Dyalog एपीएल , 10 बाइट्स

(⊃∧.=⊃↑⊢)⌽

⊃क्या उल्टे तर्क से लिए गए पहले n के
∧.= बराबर पहला सर्व है?
⊃
↑
⊢
⌽

TryAPL ऑनलाइन!

— एडम
स्रोत

2

कितने बाइट्स?

— कॉनर ओ'ब्रायन

@ ConorO'Brien क्षमा करें, बॉयलरप्लेट में भरना भूल गए।

— अदम

1

जावास्क्रिप्ट (ईएस 6), 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]))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

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

इनपुट: एक सूचक शून्य से समाप्त सरणी के लिए।
आउटपुट: 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));

देता है:

यह अपरिभाषित व्यवहार पर निर्भर करता है। यदि पैडिंग मान्य है, तो कोई रिटर्न स्टेटमेंट नहीं है, लेकिन gcc -std=c99इस रिटर्न का उपयोग करके उस एरे के अंतिम तत्व का उपयोग किया जाता है जो (कम से कम प्रत्येक मशीन में) पारित किया गया था।

— रिले
स्रोत

1

पर्ल 5 , 30 बाइट्स

के लिए शामिल +1है-p

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

इसे ऑनलाइन आज़माएं!

— टन हास्पेल
स्रोत

1

ब्रेकीलॉग , 6 बाइट्स

a₁=.l∈

इसे ऑनलाइन आज़माएं!

सफलता या असफलता के माध्यम से आउटपुट, जैसा कि लीकी नून की ब्रेकीलॉग v1 उत्तर करता है। एक समान दृष्टिकोण लेता है, साथ ही, लेकिन बहुत कम निकलता है।

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.

ब्रेकीलॉग , 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.

— असंबंधित स्ट्रिंग
स्रोत

0

रेटिना , 34 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

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

इनपुट पूर्णांक-पृथक-पूर्णांक की सूची है। प्रिंटों 0या 1।

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक परीक्षण सूट को सक्षम करती है, जहां प्रति पंक्ति एक अंतरिक्ष-अलग परीक्षण मामला है।)

एक वैकल्पिक विचार जो 35 बाइट और प्रिंट 0या एक सकारात्मक पूर्णांक पर समाप्त होता है :

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

— मार्टिन एंडर
स्रोत

0

Pyke, 7 बाइट्स

eQ>}lt!

यहाँ यह कोशिश करो!

— नीला
स्रोत

0

जावास्क्रिप्ट (ईएस 5), 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;
}

— पॉल शमित्ज़
स्रोत

0

ब्रेन-आलोचना 84 बाइट्स

यहां मुझे 100000000 ने हराया

यह ऑनलाइन की कोशिश करो!

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

पूर्णांक के सरणी के रूप में इनपुट लेता है।

आने की व्याख्या।

यहाँ एक 64 बाइट संस्करण है जो उत्तर का नहीं आउटपुट:

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

— गेहूं का जादूगर
स्रोत

PKCS # 7 पैडिंग सत्यापन

इनपुट

उत्पादन

परीक्षण के मामलों

पायथन, 47 34 33 बाइट्स

ब्रेकीलॉग , 14 बाइट्स

अजगर, 5 बाइट्स

जेली , 5 बाइट्स

यह काम किस प्रकार करता है

CJam, 9 8 बाइट्स

व्याख्या

05AB1E , 9 बाइट्स

MATL , 10 बाइट्स

व्याख्या

गणितज्ञ, 29 बाइट्स

हास्केल, 50 बाइट्स

जे, 13 बाइट्स

प्रयोग

व्याख्या

ब्रेन-फ्लैक , 54 बाइट्स

व्याख्या

बैच, 101 बाइट्स

हास्केल, 49 बाइट्स

Dyalog एपीएल , 10 बाइट्स

जावास्क्रिप्ट (ईएस 6), 51 47 41 बाइट्स

सी 91 बाइट्स

पर्ल 5 , 30 बाइट्स

ब्रेकीलॉग , 6 बाइट्स

ब्रेकीलॉग , 6 बाइट्स

रेटिना , 34 बाइट्स

Pyke, 7 बाइट्स

जावास्क्रिप्ट (ईएस 5), 89 बाइट्स

ब्रेन-आलोचना 84 बाइट्स