परिचय

उपयोगकर्ता के पासवर्ड को चुराने से रोकने के लिए, एक निश्चित बैंक खाता प्रणाली ने निम्नलिखित सुरक्षा उपाय को लागू किया है: केवल कुछ अंकों को हर बार दर्ज करने के लिए संकेत दिया जाता है।

उदाहरण के लिए, मान लें कि आपका लक्ष्य पासवर्ड है 89097, सिस्टम उन्हें 2, 4 और 5 वां अंक दर्ज करने के लिए संकेत दे सकता है:

997

या यह उन्हें 1, 3 और 5 वां अंक दर्ज करने के लिए प्रेरित कर सकता है:

807

आप सभी जानते हैं कि आपका लक्ष्य क्रम में अंकों में प्रवेश कर गया है, लेकिन आपको नहीं पता कि वे वास्तविक पासवर्ड में किस पद पर हैं । आप सभी जानते हैं कि दो 9 हैं, जो 7 से पहले आने चाहिए; और वह 8 0 से पहले आता है, और 0 से पहले 7. इसलिए, छह संभावित पासवर्ड हैं:

आपके लक्ष्य के कंप्यूटर में कीलॉगर अब महीनों के लिए पासवर्ड इनपुट एकत्र कर रहा है, तो चलो हैक करें!

चुनौती

तीन अंकों के इनपुट की सूची को देखते हुए, सभी संभावित पासवर्ड को आउटपुट करें जो सभी इनपुट के लिए मान्य हैं। कम्प्यूटेशनल जटिलता को कम करने और संभावित परिणामों की मात्रा को कम रखने के लिए, पासवर्ड को संख्यात्मक होने की गारंटी है और 5 का निश्चित आकार है। प्रत्येक इनपुट में अंक क्रम में हैं: यदि यह 123 है, तो लक्ष्य 1 पहले टाइप किया गया था, फिर 2, फिर 3।

इनपुट / आउटपुट उदाहरण

|----------------------|--------------------------------------------|
|         Input        |                   Output                   |
|----------------------|--------------------------------------------|
| [320, 723, 730]      | [37230, 72320, 73203, 73230]               |
| [374, 842]           | [37842, 38742, 83742]                      |
| [010, 103, 301]      | [30103]                                    |
| [123, 124, 125, 235] | [12345, 12354, 12435]                      |
| [239, 944]           | [23944]                                    |
| [111, 120]           | [11201, 11120, 11210, 12011, 12110, 12101] |
| [456, 789]           | []                                         |
| [756, 586]           | [07586, 17586, 27586, 37586, 47586, 57586, 57856, 58756, 67586, 70586, 71586, 72586, 73586, 74586, 75086, 75186, 75286, 75386, 75486, 75586, 75686, 75786, 75806, 75816, 75826, 75836, 75846, 75856, 75860, 75861, 75862, 75863, 75864, 75865, 75866, 75867, 75868, 75869, 75876, 75886, 75896, 75986, 76586, 77586, 78586, 79586, 87586, 97586] |
| [123]                | [00123, 01023, 01123, 01203, 01213, 01223, 01230, 01231, 01232, 01233, 01234, 01235, 01236, 01237, 01238, 01239, 01243, 01253, 01263, 01273, 01283, 01293, 01323, 01423, 01523, 01623, 01723, 01823, 01923, 02123, 03123, 04123, 05123, 06123, 07123, 08123, 09123, 10023, 10123, 10203, 10213, 10223, 10230, 10231, 10232, 10233, 10234, 10235, 10236, 10237, 10238, 10239, 10243, 10253, 10263, 10273, 10283, 10293, 10323, 10423, 10523, 10623, 10723, 10823, 10923, 11023, 11123, 11203, 11213, 11223, 11230, 11231, 11232, 11233, 11234, 11235, 11236, 11237, 11238, 11239, 11243, 11253, 11263, 11273, 11283, 11293, 11323, 11423, 11523, 11623, 11723, 11823, 11923, 12003, 12013, 12023, 12030, 12031, 12032, 12033, 12034, 12035, 12036, 12037, 12038, 12039, 12043, 12053, 12063, 12073, 12083, 12093, 12103, 12113, 12123, 12130, 12131, 12132, 12133, 12134, 12135, 12136, 12137, 12138, 12139, 12143, 12153, 12163, 12173, 12183, 12193, 12203, 12213, 12223, 12230, 12231, 12232, 12233, 12234, 12235, 12236, 12237, 12238, 12239, 12243, 12253, 12263, 12273, 12283, 12293, 12300, 12301, 12302, 12303, 12304, 12305, 12306, 12307, 12308, 12309, 12310, 12311, 12312, 12313, 12314, 12315, 12316, 12317, 12318, 12319, 12320, 12321, 12322, 12323, 12324, 12325, 12326, 12327, 12328, 12329, 12330, 12331, 12332, 12333, 12334, 12335, 12336, 12337, 12338, 12339, 12340, 12341, 12342, 12343, 12344, 12345, 12346, 12347, 12348, 12349, 12350, 12351, 12352, 12353, 12354, 12355, 12356, 12357, 12358, 12359, 12360, 12361, 12362, 12363, 12364, 12365, 12366, 12367, 12368, 12369, 12370, 12371, 12372, 12373, 12374, 12375, 12376, 12377, 12378, 12379, 12380, 12381, 12382, 12383, 12384, 12385, 12386, 12387, 12388, 12389, 12390, 12391, 12392, 12393, 12394, 12395, 12396, 12397, 12398, 12399, 12403, 12413, 12423, 12430, 12431, 12432, 12433, 12434, 12435, 12436, 12437, 12438, 12439, 12443, 12453, 12463, 12473, 12483, 12493, 12503, 12513, 12523, 12530, 12531, 12532, 12533, 12534, 12535, 12536, 12537, 12538, 12539, 12543, 12553, 12563, 12573, 12583, 12593, 12603, 12613, 12623, 12630, 12631, 12632, 12633, 12634, 12635, 12636, 12637, 12638, 12639, 12643, 12653, 12663, 12673, 12683, 12693, 12703, 12713, 12723, 12730, 12731, 12732, 12733, 12734, 12735, 12736, 12737, 12738, 12739, 12743, 12753, 12763, 12773, 12783, 12793, 12803, 12813, 12823, 12830, 12831, 12832, 12833, 12834, 12835, 12836, 12837, 12838, 12839, 12843, 12853, 12863, 12873, 12883, 12893, 12903, 12913, 12923, 12930, 12931, 12932, 12933, 12934, 12935, 12936, 12937, 12938, 12939, 12943, 12953, 12963, 12973, 12983, 12993, 13023, 13123, 13203, 13213, 13223, 13230, 13231, 13232, 13233, 13234, 13235, 13236, 13237, 13238, 13239, 13243, 13253, 13263, 13273, 13283, 13293, 13323, 13423, 13523, 13623, 13723, 13823, 13923, 14023, 14123, 14203, 14213, 14223, 14230, 14231, 14232, 14233, 14234, 14235, 14236, 14237, 14238, 14239, 14243, 14253, 14263, 14273, 14283, 14293, 14323, 14423, 14523, 14623, 14723, 14823, 14923, 15023, 15123, 15203, 15213, 15223, 15230, 15231, 15232, 15233, 15234, 15235, 15236, 15237, 15238, 15239, 15243, 15253, 15263, 15273, 15283, 15293, 15323, 15423, 15523, 15623, 15723, 15823, 15923, 16023, 16123, 16203, 16213, 16223, 16230, 16231, 16232, 16233, 16234, 16235, 16236, 16237, 16238, 16239, 16243, 16253, 16263, 16273, 16283, 16293, 16323, 16423, 16523, 16623, 16723, 16823, 16923, 17023, 17123, 17203, 17213, 17223, 17230, 17231, 17232, 17233, 17234, 17235, 17236, 17237, 17238, 17239, 17243, 17253, 17263, 17273, 17283, 17293, 17323, 17423, 17523, 17623, 17723, 17823, 17923, 18023, 18123, 18203, 18213, 18223, 18230, 18231, 18232, 18233, 18234, 18235, 18236, 18237, 18238, 18239, 18243, 18253, 18263, 18273, 18283, 18293, 18323, 18423, 18523, 18623, 18723, 18823, 18923, 19023, 19123, 19203, 19213, 19223, 19230, 19231, 19232, 19233, 19234, 19235, 19236, 19237, 19238, 19239, 19243, 19253, 19263, 19273, 19283, 19293, 19323, 19423, 19523, 19623, 19723, 19823, 19923, 20123, 21023, 21123, 21203, 21213, 21223, 21230, 21231, 21232, 21233, 21234, 21235, 21236, 21237, 21238, 21239, 21243, 21253, 21263, 21273, 21283, 21293, 21323, 21423, 21523, 21623, 21723, 21823, 21923, 22123, 23123, 24123, 25123, 26123, 27123, 28123, 29123, 30123, 31023, 31123, 31203, 31213, 31223, 31230, 31231, 31232, 31233, 31234, 31235, 31236, 31237, 31238, 31239, 31243, 31253, 31263, 31273, 31283, 31293, 31323, 31423, 31523, 31623, 31723, 31823, 31923, 32123, 33123, 34123, 35123, 36123, 37123, 38123, 39123, 40123, 41023, 41123, 41203, 41213, 41223, 41230, 41231, 41232, 41233, 41234, 41235, 41236, 41237, 41238, 41239, 41243, 41253, 41263, 41273, 41283, 41293, 41323, 41423, 41523, 41623, 41723, 41823, 41923, 42123, 43123, 44123, 45123, 46123, 47123, 48123, 49123, 50123, 51023, 51123, 51203, 51213, 51223, 51230, 51231, 51232, 51233, 51234, 51235, 51236, 51237, 51238, 51239, 51243, 51253, 51263, 51273, 51283, 51293, 51323, 51423, 51523, 51623, 51723, 51823, 51923, 52123, 53123, 54123, 55123, 56123, 57123, 58123, 59123, 60123, 61023, 61123, 61203, 61213, 61223, 61230, 61231, 61232, 61233, 61234, 61235, 61236, 61237, 61238, 61239, 61243, 61253, 61263, 61273, 61283, 61293, 61323, 61423, 61523, 61623, 61723, 61823, 61923, 62123, 63123, 64123, 65123, 66123, 67123, 68123, 69123, 70123, 71023, 71123, 71203, 71213, 71223, 71230, 71231, 71232, 71233, 71234, 71235, 71236, 71237, 71238, 71239, 71243, 71253, 71263, 71273, 71283, 71293, 71323, 71423, 71523, 71623, 71723, 71823, 71923, 72123, 73123, 74123, 75123, 76123, 77123, 78123, 79123, 80123, 81023, 81123, 81203, 81213, 81223, 81230, 81231, 81232, 81233, 81234, 81235, 81236, 81237, 81238, 81239, 81243, 81253, 81263, 81273, 81283, 81293, 81323, 81423, 81523, 81623, 81723, 81823, 81923, 82123, 83123, 84123, 85123, 86123, 87123, 88123, 89123, 90123, 91023, 91123, 91203, 91213, 91223, 91230, 91231, 91232, 91233, 91234, 91235, 91236, 91237, 91238, 91239, 91243, 91253, 91263, 91273, 91283, 91293, 91323, 91423, 91523, 91623, 91723, 91823, 91923, 92123, 93123, 94123, 95123, 96123, 97123, 98123, 99123] |
|----------------------|--------------------------------------------|

नियम

इनपुट गैर-रिक्त की गारंटी है।
शून्य राशि का प्रमुख और अनुगामी: 01234से भिन्न होता है 12340, और 1234पासवर्ड को क्रैक नहीं करता है। सोचें कि असली पासवर्ड कैसे काम करते हैं!
मानक I / O नियम लागू होते हैं।
कोई मानक खामियां नहीं हैं ।
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है। गैर-कोडिंग वाली भाषाओं का स्वागत है!

code-golf

— cefel
स्रोत

5

क्या अंक हमेशा क्रम में होते हैं? परीक्षण के मामलों के आधार पर, मुझे लगता है कि वे हैं, लेकिन मैं इसे नियमों में उल्लिखित नहीं देख सकता था जब तक कि मैं इसे पिछले नहीं पढ़ता।

— केविन क्रूज़सेन

13

PPCG में आपका स्वागत है! यह एक अच्छी, संरचित और बड़े करीने से तैयार पहली चुनौती है। आपने स्पष्ट रूप से अपना होमवर्क किया है जहां तक कि सभी नीचे हो रहे हैं। मैं इसका उत्तर देने के लिए उत्सुक हूं (यदि कोई इसका उत्तर आर में पहले नहीं देता है!)। भविष्य में, हम मुख्य पोस्ट करने से पहले प्रतिक्रिया प्राप्त करने के लिए सैंडबॉक्स का उपयोग करने का सुझाव देते हैं । आशा है कि आप PPCG पर अपना समय आनंद लेंगे!

— ग्यूसेप

1

@Giuseppe धन्यवाद! मैं वर्षों से इस साइट पर प्रश्नों को गुमनाम रूप से पढ़ रहा हूं, और मैं कुछ महीनों से इस विशिष्ट समस्या को हल कर रहा हूं और लिख रहा हूं: मुझे सैंडबॉक्स को छोड़ना काफी पसंद है। मैं पहली बार वहाँ पोस्ट करेंगे!

— cefel

2

@ अर्नुलड, यदि आपका पासवर्ड 01234 या 12340 है, तो आप 1234 लिखकर लॉग इन नहीं कर सकते हैं। पासवर्ड संख्या की तुलना में अधिक संख्या में स्ट्रिंग होते हैं, भले ही संख्याओं से बना हो, कम से कम उस अर्थ में। तो हां, अग्रणी और अनुगामी शून्य अनिवार्य हैं।

— सेफ़ेल

2

अंतिम परीक्षा का मामला 22123 से गायब प्रतीत होता है ... जब तक मैं कुछ गलत नहीं समझ रहा हूँ?

— जोनाह

24

पायथन, 100 बाइट्स

lambda e,d='%05d':[d%i for i in range(10**5)if all(re.search('.*'.join(x),d%i)for x in e)]
import re

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

पायथन 2 में और साथ ही पायथन 3 में काम करता है।

( पायथन 3.8 में 97 बाइट्स :)

lambda e:[p for i in range(10**5)if all(re.search('.*'.join(x),p:='%05d'%i)for x in e)]
import re

— लिन
स्रोत

1

यह एक प्यारा उपाय है ...

— योना

1

आपका गैर-3.8 कोड स्ट्रिंग को अलियास करने की "गरीब-आदमी की असाइनमेंट अभिव्यक्ति" कर सकता है '%05d'।

— xnor

22

05AB1E , 11 9 बाइट्स

žh5ãʒæIåP

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

व्याख्या

žh          # push 0123456789
  5ã        # 5 times cartesian product
    ʒ       # filter, keep only values are true under:
     æ      # powerset of value
      Iå    # check if each of the input values are in this list
        P   # product

— Emigna
स्रोत

12

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

के साथ परिणाम प्रिंट करता है alert()।

a=>{for(k=n=1e5;n--;)a.every(x=>(s=([k]+n).slice(-5)).match([...x].join`.*`))&&alert(s)}

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

टिप्पणी की गई

a => {                    // a[] = input array of 3-character strings
  for(k = n = 1e5; n--;)  // initialize k to 100000; for n = 99999 to 0:
    a.every(x =>          // for each string x = 'XYZ' in a[]:
      ( s =               //   define s as the concatenation of
          ([k] + n)       //   '100000' and n; e.g. '100000' + 1337 -> '1000001337'
          .slice(-5)      //   keep the last 5 digits; e.g. '01337'
      ).match(            //   test whether this string is matching
        [...x].join`.*`   //   the pattern /X.*Y.*Z/
      )                   //
    ) &&                  // end of every(); if all tests were successful:
      alert(s)            //   output s
}                         //

— Arnauld
स्रोत

8

हास्केल, 81 80 78 76 बाइट्स

f x=[p|p<-mapM(:['1'..'9'])"00000",all(`elem`(concat.words<$>mapM(:" ")p))x]

हास्केल में स्पष्ट जानवर बल दृष्टिकोण: सभी संभव पासवर्डों की एक सूची बनाई गई और उन लोगों को रखें जहां इनपुट सूची से सभी तत्व बाद की सूची में संबंधित हैं।

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

संपादित करें: -1x बाइट @xnor के लिए, -2 -4 बाइट्स @ H.PWiz के लिए धन्यवाद

— nimi
स्रोत

1

लगता है कि आप सबसेक्श को अपने से थोड़ा छोटा कर सकते हैं।

— xnor

1

concat.words<$>mapM(:" ")pछोटा है

— H.PWiz

3

p<-mapM(:['1'..'9'])"00000"2 बाइट्स बचाने के लिए उपयोग करें

— H.PWiz

5

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

9Żṗ5ŒPiⱮẠɗƇ

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

— आउटगोल्फर को एरिक करें
स्रोत

5

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

f<QyT^s`MT5

तार के एक सेट के रूप में इनपुट लेता है।
इसे यहाँ आज़माएँ

व्याख्या

f<QyT^s`MT5
      s`MT      Take the digits as a string.
     ^    5     Take the Cartesian product with itself 5 times.
f   T           Filter the ones...
 <Qy            ... where the input is a subset of the power set.

— स्मृति सहायक
स्रोत

5

रूबी , 54 बाइट्स

->a{(?0*5..?9*5).select{|x|a.all?{|y|x=~/#{y*'.*'}/}}}

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

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

— किरिल एल।
स्रोत

बहुत बढ़िया! आपने मुझे 25 बाइट्स से हराया। क्या मुझे अपना उत्तर हटा देना चाहिए?

— एरिक डुमिनील

1

नहीं, जब तक आपके पास एक मान्य उत्तर है, तब तक इसे हटाने की कोई आवश्यकता नहीं है।

— किरिल एल।

5

पायथन 3 , 98 बाइट्स

f=lambda l,s='':any(l)or print(s)if s[4:]else[f([x[x[:1]==c:]for x in l],s+c)for c in'0123456789']

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

sफिर से lहिट होने के लिए अभी भी शेष में नज़र रखने के लिए, हर पाँच-अंकीय संख्या स्ट्रिंग के निर्माण की कोशिश करता है । यदि सभी अंत तक खाली हैं, तो परिणाम प्रिंट करता है।

पायथन 3.8 (पूर्व-रिलीज़) , 94 बाइट्स

lambda l:[s for n in range(10**5)if all(''in[x:=x[x[:1]==c:]for c in(s:='%05d'%n)]for x in l)]

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

असाइनमेंट एक्सप्रेशन की शक्ति को निहारें ! परवर्ती जाँच के लिए यहाँ से विधि का उपयोग करता है ।

— XNOR
स्रोत

4

पर्ल 5 `-a` , 80 बाइट्स

map{s||($t=0)x(5-y///c)|e;for$b(map s//.*/gr,@F){/$b/&&$t++}$t==@F&&say}0..99999

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

— Xcali
स्रोत

1

$t+=/$b/इसके बजाय/$b/&&$t++

— नहुएल फौलीउल

4

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

~(`
.$*
m`^
G`
^
K`¶5+%`$$¶0"1"2"3"4"5"6"7"8"9¶
"
$$"

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

~(`

स्क्रिप्ट निष्पादित करने के बाद, परिणाम को एक नई स्क्रिप्ट के रूप में लें, और उस पर भी अमल करें।

.$*

.*हर जगह डालें । इसका परिणाम यह है कि .*3.*2.*0.*हालांकि हमें केवल इसकी आवश्यकता है 3.*2.*0, न कि यह मायने रखता है।

m`^
G`

G`प्रत्येक पंक्ति के शुरू में डालें । यह इसे रेटिना ग्रीप कमांड में बदल देता है।

^
K`¶5+%`$$¶0"1"2"3"4"5"6"7"8"9¶
"
$$"

दो अधिक रेटिना आदेश उपसर्ग। परिणामी स्क्रिप्ट इस प्रकार दिखाई देगी:

K`

बफ़र साफ़ करें (जिसमें मूल इनपुट शामिल है)।

5+

5 बार दोहराएं ...

%`$

... प्रत्येक पंक्ति में संलग्न ...

0$"1$"2$"3$"4$"5$"6$"7$"8$"9

... अंक 0, फिर रेखा की एक प्रति, फिर अंक 1, आदि 9। इसका मतलब है कि nलूप्स के बाद आपके पास सभी n-digit नंबर होंगे।

G`.*3.*2.*0.*
G`.*7.*2.*3.*
G`.*7.*3.*0.*

इनपुट के आधार पर संभावित संख्याओं को फ़िल्टर करें।

— नील
स्रोत

4

आर , 80 82 बाइट्स

Reduce(intersect,lapply(gsub("",".*",scan(,"")),grep,sprintf("%05d",0:99999),v=T))

यहाँ रेगेक्स का उपयोग करके एक आधार आर समाधान है। कार्यों के इस नेस्टेड श्रृंखला को लिखने से मुझे एहसास हुआ कि मैंने मैग्रीट पैकेज की सराहना करना कितना सीखा है!

शुरू में इनपुट पर नियम नहीं पढ़े थे, इसलिए अब स्टडिन से लिखा गया है (धन्यवाद @KirillL)।

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

— निक केनेडी
स्रोत

@digEmAll यह कहता है कि यह 82 बाइट्स है ना? इनपुट में अग्रणी शून्य के लिए संभावित के कारण आप पूर्णांक का उपयोग नहीं कर सकते।

— निक कैनेडी

क्षमा करें, मैंने शीर्षक पढ़ा और अनजाने में मैंने यह देखते हुए बिना न्यूनतम संख्या को चुना कि यह स्ट्राइकड्रिथ था ... और हाँ, क्षमा करें फिर से आप स्ट्रिंग इनपुट के बारे में सही हैं;)

— डाइजेक्सिल

2

रूबी , 79 77 बाइट्स

->x{(0...1e5).map{|i|'%05d'%i}.select{|i|x.all?{|c|i=~/#{c.gsub('','.*')}/}}}

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

इनपुट स्ट्रिंग्स की एक सरणी है।

यहाँ एक ही कोड का अधिक पठनीय संस्करण है:

def f(codes)
  (0...10**5).map{|i| '%05d'%i}.select do |i|
    codes.all? do |code|
      i =~ Regexp.new(code.chars.join('.*'))
    end
  end
end

— एरिक डुमिनील
स्रोत

BTW, आपके दृष्टिकोण को चार सरणी इनपुट में स्विच करके भी छोटा किया जा सकता है, जैसा कि मेरे संस्करण में है, और -2 अधिक बाइट्स 1e5जैसे कि ऊपरी मान को स्वरूपित करके , इस

— किरिल एल

@KirillL। -2 बाइट्स के लिए धन्यवाद। मैं इनपुट प्रारूप को नहीं बदलूंगा क्योंकि मेरा उत्तर आपके जैसा ही होगा। चीयर्स!

— एरिक डुमिनील

2

PHP 128 बाइट्स

for(;$i++<1e5;$k>$argc||print$s)for($k=0;$n=$argv[++$k];)preg_match("/$n[0].*$n[1].*$n[2]/",$s=sprintf("%05d
",$i-1))||$k=$argc;

या

for(;$i<1e5;$i+=$k<$argc||print$s)for($k=0;$n=$argv[++$k];)if(!preg_match("/$n[0].*$n[1].*$n[2]/",$s=sprintf("%05d
",$i)))break;

कमांड लाइन तर्कों से इनपुट लें। ऑनलाइन चलाएं -nrया उन्हें आज़माएं ।

— टाइटस
स्रोत

2

जे , 52 बाइट्स

(>,{;^:4~i.10)([#~]*/@e."2((#~3=+/"1)#:i.32)#"_ 1[)]

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

— जोनाह
स्रोत

2

जाप, 21 बाइट्स

1e5o ù'0 f@e_XèZË+".*

कोशिश करो!

1e5o ù'0 f@e_XèZË+".*    # full program

1e5o                     # generate numbers under 100k
     ù'0                 # left pad with 0's
         f@              # filter array
           e_            # check every element of input array
             Xè          # X is the number to be tested.
                         # test it against a regex.
               ZË+".*    # the regex is an element from the input array
                         # with wildcards injected between each character

-2 बाइट्स @ शुग्गी को धन्यवाद!

— दाना
स्रोत

कम बेकार चर:: 1e5o ù'0 fA{Ue@AèX®+".*पी

— एएससीआईआई-केवल

यह भी 23:1e5o ù'0 fA{Ue@AèX¬q".*

— ASCII- केवल

21 बाइट्स

— झबरा

दिलचस्प है ... मुझे नहीं पता था return X,Y,Zकि आखिरी कार्यकाल होगा। युक्तियों के लिए धन्यवाद :)

— दान

1

@dana; हाँ, यह जावास्क्रिप्ट की एक विशेषता है: tio.run/##00SSxxsosKNHNy09J/Z9m@1@jQqdS09auuii1pLQoKwHIq/…

— झबरा

2

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 116 बाइट्स

x=>{for(int i=0;i<1e5;){var s=$"{i++:D5}";if(x.All(t=>t.Aggregate(-6,(a,c)=>s.IndexOf(c,a<0?a+6:a+1))>0))Print(s);}}

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

// x: input list of strings
x=>{
  // generate all numbers under 100k
  for(int i=0;i<1e5;){
    // convert the current number to
    // a 5 digit string padded with 0's
    var s=$"{i++:D5}";
    // test all inputs against the 5 digit
    // string using an aggregate.
    // each step of the aggregate gets
    // the index of the next occurrence
    // of the current character starting
    // at the previously found character.
    // a negative index indicates error.
    if(x.All(t=>t
             .Aggregate(-6,(a,c)=>
               s.IndexOf(c,a<0?a+6:a+1)
             )>0))
      // output to STDOUT
      Print(s);
  }
}

EDIT: एक बग तय किया जहां एक ही चरित्र को एक से अधिक बार गिना गया। उदाहरण के लिए, यदि 000लॉग किया गया था, तो फ़ंक्शन एकल वाले सभी पासवर्ड वापस करने के लिए उपयोग किया गया था 0।

— दाना
स्रोत

1

क्लीन , 113 बाइट्स

import StdEnv,Data.List
$l=[s\\s<-iter 5(\p=[[c:e]\\e<-p,c<-['0'..'9']])[[]]|all(flip any(subsequences s)o(==))l]

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

— Οurous
स्रोत

1

के 67 बाइट्स

{n@&{&/y in\:x@/:&:'a@&3=+/'a:(5#2)\:'!32}[;x]'n:{"0"^-5$$x}'!_1e5}

K में एक (बहुत) आदिम रेगेक्स क्षमता है, इसलिए मैंने एक अलग दृष्टिकोण की कोशिश की।

{...} एक मेमने को परिभाषित करता है। उदाहरण का उपयोग करें:{...}("320";"723";"730")

रिटर्न ("37230";"72320";"73203";"73230")

n 0-गद्देदार तारों के रूप में 0..9999 में पूर्णांकों की सूची है
- _1e5 फर्श पर लागू होता है 1e5 (वैज्ञानिक संकेतन) -> पूर्णांक 100000 उत्पन्न करता है
- !_1e5 पूर्णांक-सूची 0..99999 उत्पन्न करता है
- {..}'!_1e5 0.99999 में प्रत्येक मूल्य पर लैम्ब्डा लागू करता है
- $x तर्कों के लिए तर्क x (निहित अर्थ) बदलना
- -5$$x5 स्ट्रिंग $ x को आकार 5 के क्षेत्र में समायोजित करें (उदा। -5$$12उत्पन्न करता है" 12"
- "0"^string"0" चार के साथ रिक्त स्थान को बदलता है, इसलिए "0"^-5$$12उत्पन्न होता है"00012"
a 5-बिट मान के रूप में 0..31 रेंज में पूर्णांकों की सूची है
- !32 मान उत्पन्न करें 0..31
- (5#2) 2 5 बार दोहराएं (सूची 2 2 2 2 2)
- (5#2)\:'!32 ५.३१ के रेंज में प्रत्येक मूल्य के लिए ५-बिट मान (२-बेस पांच-बार) उत्पन्न करता है
हम ठीक 3 लोगों के साथ फ़िल्टर करते हैं। वे मान सभी संयोजन (स्थान) हैं जहां पैटर्न स्थित हो सकते हैं 11100 11010 11001 10110 10101 10011 01110 01101 01011 00111:। पूर्व। "एबीसी" पैटर्न के लिए हमारे पास रेगेक्स के साथ समानता हैabc?? ab?c? ab??c a?bc? a?b?c a??bc ?abc? ?ab?c ?a?bc ??abc?
- +\'a प्रत्येक बाइनरी प्रतिनिधित्व की राशि की गणना करता है (लोगों की संख्या)
- 3=+\'a बूलियन्स की सूची उत्पन्न करता है (यदि प्रत्येक मान 3 लोगों में है)
- a@&3=+\'a "जहां पर 3 = + \ 'एक सत्य है" के रूप में पढ़ता है
पिछले स्थानों के लिए अनुक्रमणिका की सूची बनाएं: (0 1 2; 0 1 3; 0 1 4; 0 2 3; 0 2 4; 0 3 4; 1 2 3; 1 2 4; 1 3 4; 2 3 4)और पासवर्ड के लिए संभव दर्ज किए गए मान (x)
- &:' "जहां प्रत्येक" के रूप में पढ़ता है, बाइनरी-कोडेड पूर्णांकों की सूची पर लागू होता है, और प्रत्येक 1-बिट के अनुक्रमित की गणना करता है
- x@/: अनुक्रमणिका की सूची के प्रत्येक एलएम पर पासवर्ड x लागू करता है (सभी संभव दर्ज किए गए मान उत्पन्न करता है)
निर्धारित करता है कि क्या सभी पैटर्न सभी संभावित प्रवेश मूल्यों की सूची में स्थित हैं
- y वह आर्ग है जो प्रतिमानों की सूची का प्रतिनिधित्व करता है
- y in\: दाईं ओर सूची में y के प्रत्येक मान के रूप में पढ़ता है
- &/"और ओवर" है। &/y in\:..सही है अगर y में सभी पैटर्न सूची में रेखांकित हैं ..
अंत में, प्रत्येक स्ट्रिंग को n में हर सूचकांक पर लौटाएं जो लंबोदर को सच बनाता है
- n@&{..} के रूप में पढ़ता है "जहां पर lambda {..} सच है"

— जे सेंदरा
स्रोत

0

सी (जीसीसी) 222 बाइट्स

#define C(p)*f-p?:++f;
#define I(x,y)x<10?:++y,x%=10;
a,b,c,d,e;f(int**H){for(;a<10;){int**h=H,*f,g=0;for(h=H;*h;){f=*h;C(a)C(b)C(c)C(d)C(e)f>*h+++2?:(g=1);}g?:printf("%d%d%d%d%d,",a,b,c,d,e);++e;I(e,d)I(d,c)I(c,b)I(b,a)}}

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

कॉलिंग कोड

int main() {
  int hint1[5] = {9,9,7,-1,-1};
  int hint2[5] = {8,0,7,-1,-1};
  int* hints[3] = {hint1,hint2,0};
  f(hints);
}

उत्पादन

80997,89097,89907,98097,98907,99807,

— rtpax
स्रोत

214 बाइट्स

— सीलिंगकैट

बैंक अकाउंट का पासवर्ड क्रैक करें!

परिचय

चुनौती

इनपुट / आउटपुट उदाहरण

नियम

पायथन, 100 बाइट्स

05AB1E , 11 9 बाइट्स

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

टिप्पणी की गई

हास्केल, 81 80 78 76 बाइट्स

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

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

व्याख्या

रूबी , 54 बाइट्स

पायथन 3 , 98 बाइट्स

पायथन 3.8 (पूर्व-रिलीज़) , 94 बाइट्स

पर्ल 5 -a , 80 बाइट्स

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

आर , 80 82 बाइट्स

रूबी , 79 77 बाइट्स

PHP 128 बाइट्स

जे , 52 बाइट्स

जाप, 21 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 116 बाइट्स

क्लीन , 113 बाइट्स

के 67 बाइट्स

सी (जीसीसी) 222 बाइट्स

पर्ल 5 `-a` , 80 बाइट्स