บทนำ

เพื่อป้องกันการขโมยคีย์ล็อกรหัสผ่านของผู้ใช้ระบบบัญชีธนาคารบางแห่งได้ดำเนินการตามมาตรการรักษาความปลอดภัยต่อไปนี้: มีเพียงบางตัวเลขเท่านั้นที่ได้รับแจ้งให้ป้อนในแต่ละครั้ง

ตัวอย่างเช่นสมมติว่ารหัสผ่านเป้าหมายของคุณคือ89097ระบบอาจแจ้งให้ป้อนรหัสหลักที่ 2, 4 และ 5:

997

หรืออาจแจ้งให้พวกเขาป้อนตัวเลขที่ 1, 3 และหลักที่ 5:

807

ทั้งหมดที่คุณรู้คือเป้าหมายของคุณป้อนตัวเลขในการสั่งซื้อแต่คุณไม่ทราบว่าตำแหน่งที่พวกเขาอยู่ในรหัสผ่านที่แท้จริง ทั้งหมดที่คุณรู้คือมีสอง 9s ซึ่งจะต้องมาก่อน 7; และ 8 นั้นมาก่อน 0 และ 0 ก่อนหน้า 7 ดังนั้นจึงมีหกรหัสผ่านที่เป็นไปได้:

80997
89097
89907
98097
98907
99807

keylogger ในคอมพิวเตอร์เป้าหมายของคุณรวบรวมรหัสผ่านเป็นเวลาหลายเดือนแล้วมาแฮ็กกันเถอะ!

ท้าทาย

รับรายการอินพุตสามหลักส่งออกรหัสผ่านที่เป็นไปได้ทั้งหมดที่ใช้ได้สำหรับอินพุตทั้งหมด เพื่อลดความซับซ้อนในการคำนวณและเพื่อให้ได้ผลลัพธ์ที่ต่ำที่สุดรหัสผ่านจะรับประกันว่าจะเป็นตัวเลขและมีขนาดคงที่ที่ 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 มาตรฐาน
• ไม่มีช่องโหว่มาตรฐาน
• นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ ยินดีต้อนรับภาษาที่ไม่มี codegolfing!

Python ขนาด 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 2 และ Python 3

( 97 ไบต์ใน 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 ไบต์

ž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

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

Haskell, 81 80 78 76 ไบต์

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

วิธีการบังคับเดรัจฉานที่เห็นได้ชัดใน Haskell: สร้างรายการรหัสผ่านที่เป็นไปได้ทั้งหมดและเก็บรักษาสิ่งที่องค์ประกอบทั้งหมดจากรายการอินพุตอยู่ในรายการลำดับส่วนประกอบ

ลองออนไลน์!

แก้ไข: -1 ไบต์ขอบคุณ @xnor, -2 -4 ไบต์ขอบคุณ @ H.PWiz

เยลลี่ 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.

Ruby , 54 ไบต์

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

ลองออนไลน์!

รับอินพุตเป็นอาร์เรย์ของอักขระอาร์เรย์

Python 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ส่วนที่เหลือ หากทุกอย่างว่างเปล่าในตอนท้ายให้พิมพ์ผลลัพธ์

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

ลองออนไลน์!

ดูพลังของการแสดงออกที่มอบหมาย ! ใช้วิธีจากที่นี่เพื่อตรวจสอบส่วนประกอบ

Perl 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`ที่จุดเริ่มต้นของแต่ละบรรทัด นี่เปลี่ยนเป็นคำสั่ง 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ตัวเลข -digit ทั้งหมด

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 พื้นฐานโดยใช้ regex การเขียนชุดฟังก์ชันที่ซ้อนกันนี้ทำให้ฉันรู้ว่าฉันได้เรียนรู้ที่จะชื่นชมแพ็คเกจ magrittr มากแค่ไหน!

เริ่มแรกไม่ได้อ่านกฎเกี่ยวกับอินพุตดังนั้นตอนนี้อ่านจาก stdin (ขอบคุณ @KirillL)

ลองออนไลน์!

Ruby , 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[)]

ลองออนไลน์!

Japt, 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 ไบต์ขอบคุณ @Shaggy!

C # (Visual C # Interactive คอมไพเลอร์) , 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 มีความสามารถ regex ดั้งเดิม (มาก) ดังนั้นฉันจึงลองใช้วิธีอื่น

{... } กำหนดแลมบ์ดา ใช้ตัวอย่าง:{...}("320";"723";"730")

ผลตอบแทน ("37230";"72320";"73203";"73230")

• n เป็นรายการจำนวนเต็มในช่วง 0..9999 เป็นสตริง 0-padded

  • _1e5 ใช้พื้นเพื่อลอย 1e5 (สัญลักษณ์ทางวิทยาศาสตร์) -> สร้างจำนวนเต็ม 100000

  • !_1e5 สร้างรายการจำนวนเต็ม 0..99999

  • {..}'!_1e5 ใช้แลมบ์ดากับแต่ละค่าใน 0..99999

  • $x แปลงอาร์กิวเมนต์ x (ARG โดยนัย) เป็นสตริง

  • -5$$xปรับสตริง $ x ให้เหมาะกับฟิลด์ขนาด 5 (เช่น-5$$12สร้าง" 12"

  • "0"^stringแทนที่ช่องว่างด้วยอักขระ "0" ดังนั้น"0"^-5$$12สร้าง"00012"

• a เป็นรายการจำนวนเต็มในช่วง 0..31 เป็นค่า 5 บิต

  • !32 สร้างค่า 0..31

  • (5#2) ทำซ้ำ 2 ห้าครั้ง (รายการ 2 2 2 2 2)

  • (5#2)\:'!32 สร้างค่า 5 บิต (2 ฐานห้าครั้ง) สำหรับแต่ละค่าในช่วง 0..31

• เรากรองค่าของ a ด้วย 3 อย่างแน่นอน ที่มีค่าทั้งหมดรวมกัน (สถานที่) 11100 11010 11001 10110 10101 10011 01110 01101 01011 00111ซึ่งรูปแบบที่สามารถอยู่: อดีต สำหรับรูปแบบ "abc" เรามีความเท่าเทียมกับ regexabc?? ab?c? ab??c a?bc? a?b?c a??bc ?abc? ?ab?c ?a?bc ??abc?

  • +\'a คำนวณผลรวมของการเป็นตัวแทนไบนารีแต่ละครั้ง (จำนวนรายการ)

  • 3=+\'a สร้างรายการบูลีน (ถ้าแต่ละค่าใน a มี 3 อย่างแน่นอน)

  • a@&3=+\'a อ่านว่า "a at where 3 = + \ 'a is true"

• สร้างรายการดัชนีสำหรับสถานที่ก่อนหน้า: (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 เป็น arg ที่แสดงรายการของรูปแบบ

  • y in\: อ่านค่าแต่ละค่าของ y ในรายการทางด้านขวา

  • &/คือ "และมากกว่า" &/y in\:..ผลตอบแทนจริงถ้ารูปแบบทั้งหมดใน y ตั้งอยู่ที่รายการ ..

• ในที่สุดก็คืนค่าแต่ละสตริงใน n ที่ทุกดัชนีที่ทำให้แลมบ์ดาเป็นจริง

  • n@&{..} อ่านเป็น "n ที่ lambda {.. } คืนค่าจริง"

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,