소개

키로거가 사용자의 비밀번호를 도용하지 못하도록 특정 은행 계좌 시스템은 다음과 같은 보안 조치를 구현했습니다. 매번 특정 숫자 만 입력하라는 메시지가 표시됩니다.

예를 들어, 대상의 비밀번호가이라고 가정 89097하면 시스템은 2, 4, 5 번째 숫자를 입력하라는 메시지를 표시 할 수 있습니다.

997

또는 1, 3, 5 번째 숫자를 입력하라는 메시지가 표시 될 수 있습니다.

807

대상이 숫자를 순서대로 입력했다는 것만 알지만 실제 암호에서 해당 위치가 속한 위치는 알 수 없습니다 . 아시다시피, 두 개의 9가 있으며, 7 이전에 와야합니다. 8은 0 앞에, 0은 7 앞에옵니다. 따라서 여섯 가지 가능한 암호가 있습니다.

80997
89097
89907
98097
98907
99807

대상 컴퓨터의 키로거가 몇 달 동안 암호 입력을 수집 해 왔으므로 해킹하자!

도전

3 자리 입력 목록이 제공되면 모든 입력에 유효한 가능한 모든 암호를 출력하십시오. 계산 복잡성을 줄이고 가능한 결과의 양을 줄이려면 암호의 숫자와 고정 크기가 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] |
|----------------------|--------------------------------------------|

규칙

• 비어 있지 않은 입력이 보장됩니다.
• 선행 및 문제에 0을 후행하는 것은 : 01234다른 12340, 그리고 1234하나의 암호를 해독하지 않습니다. 실제 암호가 어떻게 작동하는지 생각해보십시오!
• 표준 I / O 규칙이 적용됩니다.
• 표준 허점이 없습니다 .
• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다. 비 골프 언어는 환영합니다!

파이썬, 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

온라인으로 사용해보십시오!

Python 3과 Python 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

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

자바 스크립트 (ES6), 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
}                         //

하스켈, 81 80 78 76 바이트

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

Haskell의 명백한 무차별 접근 방식 : 가능한 모든 암호 목록을 작성하고 입력 목록의 모든 요소가 각각의 하위 시퀀스 목록에있는 암호를 유지하십시오.

온라인으로 사용해보십시오!

편집 : -1 바이트 덕분에, @xnor합니다 -2 @ H.PWiz -4 바이트 감사

젤리 , 11 바이트

9Żṗ5ŒPiⱮẠɗƇ

온라인으로 사용해보십시오!

Pyth, 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.

루비 , 54 바이트

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

온라인으로 사용해보십시오!

문자 배열의 배열로 입력을받습니다.

파이썬 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']

온라인으로 사용해보십시오!

에서 5 자리 숫자로 된 문자열을 재귀 적으로 시도 s하여 l여전히 적중 할 부분 시퀀스를 추적합니다 . 끝이 모두 비어 있으면 결과를 인쇄합니다.

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

온라인으로 사용해보십시오!

대입 식 의 힘을보십시오 !. 하위 순서를 확인하기 위해 여기부터 방법을 사용합니다 .

펄 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

온라인으로 사용해보십시오!

레티 나 , 53 바이트

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

온라인으로 사용해보십시오! 설명:

~(`

스크립트를 실행 한 후 결과를 새 스크립트로 가져 와서 실행하십시오.

.$*

.*어디에나 삽입하십시오 . 이 결과 .*3.*2.*0.*우리는 필요하지만 3.*2.*0그것은 중요하지 것이다.

m`^
G`

G`각 줄의 시작 부분에 a 를 삽입하십시오 . Retina Grep 명령으로 전환됩니다.

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

두 개의 Retina 명령 접두사. 결과 스크립트는 다음과 같습니다.

K`

버퍼 (원래 입력을 포함)를 비 웁니다.

5+

5 번 반복 ...

%`$

... 각 줄에 추가하십시오 ...

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

...까지 숫자 0, 그 다음 줄의 사본, 그리고 그 다음 1까지 의 숫자 등 9. 이것은 n루프 이후에 모든 n자릿수를 갖음을 의미합니다.

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

입력을 기준으로 가능한 숫자를 필터링하십시오.

R , 80 82 바이트

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

다음은 정규식을 사용하는 기본 R 솔루션입니다. 이 일련의 중첩 함수를 작성하면 magrittr 패키지에 대해 얼마나 많이 배웠는지 알 수있었습니다!

처음에는 입력에 대한 규칙을 읽지 않았으므로 이제 stdin에서 읽습니다 (@KirillL 덕분에).

온라인으로 사용해보십시오!

루비 , 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

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하거나 사용해보십시오 .

J , 52 바이트

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

온라인으로 사용해보십시오!

apt, 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

@Shaggy 덕분에 -2 바이트!

C # (Visual C # 대화식 컴파일러) 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);
  }
}

편집 : 같은 문자가 두 번 이상 계산되는 버그가 수정되었습니다. 예를 들어, 000기록 된 경우이 함수는 단일을 포함하는 모든 비밀번호를 리턴하는 데 사용됩니다 0.

클린 , 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]

온라인으로 사용해보십시오!

K 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 float 1e5에 플로어를 적용합니다 (과학적 표기법)-> 정수 100000 생성

  • !_1e5 정수 목록 0..99999를 생성합니다

  • {..}'!_1e5 0..99999의 각 값에 람다를 적용합니다.

  • $x 인수 x (암시 적 인수)를 문자열로 변환

  • -5$$x문자열 $ x를 크기가 5 인 필드에 맞 춥니 다 (예 : -5$$12생성" 12"

  • "0"^string공백을 "0"문자로 대체하므로 "0"^-5$$12생성"00012"

• a 0..31 범위의 정수 목록 (5 비트 값)

  • !32 값을 생성합니다 0..31

  • (5#2) 2 회 5 회 반복 (목록 2 2 2 2 2)

  • (5#2)\:'!32 0..31 범위의 각 값에 대해 5 비트 값 (2 개의 기본 5 회)을 생성합니다.

• a의 값을 정확히 3으로 필터링합니다. 이 값은 패턴을 찾을 수있는 모든 조합 (장소) 11100 11010 11001 10110 10101 10011 01110 01101 01011 00111입니다. 전의. "abc"패턴의 경우 정규 표현식과 동등합니다.abc?? ab?c? ab??c a?bc? a?b?c a??bc ?abc? ?ab?c ?a?bc ??abc?

  • +\'a 각 이진 표현의 합계를 계산합니다 (1의 수).

  • 3=+\'a 부울 목록을 생성합니다 (a의 각 값에 정확히 3 개의 값이있는 경우).

  • a@&3=+\'a "3 = + \ 'a가 참인 곳"으로 읽습니다.

• 이전 장소에 ​​대한 색인 목록을 생성합니다 (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)에 입력 가능한 값

  • &:' "where each"로 읽고 2 진 정수 목록에 적용하고 각 1 비트의 인덱스를 계산합니다.

  • x@/: 인덱스 목록의 각 요소에 암호 x를 적용합니다 (가능한 모든 입력 값 생성).

• 모든 패턴이 입력 가능한 모든 값 목록에 있는지 판별

  • y 패턴 목록을 나타내는 인수입니다.

  • y in\: 오른쪽 목록에서 y의 각 값으로 읽습니다.

  • &/"이상"입니다. &/y in\:..y의 모든 패턴이 목록에있는 경우 true를 리턴합니다.

• 마지막으로 람다를 사실로 만드는 모든 인덱스에서 n의 각 문자열을 반환하십시오.

  • n@&{..} "lamda {..}가 true를 반환하는 위치에서 n"으로 읽습니다.

C (GCC) 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,