पासवर्ड बिशप अच्छाई

10

से लिया गया यह , अब नष्ट कर दिया, पोस्ट।

एक स्ट्रिंग, उत्तर (सत्य / मिथ्या या दो सुसंगत मूल्यों) को देखते हुए यदि यह एक अच्छा बिशप पासवर्ड बनाता है, जो तब होता है जब निम्नलिखित सभी शर्तें पूरी होती हैं:

  1. इसमें कम से कम 10 अक्षर हैं

  2. इसके कम से कम 3 अंक हैं ( [0-9])

  3. यह एक पलिंड्रोम नहीं है (उलट जाने पर खुद के समान)

यदि आपका कोड एक अच्छा बिशप पासवर्ड है तो आपको 0 बाइट्स बोनस मिलता है।

चेतावनी: क्या नहीं वास्तविक पासवर्ड शक्ति का एक उपाय के रूप में बिशप अच्छाई का उपयोग करें!

उदाहरण

अच्छा बिशप पासवर्ड

PPCG123GCPP
PPCG123PPCG
PPCG123gcpp
0123456789
Tr0ub4dor&3

अच्छा बिशप पासवर्ड नहीं

PPCG123 (बहुत छोटा)
correct horse battery staple (पर्याप्त अंक नहीं)
PPCG121GCPP (palindrome)
 (बहुत छोटा और पर्याप्त अंक नहीं)
abc121cba (बहुत छोटा और पैलिंड्रोम)
aaaaaaaaaaaa (palindrome और पर्याप्त अंक नहीं)
abc99cba (सब कुछ गलत)

code-golf  string  decision-problem  palindrome 
— एडम
स्रोत
@KrystosTheOverlord यह शब्द इस चुनौती में ही परिभाषित किया गया है। ; -पी
— एरिक आउटगॉल्फ
9
अजी, मैं कुछ शतरंज तर्क पासवर्ड नियमों की उम्मीद कर रहा था ...
— बर्गी
1
मैंने सभी उत्तरों को पढ़ा और बोनस का दावा नहीं किया।
— विस्कह
1
यदि आप इस वास्तविक बोनस के लिए अर्हता प्राप्त करते हैं, तो @JDL आपको वास्तव में आपके स्कोर से 0 बाइट्स को प्रतिस्थापित करने के लिए मिलता है! आप किस का इंतजार कर रहे हैं?
— आरोन
1
आपका एक मापदंड वास्तव में बिशप (2013) द्वारा प्रस्तावित के विपरीत है। उन्होंने प्रस्ताव दिया कि पासवर्ड 10 वर्ण या उससे कम होने चाहिए, अधिक नहीं।
— PyRulez

जवाबों:

5

अजगर २ , 61 59 54 51 बाइट्स

lambda s:sum(map(str.isdigit,s))>2<s[:9]<s<>s[::-1]

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

-5 बाइट्स, एरिक आउटग्लोफर के लिए धन्यवाद
-3 बाइट्स के लिए धन्यवाद, एक्सनॉर के लिए धन्यवाद

— TFeld
स्रोत
— अगस्त को आउटगॉल्फ
@EriktheOutgolfer धन्यवाद :)
— 15
आप लंबाई की जाँच वैसे भी कर सकते हैं s[:9]<s, जो नॉन- s[:9]<s!=s[::-1]
— पैलिंड्रोम
@ एक्सनॉर धन्यवाद :)
— TFeld
4

05AB1E , 12 बाइट्स

gT@Iþg3@IÂÊP

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

g      # Get the length of the (implicit) input
 T@    # Check if this length >= 10
Iþ     # Get the input and only leave the digits
  g    # Then get the length (amount of digits)
   3@  # And check if the amount of digits >= 3
IÂ     # Get the input and the input reversed
  Ê    # Check if they are not equal (so not a palindrome)
P      # Check if all three above are truthy (and output implicitly)
— केविन क्रूज़सेन
स्रोत
4

जाप , 17 14 बाइट्स

ʨA&U¦Ô&3§Uè\d

-3 बाइट्स @ शैग्य द्वारा पुनर्व्यवस्थित

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

Japt , 15 बाइट्स (0 बाइट्स बोनस: v)

ʨ10&U¦Ô&3§Uè\d

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत
1
डांग! अपने स्वयं के शुरू करने से पहले समाधान की जाँच करनी चाहिए! 14 बाइट्स
— झबरा
4

आर , 80 70 62 64 63 बाइट्स

any(rev(U<-utf8ToInt(scan(,'')))<U)&sum(U>47&U<58)>2&sum(U|1)>9

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

DigEmAll से, और कुछ पुन: व्यवस्थित भी

sum((s<-el(strsplit(scan(,''),"")))%in%0:9)>2&!all(s==rev(s))&s[10]>''

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

बहुत सीधा, कोई वास्तविक आश्चर्यजनक चाल यहाँ नहीं है। उपयोगकर्ता इनपुट स्ट्रिंग के बाद:

  • 2 से अधिक संख्याओं के लिए स्ट्रिंग को अलग करता है और खोजता है। (3 या अधिक अंक)
  • जाँचता है कि क्या सभी तत्व स्ट्रिंग के उलट संस्करण के समान नहीं हैं (palindrome)
  • जाँचता है कि लंबाई 9 (10 या अधिक वर्णों) से अधिक है
— Sumner18
स्रोत
मुझे लगता है कि आप की जगह ले सकता !all(s==rev(s))के साथ any(s!=rev(s))जो एक बाइट बचत होगी। मुझे लगता है कि लंबाई की जांच भी कम की जा सकती है, लेकिन यह निश्चित नहीं है कि (या तो ncharया किसी तरह का sum(x|1)हैक)
— JDL
1
वास्तव में, मुझे लगता है कि any(s>rev(s))यह काम करेगा --- यदि कोई चरित्र अपने पैलंड्रोमिक समकक्ष से कम है, तो पासवर्ड के दूसरे छोर पर ऐरो सच होगा। कि एक और बाइट बचाता है।
— JDL
2
— digEmAll
1
@digEmAll आपका उदाहरण सही है जब केवल एक ही संख्या होती है, तो आपको एक शामिल करने की आवश्यकता होगी>2
— हारून हैमन
1
— डाइजेक्सिल
3

एपीएल + विन, 36, 30 29 बाइट्स

7 बाइट्स ने Adám को धन्यवाद दिया

सूचकांक मूल = ०

इनपुट स्ट्रिंग के लिए संकेत

(10≤⍴v)×(3≤+/v∊∊⍕¨⍳10)>v≡⌽v←⎕

इसे ऑनलाइन आज़माएं! दरोगल क्लासिक के सौजन्य से

स्पष्टीकरण:

(10≤⍴v) Length test pass 1 fail 0

(3≤+/v∊∊⍕¨⍳10) Number of digits test

>v≡⌽v Palindrome test

कोड बोनस के लिए भी योग्य है क्योंकि यह एक अच्छा बिशप पासवर्ड है।

— ग्राहम
स्रोत
@ एडम। 6 बाइट बचाने के लिए धन्यवाद। OnIO पर सहमत हुए। vv ठीक काम करता है अगर मैं आगे बढ़ाता हूं ~। जैसा कि एक्स के उपयोग के लिए मैं इसका उपयोग तब करता हूं जब एक साथ बूलियन परीक्षण स्ट्रिंग करते हैं। समान परिणाम बाइट्स की संख्या।
— ग्राहम
क्या आपके पास है ≢जो ~… ≡? और अगर तुम नहीं, आप मर्ज कर सकते हैं ×~में>
— एडम
@ Adám नहीं, मेरे पास I नहीं है। मैं एक और बाइट के लिए × ~ में> विलय कर सकता हूं। धन्यवाद। मुझे डर है कि मेरे "पुटिंग गेम" को अभी भी अधिक अभ्यास की आवश्यकता है;)
— ग्राहम
3

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

सुझावों के लिए धन्यवाद, क्रॉपेब और घातक !

¬↔?l>9&ịˢl>2

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

व्याख्या

कार्यक्रम एक एकल विधेय है, जो दो भागों से मिलकर बना है &।

प्रथम:

¬       The following assertion must fail:
 ↔        The input reversed
  ?       can be unified with the input
        Also, the input's
   l    length
    >9  must be greater than 9

दूसरा:

 ˢ     Get all outputs from applying the following to each character in the input:
ị        Convert to number
       This gives an integer for a digit character and fails for a non-digit, so
       we now have a list containing one integer for each digit in the password
  l    Its length
   >2  must be greater than 2
— DLosc
स्रोत
{∋.∈Ị∧}ᶜहो सकता है{∋ị}ᶜ
— क्रोप्पे
— नॉट पैलिंड्रोम
@ क्रॉपेब ओह, दिलचस्प! मैंने विचार नहीं किया ị, लेकिन यह समझ में आता है कि यदि चरित्र एक अंक है तो यह सफल होगा। धन्यवाद!
— 19
@Fatalize अहा - इस ?तरह पुन: उपयोग करना साफ है। धन्यवाद!
— DLosc
2

जावा 8, 92 बाइट्स

s->s.length()>9&s.replaceAll("\\D","").length()>2&!s.contains(new StringBuffer(s).reverse())

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

स्पष्टीकरण:

s->                        // Method with String parameter and boolean return-type
  s.length()>9             //  Check if the length of the input-String is more than 9
  &s.replaceAll("\\D","")  //  AND: remove all non-digits from the input-String
    .length()>2            //       and check if the amount of digits is more than 2
  &!s.contains(new StringBuffer(s).reverse())
                           //  AND: check if the input-String does NOT have the reversed
                           //       input-String as substring (and thus is not a palindrome)
— केविन क्रूज़सेन
स्रोत
2

जावास्क्रिप्ट, 60 56 46 बाइट्स

वर्णों के एक सरणी के रूप में इनपुट लेता है। आउटपुट 1truthy के लिए और 0falsey के लिए।

s=>/(\d.*){3}/.test(s[9]&&s)&s+``!=s.reverse()

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

10 बाइट्स (!) को सहेज कर अरनौल को धन्यवाद दिया ।

— झबरा
स्रोत
2

एपीएल (Dyalog यूनिकोड) , 25 बाइट्स SBCS

{∧/(9<≢⍵)(3≤+/⍵∊⎕D),⍵≢⌽⍵}

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

— voidhawk
स्रोत
1
अच्छा। अब आप इसे एक ट्रेन में बनाकर इसे गोल्फ कर सकते हैं: (9<≢)∧(3≤1⊥∊∘⎕D)∧⊢≢⌽और फिर पार्न्स से बचने के लिए एक और बाइट को बचाकर इसे बचा सकते हैं: (9<≢)∧≢∘⌽⍨∧3≤1⊥∊∘⎕Dआइए जानते हैं कि क्या आपको इन चरणों के स्पष्टीकरण की आवश्यकता है।
— आदम
1

रेटिना 0.8.2 , 40 बाइट्स

G`.{10}
G`(\d.*){3}
+`^(.)(.*)\1$
$2
^..

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

G`.{10}

कम से कम 10 वर्णों की जाँच करता है।

G`(\d.*){3}

कम से कम 3 अंकों के लिए चेक।

+`^(.)(.*)\1$
$2

यदि वे मेल खाते हैं तो पहले और अंतिम चरित्र को हटा दें।

^..

यदि कम से कम 2 अक्षर हैं तो यह एक तालमेल नहीं था।

.NET के बैलेंसिंग समूहों का मतलब है कि यह एक नियमित अभिव्यक्ति में किया जा सकता है, लेकिन इसमें 47 बाइट्स लगते हैं:

^(?!(.)*.?(?<-1>\1)*$(?(1).))(?=.{10})(.*\d){3}

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं।

— नील
स्रोत
1

पायथन 3 , 74 72 64 बाइट्स

धन्यवाद नील ए -2 बाइट्स के लिए!
धन्यवाद जो किंग -8 बाइट्स के लिए! 

lambda s:s[9:]and re.findall('\d',s)[2:]and s[::-1]!=s
import re

स्पष्टीकरण:

lambda s: # Create lambda                                          
           s[9:] # Check if the string is at least 10 characters long                                 
                     and re.findall('\d',s)[2:] #Check for at least 3 matches of the regex \d (which matches all digits)
                     and s[::-1] != s # Check if the string reversed is equal to the string (palindrome test)
import re  # Import regex module

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

— epicness
स्रोत
— नील ए।
1

पर्ल 6 , 32 बाइट्स

{$_ ne.flip&&m:g/\d/>2&&.comb>9}

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

अनाम कोड ब्लॉक जो केवल लागू करता है कि सभी नियमों का अनुपालन किया जाता है।

स्पष्टीकरण:

{          &&         &&       }  # Anonymous code block
 $_ ne.flip                       # Input is not equal to its reverse
             m:g/\d/>2            # There are more than two digits
                        .comb>9   # There are more than 9 characters
— मजाक कर रहा है
स्रोत
1

के (ओके) , 31 28 बाइट्स

-3 बाइट्स ngn के लिए धन्यवाद!

{(x~|x)<(2<#x^x^/$!10)*9<#x}

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

— गैलेन इवानोव
स्रोत
1
आप +//(योग राशि तक) का उपयोग कर सकते हैं (योग +/+/राशि)
— ngn
1
वैकल्पिक रूप से, आप x^x^yदो सूचियों के बीच चौराहे को खोजने के लिए उपयोग कर सकते हैं #x^x^,/!10:। इसे छोटा किया जा सकता है #x^x^/!10( ^"बिना" के, x^/... ^x
— -प्रारंभिक
1
एक और बात, >(या <) का उपयोग "और नहीं" के रूप में किया जा सकता है:{(x~|x)<(2<#x^x^/$!10)*9<#x}
— ngn
@ng धन्यवाद! चौराहा खोजने का अच्छा तरीका!
— गेलन इवानोव
0

पिप , 19 बाइट्स

#a>9&XD Na>2&aNERVa

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले)

व्याख्या

aपहली कमांड-लाइन तर्क होने के साथ :

#a > 9      Length of a is greater than 9
&           and
XD N a > 2  Number of matches of regex [0-9] iN a is greater than 2
&           and
a NE RV a   a is not (string-)equal to reverse of a
— DLosc
स्रोत
0

पायथ, 17 बाइट्स

&&<2l@`MTQ<9lQ!_I

इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

&&<2l@`MTQ<9lQ!_IQ   Implicit: Q=eval(input()), T=10
                     Trailing Q inferred
      `MT            [0-10), as strings
     @   Q           Take characters from input which are in the above
    l                Length
  <2                 Is the above greater than 2?
            lQ       Length of Q
          <9         Is the above greater than 9?
               _IQ   Is Q unchanged after reversal?
              !      Logical NOT
&&                   Logical AND the three results together
— सोक
स्रोत
0

ग्रूवी, (47 बाइट्स)

{p->p=~/.{10}/&&p=~/(\d.*){3}/&&p!=p.reverse()}

(बोनस समावेश पाठक के लिए एक अभ्यास के रूप में छोड़ दिया जाता है)

— randomsimon
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.