Giới thiệu

Để ngăn chặn các keylogger đánh cắp mật khẩu của người dùng, một hệ thống tài khoản ngân hàng nhất định đã thực hiện biện pháp bảo mật sau: chỉ một số chữ số nhất định được nhắc nhập mỗi lần.

Ví dụ: giả sử mật khẩu của mục tiêu của bạn là 89097, hệ thống có thể nhắc họ nhập chữ số thứ 2, 4 và 5:

997

Hoặc nó có thể nhắc họ nhập chữ số 1, 3 và 5:

807

Tất cả những gì bạn biết là mục tiêu của bạn đã nhập các chữ số theo thứ tự, nhưng bạn không biết vị trí của chúng trong mật khẩu thực tế . Tất cả những gì bạn biết là có hai số 9, phải đến trước 7; và 8 đến trước 0 và 0 trước 7. Do đó, có sáu mật khẩu có thể:

80997
89097
89907
98097
98907
99807

Keylogger trong máy tính của mục tiêu của bạn đã thu thập mật khẩu đầu vào trong nhiều tháng nay, vì vậy hãy tham gia!

Thử thách

Đưa ra một danh sách các đầu vào ba chữ số, xuất ra tất cả các mật khẩu có thể hợp lệ cho tất cả các đầu vào. Để giảm độ phức tạp tính toán và giữ cho số lượng kết quả có thể thấp, mật khẩu được đảm bảo là số và có kích thước cố định là 5. Các chữ số trong mỗi đầu vào theo thứ tự: nếu là 123, mục tiêu được nhập 1 trước, rồi 2, rồi 3.

Ví dụ đầu vào / đầu ra

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

Quy tắc

• Đầu vào được đảm bảo không trống.
• Vấn đề số 0 đứng đầu và dấu vết: 01234khác với 12340và 1234không bẻ khóa mật khẩu. Hãy nghĩ về cách mật khẩu thực sự hoạt động!
• Quy tắc I / O tiêu chuẩn được áp dụng.
• Không có sơ hở tiêu chuẩn .
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng. Ngôn ngữ không mã hóa được chào đón!

Python, 100 byte

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

Hãy thử trực tuyến!

Hoạt động trong Python 2 cũng như Python 3.

( 97 byte trong Python 3.8 :)

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

05AB1E , 11 9 byte

žh5ãʒæIåP

Hãy thử trực tuyến!

Giải trình

ž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

JavaScript (ES6), 88 byte

In kết quả với alert().

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

Hãy thử trực tuyến!

Đã bình luận

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

Haskell, 81 80 78 76 byte

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

Cách tiếp cận vũ phu rõ ràng trong Haskell: xây dựng một danh sách tất cả các mật khẩu có thể và giữ những mật khẩu mà tất cả các yếu tố trong danh sách đầu vào nằm trong danh sách các chuỗi con tương ứng.

Hãy thử trực tuyến!

Chỉnh sửa: -1 byte nhờ @xnor, -2 -4 byte nhờ @ H.PWiz

Thạch , 11 byte

9Żṗ5ŒPiⱮẠɗƇ

Hãy thử trực tuyến!

Bình thường, 11 byte

f<QyT^s`MT5

Đưa đầu vào dưới dạng một chuỗi các chuỗi.
Hãy thử nó ở đây

Giải trình

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.

Ruby , 54 byte

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

Hãy thử trực tuyến!

Đưa đầu vào như một mảng của các mảng ký tự.

Python 3 , 98 byte

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

Hãy thử trực tuyến!

Đệ quy cố gắng xây dựng mỗi chuỗi số gồm năm chữ số s, theo dõi các chuỗi con lvẫn còn bị tấn công. Nếu tất cả đều trống vào cuối, in kết quả.

Python 3.8 (tiền phát hành) , 94 byte

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

Hãy thử trực tuyến!

Kìa sức mạnh của biểu thức chuyển nhượng ! Sử dụng phương pháp từ đây để kiểm tra các phần tiếp theo.

Perl 5 -a , 80 byte

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

Hãy thử trực tuyến!

Võng mạc , 53 byte

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

Hãy thử trực tuyến! Giải trình:

~(`

Sau khi thực thi tập lệnh, hãy lấy kết quả làm tập lệnh mới và cũng thực hiện tập lệnh đó.

.$*

Chèn .*khắp nơi. Điều này dẫn đến .*3.*2.*0.*mặc dù chúng tôi chỉ cần 3.*2.*0, không quan trọng.

m`^
G`

Chèn một G`ở đầu mỗi dòng. Điều này biến nó thành một lệnh Retina Grep.

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

Tiền tố thêm hai lệnh Retina. Do đó, kịch bản kết quả sẽ trông giống như thế này:

K`

Xóa bộ đệm (chứa đầu vào ban đầu).

5+

Lặp lại 5 lần ...

%`$

... nối vào từng dòng ...

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

... chữ số 0, sau đó là bản sao của dòng, rồi chữ số 1, v.v. cho đến khi 9. Điều này có nghĩa là sau ncác vòng lặp, bạn sẽ có tất cả các nsố-chữ số.

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

Lọc các số có thể dựa trên đầu vào.

R , 80 82 byte

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

Đây là một giải pháp cơ sở R sử dụng regex. Viết chuỗi các hàm lồng nhau này khiến tôi nhận ra mình đã học được bao nhiêu để đánh giá cao gói magrittr!

Ban đầu không đọc quy tắc về đầu vào, vì vậy bây giờ đọc từ stdin (cảm ơn @KirillL).

Hãy thử trực tuyến!

Ruby , 79 77 byte

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

Hãy thử trực tuyến!

Đầu vào là một chuỗi các chuỗi.

Đây là phiên bản dễ đọc hơn của cùng một mã:

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

PHP 128 byte

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;

hoặc là

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;

lấy đầu vào từ các đối số dòng lệnh. Chạy với -nrhoặc thử chúng trực tuyến .

J , 52 byte

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

Hãy thử trực tuyến!

Japt, 21 byte

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

Thử nó!

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 byte nhờ @Shaggy!

C # (Trình biên dịch tương tác Visual C #) , 116 byte

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

Hãy thử trực tuyến!

// 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: đã sửa một lỗi trong đó cùng một ký tự được tính nhiều lần. Ví dụ: nếu 000được ghi lại, hàm được sử dụng để trả về tất cả mật khẩu chứa một mật khẩu 0.

Sạch , 113 byte

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

Hãy thử trực tuyến!

K 67 byte

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

K có một khả năng regex nguyên thủy (rất), vì vậy tôi đã thử một cách tiếp cận khác.

{...} định nghĩa lambda. Sử dụng ví dụ:{...}("320";"723";"730")

trả lại ("37230";"72320";"73203";"73230")

• n là danh sách các số nguyên trong phạm vi 0..9999 dưới dạng chuỗi 0 đệm

  • _1e5 áp dụng sàn cho float 1e5 (ký hiệu khoa học) -> tạo số nguyên 100000

  • !_1e5 tạo danh sách số nguyên 0..99999

  • {..}'!_1e5 áp dụng lambda cho mỗi giá trị trong 0..99999

  • $x chuyển đổi đối số x (ẩn arg) thành chuỗi

  • -5$$xphải điều chỉnh chuỗi $ x sang trường có kích thước 5 (ví dụ: -5$$12tạo" 12"

  • "0"^stringthay thế khoảng trống bằng char "0", do đó "0"^-5$$12tạo ra"00012"

• a là danh sách các số nguyên trong phạm vi 0..31 dưới dạng giá trị 5 bit

  • !32 tạo các giá trị 0..31

  • (5#2) lặp lại 2 năm lần (danh sách 2 2 2 2 2)

  • (5#2)\:'!32 tạo các giá trị 5 bit (2 cơ sở năm lần) cho mỗi giá trị trong phạm vi 0..31

• chúng tôi lọc các giá trị của a với chính xác 3 cái. Các giá trị đó là tất cả các kết hợp (địa điểm) trong đó mẫu có thể được đặt : 11100 11010 11001 10110 10101 10011 01110 01101 01011 00111. Ví dụ. đối với mẫu "abc", chúng ta có sự tương đương với biểu thức chính quyabc?? ab?c? ab??c a?bc? a?b?c a??bc ?abc? ?ab?c ?a?bc ??abc?

  • +\'a tính tổng của mỗi biểu diễn nhị phân (số lượng)

  • 3=+\'a tạo danh sách booleans (nếu mỗi giá trị trong a có chính xác 3 cái)

  • a@&3=+\'a đọc là "a tại đó 3 = + \ 'a là đúng"

• tạo danh sách các chỉ mục cho các vị trí trước đó: (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)và các giá trị nhập có thể có cho mật khẩu (x)

  • &:' đọc là "nơi mỗi", áp dụng cho danh sách các số nguyên được mã hóa nhị phân và tính toán các chỉ số của mỗi 1 bit

  • x@/: áp dụng mật khẩu x cho mỗi elem của danh sách các chỉ mục (tạo ra tất cả các giá trị được nhập có thể)

• Xác định xem tất cả các mẫu được đặt trong danh sách tất cả các giá trị được nhập có thể

  • y là đối số đại diện cho danh sách các mẫu

  • y in\: đọc theo từng giá trị của y trong danh sách bên phải

  • &/là "và hơn". &/y in\:..trả về đúng iff tất cả các mẫu trong y được định vị trong danh sách ..

• cuối cùng, trả về mỗi chuỗi trong n ở mọi chỉ số làm cho lambda đúng

  • n@&{..} đọc là "n tại nơi lambda {..} trả về true"

C (GCC) 222 byte

#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)}}

Dùng thử trực tuyến

Mã gọi

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

Đầu ra

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