text:
Crack the bank account's password!
Introduction
In order to prevent keyloggers from stealing a user's password, a certain bank account system has implemented the following security measure: only certain digits are prompted to be entered each time.
For example, say your target's password is 89097, the system may prompt them to enter the 2nd, 4th and 5th digit:
997
Or it might prompt them to enter the 1st, 3rd and 5th digit:
807
All you know is that your target entered the digits in order, but you don't know which position they belong to in the actual password. All you know is there are two 9s, which must come before 7; and that 8 comes before 0, and 0 before 7. Therefore, there are six possible passwords:
80997
89097
89907
98097
98907
99807

The keylogger in your target's computer has been collecting password inputs for months now, so let's hack in!
Challenge
Given a list of three-digit inputs, output all the possible passwords that are valid for all inputs. In order to reduce computational complexity and to keep the amount of possible results low, the password is guaranteed to be numerical and have a fixed size of 5. The digits in every input are in order: if it's 123, the target typed 1 first, then 2, then 3.
Input/Output examples
|----------------------|--------------------------------------------|
|         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] |
|----------------------|--------------------------------------------|

Rules

Input is guaranteed non-empty.
Leading and trailing zeros matter: 01234 is different from 12340, and 1234 doesn't crack either password. Think of how real passwords work!
Standard I/O rules apply.
No standard loopholes.
This is code-golf, so the shortest answer in bytes wins. Non-codegolfing languages are welcome!

Are the digits always in order? Based on the test cases I assume they are, but I couldn't see it mentioned in the rules unless I read past it.

@KevinCruijssen Yes, they are in order. I'll add that to the post.

Welcome to PPCG! This is a nice, well-structured, and neatly formatted first challenge. You've clearly done your homework as far as getting that all down. I'm looking forward to answering it (if someone doesn't answer it in R first!). In the future, we suggest using the sandbox to get feedback before posting to main. Hope you enjoy your time on PPCG!

@Giuseppe thanks! I've been anonymously reading the questions on this site for years, and I've been writing and tweaking and actually solving this specific problem for a couple months: I liked it enough to skip the sandbox. I'll post there first next time!

Are leading zeros in the output mandatory?

@Arnauld Well, if your password is 01234 or 12340 you shouldn't be able to log in by typing 1234. Passwords are more a string than a number even if composed by numbers, at least in that sense. So yes, leading and trailing zeros are mandatory.

@cefel You should mention that in the challenge.

I'm confused by the example.  If we know 1st/3rd/5th digits and also know 2nd/4th/5th, don't we know all 5 digits?  I don't see where the ambiguity leading to 6 possibilities arises... (EDIT: oh ok we don't the specific digits that were asked for?  i think you should make that explicit)

Said another way, the problem is asking you to construct a full sequence of known length from multiple sub-sequences (whose indexes you do not know).

Are we allowed to take the three-digit inputs as digit lists (so like [[1, 2, 3], [4, 5, 6]]?)

@Arnauld I've added your recommendation into the post. Thanks for the input.

@Jonah I've made it explicit in the post, thanks for the input. You probably nailed the problem's description in the most generic way possible - it was truly inspired by a bank account system, though, so I kept the password idea into the challenge. :)

@HyperNeutrino yes, sure.

The final test case appears to be missing 22123... unless I'm misunderstanding something?

This is a special case of finding the Shortest common supersequence problem.

@Jonah you're right - for some reason my solution is skipping that particular number... there must be a bug somewhere. I'm adding it to the test case. Nice catch!

@user202729 rest assured that I didn't know the shortest common supersequence problem was a thing - still, I don't think we've had anything like it in PPCG before.

Python, 100 bytes
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

Try it online!
Works in Python 2 as well as Python 3.
(97 bytes in 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

This is a lovely solution...

Your non-3.8 code can do the "poor-man's assignment expression" of aliasing the string '%05d'.

05AB1E, 11 9 bytes
žh5ãʒæIåP

Try it online!
Explanation
ž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 bytes
Prints the results with alert().
a=>{for(k=n=1e5;n--;)a.every(x=>(s=([k]+n).slice(-5)).match([...x].join`.*`))&&alert(s)}

Try it online!
Commented
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 bytes
f x=[p|p<-mapM(:['1'..'9'])"00000",all(`elem`(concat.words<$>mapM(:" ")p))x]

The obvious brute force approach in Haskell: built a list of all possible passwords and keep those where all elements from the input list are in respective list of subsequences.
Try it online!
Edit: -1 byte thanks to @xnor, -2 -4 bytes thanks to @H.PWiz

Looks like you can compute the subseqs yourself a little shorter.

concat.words<$>mapM(:" ")p is shorter

use p<-mapM(:['1'..'9'])"00000" to save 2 more bytes

Python 2, 96 bytes
l=input()
n=1e5
while n:
 n-=1;s='%05d'%n;t={''}
 for c in s:t|={x+c for x in t}
 if l<t:print s

Try it online!
Takes input as a set of strings.

Python 3, 98 bytes
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']

Try it online!
Recursively tries building every five-digit number string in s, tracking the subsequences in l still remaining to be hit. If all are empty by the end, prints the result.

Your Py3.8 submission has a couple of syntax errors related to reassigning stuff that shouldn't be reassigned. I tried fixing the problems that popped up but I lost 25 bytes in the way xD

@RGS Weird, did I really not test that, or maybe something changed? Thanks for catching that, I deleted it.

I was able to pull the 3.8 one back down to 104 bytes though it's still not worth it.

@Bubbler I'm posting my 119 byter. Do you want to post your 104 or should I post it as you golfing mine down?

@RGS I'm fine if you post it. Also, 102 bytes by switching the format string.

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

Try it online!
Takes input as an arrray of character arrays.

Well done! You beat me by 25 bytes. Should I delete my answer?

No, as long as you have a valid answer, there's no need to delete it.

Pyth, 11 bytes
f<QyT^s`MT5

Takes input as a set of strings.
Try it here
Explanation
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.

R, 80 81 bytes
Reduce(intersect,lapply(gsub("",".*",scan(,"")),grep,substr(1e6:199999,2,6),v=T))

Try it online!
Here’s a base R solution using regex. Writing this nested series of functions made me realise how much I’ve learned to appreciate the magrittr package!
Initially hadn’t read rules on input, so now reads from stdin (thanks @KirillL).
Thanks to @RobinRyder for saving a byte!
Try it online!

@digEmAll it says it’s 82 bytes doesn’t it? You can’t use integers because of potential for leading zeroes in the input.

Sorry, I read the title and unconsciously I picked the minimum number without noticing that it was strikedthrough... and yes, sorry again you're right about the string input ;)

81 bytes by generating the list of all passwords with substr(1e5:19999,2,6). If displaying the same solution multiple times is allowable, you can gain a further 3 bytes with substr(1e5:2e5,2,6) (will find 00000 twice).

Jelly, 11 bytes
9Żṗ5ŒPiⱮẠɗƇ

Try it online!

Perl 5 -MList::Util=all -a, 70 bytes
map{$t=sprintf'%05d',$_;(all{$t=~/$_/}map s//.*/gr,@F)&&say$t}0..99999

Try it online!
Old Approach:  Perl 5 -a, 80 77 bytes
Credit to @NahuelFouilleul for -2 bytes
map{s||($t=0)x(5-y///c)|e;for$b(map s//.*/gr,@F){$t+=/$b/}$t-@F||say}0..99999

Try it online!

$t+=/$b/ instead of /$b/&&$t++

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

Try it online! Explanation:
~(`

After executing the script, take the result as a new script, and execute that, too.
.$*

Insert .* everywhere. This results in .*3.*2.*0.* although we only need 3.*2.*0, not that it matters.
m`^
G`

Insert a G` at the start of each line. This turns it into a Retina Grep command.
^
K`¶5+%`$$¶0"1"2"3"4"5"6"7"8"9¶
"
$$"

Prefix two more Retina commands. The resulting script will therefore look something like this:
K`

Clear the buffer (which contains the original input).
5+

Repeat 5 times...
%`$

... append to each line...
0$"1$"2$"3$"4$"5$"6$"7$"8$"9

... the digit 0, then a copy of the line, then the digit 1, etc. until 9. This means that after n loops you will have all n-digit numbers.
G`.*3.*2.*0.*
G`.*7.*2.*3.*
G`.*7.*3.*0.*

Filter out the possible numbers based on the input.

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

Try it online!
Input is an array of strings.
Here's a more readable version of the same code:
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, your approach can also be made shorter by switching to char array input, as in my version, and -2 more bytes by formatting the upper value as 1e5, like this

@KirillL. Thanks for the -2 bytes. I won't change the input format because my answer would look too much like yours. Cheers!

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

Try it online!

PHP 128 bytes
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;

or
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;

take input from command line arguments. Run with -nr or try them online.

C# (Visual C# Interactive Compiler), 116 bytes
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);}}

Try it online!
// 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: fixed a bug where the same character was counted more than once. For example, if 000 was logged, the function used to return all passwords containing a single 0.

Japt, 21 bytes
1e5o ù'0 f@e_XèZË+".*

Try it!
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 bytes thanks to @Shaggy!

less useless variables: 1e5o ù'0 fA{Ue@AèX®+".* :P

also 23: 1e5o ù'0 fA{Ue@AèX¬q".*

21 bytes

Interesting... I didn't realize return X,Y,Z would pick the last term. Thanks for the tips :)

@dana; Yup, that's a feature of JavaScript: https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@1@jQqdS09auuii1pLQoTwHIq/2fnJ9XnJ@TqpeTn66RpmGgY6ip@R8A

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

Try it online!

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

K has a (very) primitive regex capability, so i tried a different approach.
{...} defines a lambda. Use example: {...}("320";"723";"730")
returns ("37230";"72320";"73203";"73230")

n is the list of integers in range 0..9999 as 0-padded strings

_1e5 applies floor to float 1e5 (scientific notation) -> generates integer 100000
!_1e5 generates integer-list 0..99999
{..}'!_1e5 applies lambda to each value in 0..99999
$x transform argument x (implicit arg) to string
-5$$x right adjust string $x to a field of size 5 (ex. -5$$12 generates "   12"
"0"^string replaces blanks with "0" char, so "0"^-5$$12 generates "00012"

a is the list of integers in the range 0..31 as 5-bit values

!32 generate values 0..31
(5#2) repeat 2 five times (list 2 2 2 2 2)
(5#2)\:'!32 generates 5-bit values (2-base five-times) for each value in range 0..31

we filter the values of a with exactly 3 ones. That values are all the combinations (places) where pattern can be located: 11100 11010 11001 10110 10101 10011 01110 01101 01011 00111. Ex. for "abc" pattern we have equivalence with regexs abc?? ab?c? ab??c a?bc? a?b?c a??bc ?abc? ?ab?c ?a?bc ??abc?

+\'a calculates sum of each binary representation (number of ones)
3=+\'a generates list of booleans (if each value in a has exactly 3 ones)
a@&3=+\'a reads as "a at where 3=+\'a is true"

generate list of indexes for previous places: (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) and the possible entered-values for a password (x)

&:' reads as "where each", applies to list of binary-coded integers, and calculates indexes of each 1-bit
x@/: applies password x to each elem of the list of indexes (generates all possible entered values)

Determines if all patterns are located in the list of all possible entered values

y is the arg that represent list of patterns
y in\: reads as each value of y in the list at the right
&/ is "and over". &/y in\:.. returns true iff all patterns in y are locates at the list ..

finally, return each string in n at every index that makes lambda true

n@&{..} reads as "n at where lambda {..} returns true"

Bash + GNU utilities, 54 53 51 bytes
sed 's/./&.*/g;s/ \|^/|grep /g;s//seq -w 0 99999/e'

Try it online!
Thanks to @user41805 for 1 byte off, and now an additional 2 bytes off.
Input: Space-separated integers on stdin.
Output: On stdout, one possible password per line.

Putting everything inside sed (and eval'ing using sed's e) seems to save at least a byte.

@user41805 Thanks for the idea, I'll take a look at that.

@user41805  Yes, it saved a byte.

e can also be passed as a flag to the s command. Additionally, you can make use of this tip https://codegolf.stackexchange.com/a/167295 to save a byte

@user41805 Thanks -- that's 2 more bytes shaved off.

Python 3.8 (pre-release), 119 102 bytes
lambda l:['%05d'%n for n in range(10**5)if all(map(lambda x:''in[x:=x[x[:1]==c:]for c in'%05d'%n],l))]

Try it online!
This was based off of xnor's Python answer and @Bubbler helped me golf it by 17 bytes ;)

Python 3.8, 97 96 bytes
lambda l:[s for n in range(10**5)if(s:='%05d'%n,t:={''},[t:=t|{x+c for x in t}for c in s])!=t>l]

Try it online!
-1 byte thanks to @xnor.
Python 2, 96 bytes
lambda l,d='%05d':[d%n for n in range(10**5)if reduce(lambda t,c:t|{x+c for x in t},d%n,{''})>l]

Try it online!
Alternative forms of xnor's Python 2 answer.

This is nice, I didn't expect lambda versions get so close. Of course the 1e5 gives the program an advantage. I got a byte off the 3.8 one: Try it online!. Annoyingly, using < for != makes Python 3 complain, and we can't make the tuple a set.

Here's a variant of the 96: Try it online! I feel like it should possible to stick the walrus assignments somewhere shorter, but I'm not seeing how. I hope you have some ideas.

C(GCC) 222 214 bytes
-8 bytes ceilingcat
#define C(p)*f-p||++f;
#define I(x,y)x>9&&++y,x%=10;
a,b,c,d,e,g,**h,*f;z(int**H){for(a=0;g=a<10;){for(h=H;*h;g&=f>*h+++2){f=*h;C(a)C(b)C(c)C(d)C(e)}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)}}

Try it online!
Calling code
int main() {
  int hint1[5] = {9,9,7,-1,-1};
  int hint2[5] = {8,0,7,-1,-1};
  int* hints[3] = {hint1,hint2,0};
  z(hints);
}

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

211 bytes

The function takes an array of strings as input and prints each possible code on separate lines.
PHP, 122 bytes
function a($n){for(;$x++<1e5;){foreach($n as$a)if(!preg_match("/$a[0].*$a[1].*$a[2]/",$x))continue 2;printf("%05d
",$x);}}

Try it online!

sed -E, 46 44 bytes
s/./&.*/g;s/ |^/|grep /g;s//seq -w 0 99999/e

Try it online!
Input: Space-separated integers on stdin.
Output: On stdout, one possible password per line.
This is from my bash answer, which had 3 bytes off thanks to @user41805.


text:
Fizzbuzz in any base
Challenge
Input:
An integer \$b\$ between 2 and 62 (inclusive).
Output:
Count from \$1\$ to the equivalent of \$5000_{10}\$ in base \$b\$, using any reasonable representation for the digits.
However:

If the number is divisible by \$\lfloor b÷2+1\rfloor\$ (rounded down, e.g base 7 would be 7/2=3.5, 3.5+1=4.5, rounded to 4), then output 'Fizz' instead of the number.
If the number is divisible by \$\lceil b÷3+3\rceil\$ (rounded up, e.g 11/3=3.666, 3.666+3=6.666, rounded to 7), then output 'Buzz'.
As you can probably guess, if your number is divisible by both, output 'Fizzbuzz'.

Examples
Using [0-9], [A-Z] and [a-z] as the digits
(I've only included the first 10 values to keep the examples short - normally there'd by 4990 more items in each sequence)
Input: 10 (so 'Fizz' = 6 and 'Buzz' = 7)
Output: 1, 2, 3, 4, 5, Fizz, Buzz, 8, 9, 10
Input: 2 (so 'Fizz' = 2 and 'Buzz' = 4)
Output: 1, Fizz, 11, Fizzbuzz, 101, Fizz, 111, Fizzbuzz, 1001, Fizz
(I've included the first 50 values of the following to better show how they work)
Input: 55 (so 'Fizz' = \$28_{10}\$ = \$s_{55}\$ and 'Buzz' = \$22_{10}\$ = \$m_{55}\$)
Output: 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, g, h, i, j, k, l, Buzz, n, o, p, q, r, Fizz, t, u, v, w, x, y, z, A, B, C, D, E, F, G, H, I, J, K, L, M, N
Rules

Standard loopholes are forbidden
This is Code Golf, so shortest answer in bytes wins
Input and output can be through console, or function arguments/returns
Leading/trailing white space is fine, as are empty lines
Spaces between 'Fizz' and 'Buzz' are disallowed
Any capitalization variant of 'Fizz'/'Buzz'/'Fizzbuzz' is fine.
Outputs should be separated by newlines.
If you return a array of base 10 'digits' instead of representing them with characters, then they have to be in the correct order!

I've added a base-55 example

Entirely possible - will fix

You have it go [0-9]->[a-z]->[A-Z]. Is this order required or can you use [0-9]->[A-Z]->[a-z]. I ask this because @Arnauld does the latter

@Veskah As a side note, that's an easy fix in my answer but that might be trickier for others. Using the ASCII order ('A' < 'a') seems to make more sense.

I don't really mind. If you want to use emoji instead of digits, I still don't mind. It's the base that matters, not the representation.

Ok, clarified now.

Technically, in base 36 the word buzz appears by itself at index 553391, fizz at 724463, and fizzbuzz at 1216820199599. Sadly, none of them are divisible by that base's numbers

12 seems really boring; both Fizz and Buzz are 7, or have I overlooked something?

Why isn't base 10 the original FizzBuzz?

Why isn't base 10 the original FizzBuzz?: I couldn't think of an algorithm which would both generate the original numbers in base 10, and transfer well to other bases. And I didn't want to add a special case for denary since that would just overcomplicate the question, in my opinion.

For your future challenges, please consider allowing more flexible I/O. Cumbersome I/O formats is the most upvoted topic in Things to avoid when writing challenges.

Jelly,  42 38 34 33 29  32 bytes
+3 to adhere to strict formatting rules
5ȷɓ;8Ä:2,3‘ḍȧ"“Ƈ×“=%»ḟ0Fȯb@K¥ð€Y

A full program which prints 5000 lines of text, each line containing a series of integers (the digits) or one of fizz, buzz, or fizzbuzz (works fine beyond base 62).
Try it online!
How?
Note that
\$\lfloor b÷2+1\rfloor\ = \lfloor b÷2\rfloor+1\$
...and
\$\lceil b÷3+3\rceil = \lceil b÷3+2\rceil+1 = \lceil (b+6)÷3\rceil+1 = \lfloor (b+8)÷3\rfloor+1\$
updating...
5ȷɓ;8Ä:2,3‘ḍȧ"“Ƈ×“=%»ḟ0Fȯb@ð€ - Link: integer, b
5ȷ                            - 5*10³ = 5000
  ɓ                        ð€ - for €ach n in [1,2,...,5000] get this f(b,n):
    8                         -   eight
   ;                          -   concatenate      -> [b,8]
     Ä                        -   cumulative sums  -> [b,b+8]
       2,3                    -   pair literal        [2,3]
      :                       -   integer division -> [b//2, (b+8)//3]
          ‘                   -   increment        -> [b//2+1, (b+8)//3+1]
           ḍ                  -   divides n?       -> [n is fizzy?, n is buzzy?]
              “Ƈ×“=%»         -   list of dictionary strings = ['fizz','buzz']
             "                -   zip with:
            ȧ                 -     logical AND    -> [0,0], ['fizz',0], [0,'buzz'],
                              -                       or ['fizz','buzz']
                      0       -   zero
                     ḟ        -   filter discard   -> [], ['fizz'], ['buzz'],
                              -                       or ['fizz','buzz']
                       F      -   flatten          -> [], ['fizz'], ['buzz'],
                              -                       or ['fizzbuzz']
                          @   -   using swapped arguments:
                         b    -     (n) to a list of digits in base (b)  (say, [nb])
                        ȯ     -   logical OR       -> [nb], ['fizz'], ['buzz'],
                              -                       or ['fizzbuzz']

The challenge states that output must be on seperate lines

True. While I'm fine with the representation (though it's borderline), outputting an array isn't the same as playing the game. However, if you output the array of digits on each line, I'll accept it.

@GezaKerecsenyi Updated. However, I don't understand how the representation is "borderline" - in base b the digits are in $[0,n-1]$. Or how outputting an array isn't "playing the game" ("Input and output can be through console, or function arguments/returns"). Using some other arbitrary output is as simple as substitution and formatting is just boilerplate and orthogonal to the core of the challenge.

A terser implementation could just take a list of the desired digits, instead of the numerical base, like this.

Charcoal, 40 bytes
ＮθＥ…·¹×⁵φ∨⁺⎇﹪ι⊕÷θ²ωFizz⎇﹪ι÷⁺¹¹θ³ωBuzz⍘ιθ

Try it online! Link is to verbose version of code. Explanation:
Ｎθ                                      Input `b` into variable `q`
   ¹                                    Literal 1
 …·                                     Inclusive range to
      φ                                 Predefined variable 1000
    ×                                   Multiplied by
     ⁵                                  Literal 5
Ｅ                                       Map to
           ι                            Current value
          ﹪                             Modulo
              θ                         Input value
             ÷                          Floor divide
               ²                        Literal 2
            ⊕                           Incremented
         ⎇                              If nonzero
                ω                       Then predefined empty string
                 Fizz                   Otherwise literal `Fizz`
        ⁺                               Concatenated with
                       ι                Current value
                      ﹪                 Modulo
                            θ           Input value
                         ⁺              Plus
                          ¹¹            Literal 11
                        ÷               Integer divided by
                             ³          Literal 3
                     ⎇                  If nonzero
                              ω         Then predefined empty string
                               Buzz     Otherwise literal `Buzz`
       ∨                                Logical Or
                                    ι   Current value
                                   ⍘    Converted to base
                                     θ  Input value
                                        Implicitly print each result on its own line

R, 163 131 bytes
b=scan();for(d in 1:5e3)cat(list(d%/%b^rev(0:log(d,b))%%b,'fizz','buzz','fizzbuzz')[[1+(!d%%((b+2)%/%2))+2*!d%%((b+11)%/%3)]],'\n')

Try it online!
Thanks to @digEmAll for saving 23 bytes. I then further golfed @digEmAll’s efforts to save a further 9.

140 byte I worked on this without looking at your answer, but it's too similar for another post ;)

@digEmAll thanks. I’ve further golfed your answer to get 131 bytes and given you credit; hope that’s ok.

absolutely ! ;)

BTW, if you have any discussion about golfing in R ask on this chat

Oops, didn't realize there was already an R answer, my answer might be helpful for a bit more golfing?

JavaScript (ES6),  117  116 bytes
Outputs comma-delimited digits, each digit being expressed as a decimal quantity (e.g. \$19_{20}\$ is \$19\$ and \$21_{20}\$ is \$1,1\$).
b=>(g=n=>n>1?g(n-1)+`
`+((s=n%(b+2>>1)?'':'Fizz',n%(b/3+3.9|0)?s:s+'Buzz')||(g=n=>n?[...g(n/b|0),n%b]:s)(n)):1)(5e3)

Try it online!
(limited to 100 so that TIO's output does not blow up)

Any chance you could explain what |0 and (5e3) does?

@psinaught Performing a bitwise OR with $0$ on a number $n$ forces it to be coerced to the nearest smaller integer, so it's basically equivalent to Math.floor(n) (except it only works for $0\le n<2^{31}$). 5e3 is the exponential notation for 5000 -- which is here the argument passed to the outer arrow function $g$.

Python 2, 116 bytes
b=input()
i=0
exec"a=i=i+1;d=[]\nwhile a:d=[a%b]+d;a/=b\nprint'Fizz'*(i%(b/2+1)<1)+'Buzz'*(i%(~-b/3+4)<1)or d;"*5000

Try it online!
Or with 0-9a-zA-Z output:
Python 2, 143 bytes
b=input()
i=0
exec"a=i=i+1;d=''\nwhile a:d=chr(a%b+48+(a%b>9)*39-a%b/36*58)+d;a/=b\nprint'Fizz'*(i%(b/2+1)<1)+'Buzz'*(i%(~-b/3+4)<1)or d;"*5000

Try it online!

Julia, 108
h(b,N)=join((n->[string(n,base=b),"Buzz","Fizz","FizzBuzz"][1+(1>n%(b÷2+1))*2+(1>n%((b+11)÷3))]).(1:N),"\n")

ATOable

100 bytes answers are scored in bytes, not chars, and ATO gives the count at the top

you're supposed to count to 5000, not take it as an input I think

Vyxal, 26 bytes
₁²½ƛ?8"¦23f/›ḊkF½*∑n?τ$∨;⁋

Try it Online!

Perl 6, 91 bytes
{$!=0;('Fizz'x++$!%%($_/2+|0+1)~'Buzz'x$!%%(($_+8)/3+|0+1)||[R,] $!.polymod($_ xx*))xx}

Try it online!
Anonymous code block that returns a list of either strings of Fizz/Buzz/FizzBuzz or a reversed list of integers in the base.

See https://codegolf.stackexchange.com/questions/180247/fizzbuzz-in-any-base#comment434576_180273. I've added a clarification in the question about this.

05AB1E, 39 37 36 bytes
8+‚U5₄*LεX23S÷>Ö”FizzÒÖ”#×JDõQiyIв]»

-2 bytes by creating a port of @JonathanAllan's Jelly answer.
Try it online or verify all test cases (but as list-output and with the first 100 instead of 5000).
Explanation:
8+               # Add 8 to the (implicit) input
  ‚              # Pair it with the (implicit) input
   U             # Pop and store it in variable `X`
5₄*L             # Create a list in the range [1,5000]
    ε            # Map each value `y` to:
     X23S÷       #  Integer-divide the input by 2, and the input+8 by 3
          >      #  Increase both by 1
           Ö     #  Check for both if they divide value `y` evenly (1 if truthy; 0 if falsey)
     ”FizzÒÖ”    #  Push dictionary string "Fizz Buzz"
             #   #  Split on spaces
              ×  #  Repeat the strings the result amount of times (0 or 1)
               J #  Join both strings together to a single string
     DõQi        #  If this string is empty:
         yIв     #   Push value `y` in Base-input (as list) instead
    ]            # Close the if-statement and map
     »           # Join the list by new-lines (and inner lists by spaces implicitly)
                 # (and output the result implicitly)

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why ”FizzÒÖ” is "Fizz Buzz".

I have a looping version at 33 bytes in case you wanna try and optimize this. Still a byte longer than Jelly though :(

@Emigna Have you already post it? Or it's fairly similar to my answer and it is meant as a golf? PS: Jelly has a few short-cut builtins with for example the [input, input+8] part, and the filter part afterwards (which I now do as DõQi   yIв, but I have the feeling it can be golfed some more..)

Levenshtein-distance wise it's very different from yours (although parts can be rewritten to be more like yours). But I also use Jonathan's n+8 trick so I figured I'd let you try and golf yours down towards it if you want. Otherwise I'll post it as a separate answer.

@Emigna I'm currently a bit busy at work, so don't really have time to golf this answer. So if you want you can post it as your own answer. You've got my upvote. ;)

Unfortunately I discovered a bug in my version so now it's 34. I have some ideas that might make yours or mine shorter that I'll explore later. Beating/tying Jelly seems tough now though.

C# (Visual C# Interactive Compiler),  180 171 168 bytes
n=>{for(int i=1,p;i<5001;){var j=new Stack<int>();for(p=i;p>0;p/=n)j.Push(p%n);var s=i%~(n/2)<1?"Fizz":"";Print(i++%((n+11)/3)<1?s+"Buzz":s==""?string.Join("-",j):s);}}

Outputs like Arnauld's answer. Thanks to digEmAll for the idea of using a stack to reverse the output.
Saved 3 bytes thanks to ceilingcat
Try it online!

I'm going to have to say 'no' to the reverse digits. While it's the correct idea mathematically, it's not the Fizzbuzz program, say an employer would want. It's unfortunate that C# doesn't have an array reverse function.

R, 138 bytes
function(b,`*`=rep)Map(function(i)"if"((s=paste0("","Fizz"*!i%%(b%/%2+1),"Buzz"*!i%%((b+11)%/%3)))>0,s,i%/%b^((log(i,b)%/%1):0)%%b),1:5e3)

Try it online!

05AB1E, 34 bytes
Uses Jonathan's mathematical insight that ceil(n/3+3) = floor((n+8)//3)+1
ŽJćG8+‚2L>÷>NsÖ…™Ázz'ÒÖ‚×JNIв‚õKн,

Try it online!
Explanation
ŽJćG                                # for N in [1 ...5001)
    8+‚2L>÷>                        # push [input//2+1, (input+8)//3+1]
            NsÖ                     # check each if N is divisible by it
               …™Ázz                # push "fizz"
                    'ÒÖ             # push "buzz"
                       ‚            # pair
                        ×           # repeat a number of times corresponding to the result of the
                                    # divisibility test
                         J          # join to string
                          NIв‚      # pair with N converted to base <input>
                              õK    # remove empty string
                                н,  # print head of the remaining list

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Error-detecting Self-repairing Program
Your task is to create a program where if any one character is deleted, it will detect which character was deleted and then re-insert the deleted character in its own source file.
For instance, if your program is RadiationHardened and it is modified to RadiaionHardened, then your program must output that the 5th byte (0-indexed) was modified and then the program source must be RadiationHardened immediately after execution.
Notes and rules

You may assume that exactly one character was deleted in the source code before execution. Behavior for the unmodified program is undefined.
You may assume the changed byte will be deleted, not transposed, inserted, or replaced.
In the case of a run of multiple of the same character, you may report either the first or the last index of the run, but be consistent about which you use. For example baaad being deleted to baad can report either 1 or 3 (zero indexed), but must be the same throughout the entire program.
You do not need to write out the entire source to its own file. You need only re-insert the deleted byte.
Unlike the typical rules for radiation-hardened quines, detecting the changed byte from reading the program's own source code is fair game.
You can output the changed byte index through any reasonable format. Be consistent about whether it is 0-indexed or 1-indexed or any other notation. You may even output a number within a template string.

This is code-golf so the shortest program wins.
Good luck!
EDIT1: changed requirement from replacement to deletion
EDIT2: added rule for runs of duplicates

This is a lot harder than handling arbitrary deletions. Most non-esolangs are obviously out (it's usually impossible to write any program that remains syntactially valid under any one-byte modification). Even Fungeoids are mostly thwarted (they can't do anything if the 0th byte is changed into a quit program command). I thought maybe one of two IPs could survive in something like Fission but its * command kills all of the IPs. Cardinal can't do it either, because of @.

This might be turned into a code-challenge where each program is allowed to declare a list of bytes that are protected against radiation (but no more than -- say -- 50% of the total size). A simple scoring system could be to count each radiation-protected byte as 10 bytes, or something like that.

(But that may lead to some trivial and not very interesting answers.)

This sounds impossible in most, if not all, languages.

I'm considering switching this to deletions. Arnauld's suggestion is also viable.

One trivial way would be to wrap the code in a try-except, where only those keywords cannot be mutated...

@JoKing, reporting either as missing is fine, as long as it's consistent.

@Lynn (Under the original modification version). In theory Runic could survive, as there's no equivalent command to Fission's *, but Runic is terrible at reading its own source (I have yet to work out a single-IP multi-line quine, which would need to be the basis). I'm also not sure how the program is supposed to both output the changed index and the altered character's index. (Runic has no file io).

i am assuming we cannot consider machines with error-correcting memory built in, otherwise it seems like the single byte program '0' would be valid in 05ab1e

@donbright I don't think that would fulfil the repairing the source code part of the challenge

"You may require the file to be named a certain name and be run from a specific directory" - be careful, someone can just require that the filename be the correct program...

Befunge-98 (FBBI), 344 296 248 bytes
20020xxnngg33%%!!2200gg''00--3300gg33%%!!4400gg55%%!!22kk++55##rr55kk::00gg\\11pp00gg\\11++11pp22++00::pp00gg\\11++00gg--!!zz!!22**++00::gg00gg8844**--!!55++jj..''gg::00rr00::gg\\--..''220011''0011::''002211''223311''00441144kkppgg11001100::99oo@@

Try it online!
Verification!
Befunge-98 is the first esoteric language that I could find that was both 2D and had file output. This is a full solution (with a trailing newline) stored in a file named as a tab character. It outputs as 0-indexed, and outputs the first index in a run of characters (though there's only ever pairs).
There's a few golfs to be made, especially as there are 15 no-ops in the code, now just one no-op! I will be working on making this shorter, with the goal of getting to or below 200 bytes.

Oh wow! I didn't think this was possible

Unefunge-98 (PyFunge), 118 bytes
22xx00##rr33kk::gg\\11--pp22++00ppgg\\11++gg--!!zz!!22**--00gg::gg8844**--!!22++jj##''rr++..gg''2200pp0011--00::99oo@@

Try it online!
Verification!
While golfing my Befunge-98 answer, I realised I could save some bytes by porting it over to Unefunge, since I would only have to worry about the one dimension rather than the two. This also opened up a lot of possible shortcuts and golfs, which made the new solution much much smaller.
Explanation (de-duplicated):
2x        Set the delta of the movement to 2
          This means the pointer moves 2 cells every step
          This will also initialise a counter as 2 (unless a 2 has been removed)
  0       Create the cell counter  (This will be stored at cell 0)
   #r     Enter the loop
     3k:                 Create 3 more copies of the counter
        g                Get the cell at the counter's position
         \1-p            Put it in the cell before that position
             2+0p        Add 2 to the counter and put it in cell 0
                 g       Get the cell at the counter's position
                  \1+g   Get the next cell
                      -!z!2*      If they are identical, push two, else 0
                            --    Subtract it from the total counter
                              0g:g84*-!   If the next character is a space
                                       2+j  r   Exit loop
                                         j#'    Else jump back to the start

Once the loop is over
+      Add the negative counter to the total counter
 .     And print
   '20p          Replace the 2 in cell 0 that was overwritten
             o   Write to a file named
            9    Tab
       01-       The cells from -1 to
  g              The total number of cells
              @  And exit the program

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Count repetitions of an array
You will receive an array and must return the number of integers that occur more than once.
[234, 2, 12, 234, 5, 10, 1000, 2, 99, 234]

This will return 2, since each of 234 and 2 appear more than once.
[234, 2, 12, 234]
[2, 12, 234, 5, 10, 1000, 2]

The list will never be more than 100k integers long, and the integers inside the list will always be in between -100k and 100k.
Integers should be counted if they occur more than once, so if an integer occurs 3 times then it will still only count as one repeated integer.
Test cases
[1, 10, 16, 4, 8, 10, 9, 19, 2, 15, 18, 19, 10, 9, 17, 15, 19, 5, 13, 20]  = 4
[11, 8, 6, 15, 9, 19, 2, 2, 4, 19, 14, 19, 13, 12, 16, 13, 0, 5, 0, 8]     = 5
[9, 7, 8, 16, 3, 9, 20, 19, 15, 6, 8, 4, 18, 14, 19, 12, 12, 16, 11, 19]   = 5
[10, 17, 17, 7, 2, 18, 7, 13, 3, 10, 1, 5, 15, 4, 6, 0, 19, 4, 17, 0]      = 5
[12, 7, 17, 13, 5, 3, 4, 15, 20, 15, 5, 18, 18, 18, 4, 8, 15, 13, 11, 13]  = 5
[0, 3, 6, 1, 5, 2, 16, 1, 6, 3, 12, 1, 16, 5, 4, 5, 6, 17, 4, 8]           = 6
[11, 19, 2, 3, 11, 15, 19, 8, 2, 12, 12, 20, 13, 18, 1, 11, 19, 7, 11, 2]  = 4
[6, 4, 11, 14, 17, 3, 17, 11, 2, 16, 14, 1, 2, 1, 15, 15, 12, 10, 11, 13]  = 6
[0, 19, 2, 0, 10, 10, 16, 9, 19, 9, 15, 0, 10, 18, 0, 17, 18, 18, 0, 9]    = 5
[1, 19, 17, 17, 0, 2, 14, 10, 10, 12, 5, 14, 16, 7, 15, 15, 18, 11, 17, 7] = 5

What do you mean by Once it counts the repetition, don't count again? Also, since we want to find the repetition of a specific integer, how would we know which integer to search for if we are not given it? Lastly, the test cases are a bit confusing; which are output and which are input?

I've edited this to try to make it a bit clearer. Is this what you intended? Also, please put answers in for those test cases.

You may want to add some edge cases, like lists with negative, large-magnitude, unique, or no integers.

I have added some answers to the test cases, sorry if I go them wrong

I've voted to close this question until you confirm this is what you intended.

Related (output the non-unique items, instead of the amount of non-unique items).

R, 20 bytes

Is this what you are after?  Uses table to count the occurrences of each of the scan input values.  Tests if count is > 1 and sums the trues.
sum(table(scan())>1)

Try it online!

my mind went to duplicated first -- the humble table is so useful for golfing!

@giuseppe table is a favorite now :)

Bash + coreutils, 18
sort|uniq -d|wc -l

Try it online!

Haskell, 42 bytes
f s=sum[1|x<-[-9^6..9^6],filter(==x)s>[x]]

Try it online! Abuses the fact the the integers in the list are guaranteed to be within -100k and 100k.

APL (Dyalog Unicode), 9 8 bytesSBCS
-1 thanks to ngn
Anonymous tacit prefix function.
+/1<⊢∘≢⌸

Try it online!
+/ sum of
1< whether 1 is less than
…⌸ for each unique element:
 ⊢∘ ignoring the actual unique element,
 ≢ the count of its occurrences

{1<≢⍵}⌸ -> 1<⊢∘≢⌸

@ngn Thanks. Incorporated.

C# (Visual C# Interactive Compiler), 40 bytes
n=>n.GroupBy(c=>c).Count(c=>c.Count()>1)

The first draft of the spec was unclear, and I thought it mean return all the elements that appear more than once. This is the updated version.
Somehow I didn't notice that my code returned the number of elements that appeared once. Thanks to Paul Karam for catching that!
Try it online!

Your output is wrong, it needs to count the elements with 2 or more occurences. It should be n=>n.GroupBy(c=>c).Count(c=>c.Count()>=2). The OP says the answer of this list is 2. Your code returns 5. The change I gave you returns 2.

Or just >1 to keep the 40 bytes count

@PaulKaram I didn't notice that, thanks!

C (clang) 175 117 95 bytes
c(*a,*b){return*a-*b;}r(*l,m){qsort(l,m,4,c);return((!m||l[1]-*l)&l[-1]==*l)+(m?r(l+1,m-1):0);}

Try it online!
This is the first time I've submitted one of these, so let me know if there are any issues with formatting or anything.
Updates from the comments:

-58 to 117 bytes from Jo King
-80 to 95 bytes from ASCII-only

original submission

You need to include any includes your function uses as part of the submission. That said, it compiles perfectly fine without the includes

122

Welcome, nice start.  I'm not a C person but here's a link to a tips for golfing C page

117 bytes => d,i;c(*a,*b){return*a-*b;}r(l[],m){qsort(l,m,4,c);for(i=d=0;++i<m;)d+=((l[i+1]-l[i]||i>m-2)&&l[i-1]==l[i]);return d;}. As @ASCII-only noted, the includes don't affect the compilation of your program

@JoKing Nice! I just learned about some of these tricks to shorten it from the link MickyT posted. Also, does that mean the include does not need to be included in the submission?

@JoKing 100: d;c(*a,*b){return*a-*b;}r(*l,m){qsort(l,m,4,c);for(d=0;~m--;)d+=(!m||l[1]-*l)&l[-1]==*l++;return d;}

@CollinPhillips yes. as you can see in the link i posted, it still compiles fine without the includes

95: c(*a,*b){return*a-*b;}r(*l,m){qsort(l,m,4,c);return((!m||l[1]-*l)&l[-1]==*l)+(m?r(l+1,m-1):0);}

J, 11 9 bytes
-2 bytes thanks to Jonah!
1#.1<1#.=

Try it online!
Original solution:
1#.(1<#)/.~

Try it online!
Explanation:
        /.~   group the list by itself
   (   )      for each group
    1<#       is the length greater than 1
1#.           sum by base-1 conversion

Hey Galen.  1#.1<1#.= for 9 bytes + good ol' self-classify fun.

@Jonah Thanks! Honestly, I wasn't aware of this.

@Jonah Nice!

@Adám and here i was pleased that i'd gotten J to tie with APL.  Foiled again :)

05AB1E, 4 bytes
Ù¢≠O

Try it online!
or as a Test Suite
Explanation
   O  # sum
  ≠   # the false values
 ¢    # in the count
Ù     # of each unique digit in input

So all values that are not 1 are false?

@Adám: Yes, that is correct.

Python 3, 38 bytes
lambda a:sum(a.count(x)>1for x in{*a})

Try it online!

Jelly, 4 bytes
ĠITL

Try it online!
...Or  ĠIƇL
How?
ĠITL - Link: list of integers   e.g. [234, 2, 12, 234, 5, 10, 1000, 2, 99, 234]
Ġ    - group indices by value        [[2,8],5,6,3,9,[1,4,10],7]
 I   - incremental differences       [[6],[],[],[],[],[3,6],[]]
  T  - truthy indices                [1,6]
   L - length                        2

IƇ would filter to keep only truthy results of I ([[6],[3,6]]) which also has the desired length.

Java 8, 74 73 bytes
L->L.stream().filter(i->L.indexOf(i)<L.lastIndexOf(i)).distinct().count()

Try it online.
Explanation:
L->                      // Method with ArrayList parameter and integer return-type
  L.stream()             //  Create a stream of the input-list
   .filter(i->           //  Filter it by:
     L.indexOf(i)        //   Where the first index of a value
     <L.lastIndexOf(i))  //   is smaller than the last index of a value
   .distinct()           //  Deduplicate this filtered list
   .count()              //  And return the count of the remaining values

Uiua, 7 bytes
/+>1⍘⊚⊛

Try it!
/+>1⍘⊚⊛
      ⊛  # classify (i.e. map integers -> naturals)
    ⍘⊚   # inverse where (occurrences)
  >1     # where are they greater than one?
/+       # sum

Ruby, 34 bytes
->a{a.uniq.count{|x|a.count(x)>1}}

Try it online!

Ruby 2.7, 24 bytes: ->a{a.tally.count{_2>1}}

Perl 6, 15 bytes
+*.repeated.Set

Try it online!
Pretty self explanatory. An anonymous code block that gets the count (+) of the Set of elements among the repeated elements of the input (*).
I've realised I've posted almost the exact same solution for a related question.

Python 3, 63 bytes
lambda l:len(C(l)-C({*l}))
from collections import Counter as C

Try it online!

APL (Dyalog Extended), 8 7 bytesSBCS
Anonymous tacit prefix function using Jonah's method.
+/1<∪⍧⊢

Try it online!
+/ the total number occurrences
  literally the sum of Truths
1< where one is less than
∪ the unique elements'
⍧ count in
⊢ the unmodified argument

Haskell, 41 bytes
f(h:t)=sum[1|filter(==h)t==[h]]+f t
f _=0

Try it online!
Count suffixes where the first element h appears exactly once in the part t that comes after.

Haskell, 40 bytes
import Data.List
f l=length$nub$l\\nub l

Try it online!
Stealing the method from other answers.

Dammit, we had the exact same answer

Haskell, 41 bytes
f[]=0
f(a:s)=sum[1|filter(==a)s==[a]]+f s

This solution basically counts how many elements of the list have the same element appear exactly once later in the list.

PHP, 39 bytes
a nice occasion to use variable variables:
foreach($argv as$v)$r+=++$$v==2;echo$r;

takes input from command line arguments. Run with -nr or try it online.

$argv[0] is - and that appears only once in the arguments, so it does not affect the result.

Haskell, 47 bytes
f[]=0
f(a:b)|x<-filter(/=a)b,x/=b=1+f x|1>0=f b

Try it online!
This is the naïve approach.  There is likely something that could be done to improve this.
f[]=0

We return 0 for the empty list
f(a:b)

In the case of a non-empty list starting with a and then b.
|x<-filter(/=a)b,x/=b=1+f x

If filtering a out of b is different from b (that is a is in b) then we return 1 more than f applied to b with the as filtered out.
|1>0=f b

If filtering as doesn't change b then we just run f across the rest.
Here is another similar approach that has the same length:
f[]=0
f(a:b)|elem a b=1+f(filter(/=a)b)|1>0=f b

Try it online!

JavaScript (ES6), 40 bytes
a=>a.map(o=x=>n+=(o[x]=-~o[x])==2,n=0)|n

Try it online!

Japt, 12 11 9 8 6 bytes
ü èÈÊÉ

With lots of help from @ASCII-Only, and suggestions from @Shaggy and @Luis felipe De jesus Munoz.
Try it online!

11

9 9 9?

8 8

7 maybe 6 but probably not

6

6 6

Welcome to Japt! :) If you weren't aware, there's currently an open bounty for Japt solutions. @ASCII-only got you about as low as you can get on this one but another alternative that's closest to your original solution would be ü èÈÊÉ.

Another 6 bytes =D. Welcome to Japt c:

@Shaggy Thanks :) I need to start remembering/figuring out all these shortcuts :)

Wolfram Language 34 bytes
 Length@DeleteCases[Gather@#,{x_}]&

Gather groups identical integers into lists.
DeleteCases[...{x_}] eliminates lists containing a single number.
Length returns the number of remaining lists (each containing two or more identical integers.

Count[{_,__}]@*Gather

Pyth, 6 bytes
l{.-Q{

Try it here
Explanation
l{.-Q{
     {Q   Deduplicate the (implicit) input.
  .-Q     Remove the first instance of each from the input.
l{        Count unique.

Brachylog, 7 bytes
ọzt;1xl

Try it online!
Explanation:
ọ          For every unique element E of the input, [E, how many times E occurs]
 zt        The last elements of the previous value.
   ;1x     With every 1 removed,
      l    how many there are.

Gaia, 6 bytes
e:uDul

Try it online!
e	| eval as a list
 :	| duplicate
  u	| uniquify
   D	| multiset difference; keep only repeated elements
    u	| uniquify
     l	| find length

Arturo, 49 31 bytes
$=>[tally&|enumerate[k,v]->v>1]

Try it
-18 bytes due to Arturo 0.9.83 providing tally and enumerate.
$ => [               ; a function
    tally &          ; create a dictionary of elements and their occurrences from the input
    |                ; then...
    enumerate[k,v]-> ; count the number of key-value pairs where...
    v>1              ; the value (occurrences) is greater than one
]                    ; end function

Pyt, 7 bytes
ĐỤ⇹ɔ⁻žŁ

Try it online!
Đ             implicit input; Đuplicate on the stack
 Ụ            get Ụnique elements
  ⇹ɔ          ɔount occurrences of each in original list
    ⁻žŁ       decrement; remove žeros; get Łength; implicit print

Thunno 2 L, 5 bytes
Uæc1Q

Try it online!
Explanation
Uæc1Q  # Implicit input
U      # Uniquify the input
 æ     # Filter it by:
  c    #  Count in the input
   1Q  #  Is not equal to 1
       # Push the length
       # Implicit output

Element, 40 bytes
_(#'{"2:0+4:'~1+";~2=[''1+""]$2+'[(#]'}`

Try it online!
This requires input to be in a precise format like [234, 2, 1000, 2, 99, 234] (enclosed with [] with a comma and space between integers).
Explanation:
_                                        input
 (#                                      delete the [ at start of input
   '{"                               '}  WHILE the string is non-empty
   '{"2:                             '}    duplicate it
   '{"  0+                           '}    add 0 to coerce to integer (gets next number in array)
   '{"    4:                         '}    make 3 additional copies
   '{"      '                        '}    temporarily move 1 copy to control stack
   '{"       ~                       '}    fetch the current map value for given integer
   '{"        1+                     '}    increment map value
   '{"          "                    '}    retrieve temporary copy of integer (the key for the map)
   '{"           ;                   '}    store updated map value
   '{"            ~                  '}    fetch map value again (1 if 1st instance, 2 if 2nd, etc.)
   '{"             2=                '}    test for map value = 2, this is the first duplication
   '{"               [      ]        '}    IF
   '{"               [''    ]        '}      move stuff from main stack to control stack
   '{"               [  1+  ]        '}      increment the counter of duplicate (bottom of stack)
   '{"               [    ""]        '}      move stuff back to main stack
   '{"                       $       '}    take length of current integer
   '{"                        2+     '}    add 2 (for the comma and space)
   '{"                          '[  ]'}    FOR loop with that number
   '{"                          '[(#]'}      trim those many characters from front of input string
                                       ` output result

Clean, 59 54 bytes
import StdEnv,StdLib
$l=sum[1\\[_,_:_]<-group(sort l)]

Try it online!
Sorts the list, groups adjacent equal elements, and counts the number with more than 1 item.

Retina 0.8.2, 19 bytes
O`.+
m`^(.+)(¶\1)+$

Try it online! Link includes test suite which splits each line on commas. Explanation:
O`.+

Sort equal values together.
m`^(.+)(¶\1)+$

Count the number of runs of at least two values.

Pyth, 10 bytes
lf<1/QT.{Q

Probably a way to golf it, I'm quite rusty with pyth...
Alternate 10 byte version...
lf>lT1.gSk

Try it online!

Rust, 126 bytes
let f=|v:Vec<i32>|{let mut u=v.clone();u.sort();u.dedup();u.iter().filter(|i|v.iter().filter(|n|**n==**i).count()>1).count()};

I give up.  This is basically the same as Ruby. There is "another way" creating an array and indexing into it using the values in the input vector, +100000, however the type conversions (as usize / as i32) take up too much space.

PowerShell, 33 bytes
($args|group|?{$_.Count-1}).Count

Try it online!

MATL, 5 bytes
8#uqz

Try it online! Or verify all test cases.
Explanation
8#u   % Number of ocurrences of each unique value
q     % Subtract 1
z     % Number of nonzeros

PHP (112 Bytes)
<?php $c=0;foreach(array_count_values(json_decode(file_get_contents('php://stdin'))) as $b)if($b>1)$c++;echo $c;

The assignment does not make it clear if the input is received via Stdin in exactly given format or as separate parameters in Argv, so here is a variant for argv, 91 Bytes:
<?php array_shift($argv);$c=0;foreach(array_count_values($argv) as $b)if($b>1)$c++;echo $c;

Yes, you can take input via the command line arguments (as per standard IO formats). Though wouldn't there be problems if the filename was numerical?

@JoKing Sure, I fixed it.

Pyth, 8 bytes
lfthTr8S

Try it online here, or verify all the test cases at once here.

Factor, 42 bytes
: d ( x -- ) duplicates members length . ;

Try it online!

k, 8 bytes
+/1<#:'=
reads as: sum (length each group) > 1
+/ is sum (plus over)

#:' is length each

= is group (ex. =1 2 1 6 7 2 generates 1 2 6 7!(0 2;1 5;,3;,4) (dictionary of unique value and its positions)

Use example (first test case)
+/1<#:'=1 10 16 4 8 10 9 19 2 15 18 19 10 9 17 15 19 5 13 20

writes 4

Perl 5 -ap, 35 bytes
map$k{$_}++,@F;$_=grep$_>1,values%k

Try it online!

Stax, 5 bytes
ëB♀╡╙

Run and debug it

Japt -x, 5 bytes
ü ®¦q

Run it online

Husk, 5 bytes
LuṠ-u

Try it online!
L        The number of
 u       unique elements of
  Ṡ-u    the input with every unique element removed once.

C (gcc), 71 bytes
f(r,l,t)int*r;{int n[7<<15]={};for(t=0;l;t+=!~n[r[--l]+100000]--);r=t;}

Try it online!
Naive approach. 7<<15=229376.

70 bytes

Vyxal, 5 bytes
UÞ⊍UL

Try it Online!
Typical symmetric difference with the unique values in the list, take the length of the unique values in that list.

Vyxal, 4 bytes
Ċċ∑t

Try it Online!
Just another 4 byter
Explained
Ċċ∑t
Ċ     # [[item, count(item)] for item in input]
 ċ    # Each item != 1?
  ∑   # Summate. Because this is implemented as reduce by addition, it vectorises element-wise when folding.
   t  # Get the last item of that (the number of counts that != 1)

Created with the help of Luminespire.

JavaScript (Node.js), 93 bytes
a=>Object.values(a.reduce((a,c)=>Object.assign(a,{[c]:(a[c]|0)+1}),{})).filter(i=>i>1).length

Try it online!

JavaScript (Node.js), 67 bytes
a=>[...new Set(a.filter(e=>a.indexOf(e)!=a.lastIndexOf(e)))].length

Try it online!

APL(NARS), 9 chars, 18 bytes
{≢∪⍵∼⍦∪⍵}

test:
  f←{≢∪⍵∼⍦∪⍵}
  f 1 2 2 3 1 1 1 1 1 1
2
  f 234, 2, 12, 234, 5, 10, 1000, 2, 99, 234
2
  f 1, 10, 16, 4, 8, 10, 9, 19, 2, 15, 18, 19, 10, 9, 17, 15, 19, 5, 13, 20
4
  f 11, 8, 6, 15, 9, 19, 2, 2, 4, 19, 14, 19, 13, 12, 16, 13, 0, 5, 0, 8
5