Counting the number of mismatches by field MONGODB

Consider this highly condensed version of docs supplied by the OP:

var r = [
    {controlOperator : "admin"},
    {controlOperator : "admin"},
    {controlOperator : "admin"},
    {controlOperator : "buzz"},
    {controlOperator : "buzz"},
    {controlOperator : "steve"}
];

Here is a way to get the desired output:

// admin and buzz will be found.
// dave will not be found and is not in input set; result = 0
// steve is in input set but not in ops targets so will not show up at all
var ops = ['admin','buzz','dave']

c=db.foo.aggregate([
    // Perform all top level filterings here.  At a minimum we filter for
    // controlOperator but add more as needed:                                    
    {$match: {controlOperator: {$in: ops} }}

    // Let initial $group do the heavy lifting of counting                        
    ,{$group: {_id: "$controlOperator", N: {$sum:1}}}

    // OK.  Things that are not found will not make it into $group,               
    // so we have to turn the problem around and iterate over ops                 
    // to see what is NOT there.                                                  
    // Start by turning the output set into a single doc with an                  
    // array so we can exploit array functions:                                   
    ,{$group: {_id: null, M: {$push: {name: "$_id", N:"$N"}}}}

   
    // Rebuild M but from the perspective of the target ops list,                 
    // not the M array.  If we find an op name in the list, we                    
    // keep the result else we invent a new item with N = 0:                      
    ,{$project: {M: {$map: {
        input: ops,
            in: {$let: {
                vars: {ee: {$filter: {input: '$M',
                           as: 'zz',
                           cond: {$eq:['$$zz.name','$$this']}
                             }}
                      },
                in: {$cond: [
                        {$gt:[{$size:'$$ee'},0]}, // IF found                     

                        // THEN take it; only 0 or 1 items thanks to              
                        // $group.  The item is an array so take $first:          
                        {$first:'$$ee'},

                        // ELSE create a zero entry:                              
                        {name:'$$this', N:0}
                     ]}
            }}
        }}
    }}

    // At this point we have all info we need, but if you really want             
    // to break up that M array, do this.  Note that we opt for "good"            
    // key values here, i.e.                                                      
    //   {name: "admin", N:3}  // GOOD                                            
    // vs. the OP target which puts rvals into the key space:                     
    //   {"admin":3}  // Less good                                                
    ,{$unwind: '$M'}
    ,{$project: {_id:false, name: '$M.name', N:'$M.N'}}

]);

OPINION: This seems like a lot of work considering the client knows the full ops list and can do this:

c=db.foo.aggregate([
    {$match: {controlOperator: {$in: ops} }}
    ,{$group: {_id: "$controlOperator", N: {$sum:1}}}
]);

c.forEach(function(doc) {
    var x = ops.indexOf(doc['_id']);
    print(doc['_id'],x);
    if(x != -1) {
        print(doc);
        ops.splice(x,1); // remove from ops list...
    }
});

// What hasn't been removed is zero:
print("the following are zero:", ops);

Finally: there is potentially a cool use of $setUnion here by taking the ops targets, changing them into a "default" set of {op:name, N:0} objects, and then merging the calculated results on top. Those targets with no group will remain as N:0. I cannot get $setUnion to work against sets of objects though, only scalars.