Validating a Battleship board Do you know the game Battleship? Well, I want to play with my little brother, but before we can begin we need to set up our ships on the board. This is your input.
Now, we need to check that the ships that we set up are valid. This is where you come in to help. Your task is to write a program or function which checks whether the given 2d array (your board/input) is a valid board or not.
The input will be a 2d array, where 1 represents part of a ship and 0 represents part of the ocean.
The rules:

There must be:

One battleship (size 4)
Two cruisers (size 3)
Three destroyers (size 2)
Four submarines (size 1)


Any additional ships are not allowed, and neither are missing ships
Each ship must be either vertical or horizontal (aside from submarines, which are a single grid space)
The ships cannot overlap, but may be adjacent

in addition, you must solve this with a BF function (naturally the class will be called BF) which receives the 2d array(input) and uses a validate function. Afterward, you are free to manipulate the 2d array however you want and add any functions that you want.

here are some more examples(inputs) that your code must pass:
is valid:
 {1,1,1,1,0,0,0,0,0,0},
 {1,1,1,1,0,0,0,0,0,0},
 {1,1,1,1,0,0,0,0,0,0},
 {1,1,1,1,0,0,0,0,0,0},
 {1,1,1,1,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0},

InvalidShapeOfBoat which is invalid-&gt;
 {1,0,0,0,0,1,1,0,0,0},
 {1,0,0,0,0,0,0,0,1,0},
 {1,1,0,0,1,1,1,0,1,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,1,0},
 {0,0,0,0,1,1,1,0,0,0},
 {0,0,0,0,0,0,0,0,1,0},
 {0,1,0,1,0,0,0,0,0,0},
 {0,1,0,0,0,0,0,1,0,0},
 {0,0,0,0,0,0,0,0,0,0},

wrong ships, result is false-
 {1,0,0,0,0,1,1,0,0,0},
 {1,0,1,0,0,0,0,0,1,0},
 {1,0,1,0,1,1,1,0,1,0},
 {1,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,1,0},
 {0,0,0,0,1,1,1,0,0,0},
 {0,1,0,0,0,0,0,0,1,0},
 {0,0,0,1,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,1,0,0},
 {0,0,0,0,0,0,0,0,0,0},

missing ships, is false-&gt;
 {0,0,0,0,0,1,1,0,0,0},
 {0,0,1,0,0,0,0,0,1,0},
 {0,0,1,0,1,1,1,0,1,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,1,0},
 {0,0,0,0,1,1,1,0,0,0},
 {0,0,0,0,0,0,0,0,1,0},
 {0,0,0,1,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,1,0,0},
 {0,0,0,0,0,0,0,0,0,0},

check contact, is true-&gt;
 {1,1,1,0,0,0,0,0,0,0},
 {1,1,0,0,0,0,0,0,1,0},
 {1,1,0,0,1,1,1,0,1,0},
 {1,0,0,0,0,0,0,0,0,0},
 {1,0,0,0,0,0,0,0,1,0},
 {0,0,0,0,1,1,1,0,0,0},
 {0,0,0,0,0,0,0,0,1,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,1,0,0},
 {0,0,0,0,0,0,0,0,0,0},

check another one with contact-&gt;
 {1,1,1,0,0,0,0,0,0,0},
 {1,1,0,0,0,0,0,0,1,0},
 {1,1,0,0,1,1,1,0,1,0},
 {1,0,0,0,0,0,0,0,0,0},
 {1,0,0,0,0,0,0,0,1,0},
 {0,0,0,0,1,1,1,0,0,0},
 {0,0,0,0,0,0,0,0,1,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,1,0,0},
 {0,0,0,0,0,0,0,0,0,0},

check invalid, is false-&gt;
 {0,1,1,1,0,0,0,0,0,0},
 {0,0,0,1,1,1,0,0,0,0},
 {0,1,1,1,0,0,0,0,0,0},
 {0,0,0,1,1,1,0,0,0,0},
 {0,1,1,1,0,1,1,0,0,0},
 {0,1,0,0,0,0,1,1,0,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0,0,0},

random board which is false-&gt;
{0,1,0,0,0,0,0,0,0,0},
 {1,1,1,1,0,0,0,0,0,0},
 {1,0,1,1,1,0,0,0,0,0},
 {1,1,0,0,0,0,0,0,0,0},
 {1,1,0,0,0,0,0,0,0,0},
 {0,1,0,0,0,0,0,0,1,0},
 {0,0,1,0,0,0,0,0,1,0},
 {0,0,0,0,0,0,0,0,0,0},
 {0,0,0,0,1,0,0,0,0,0},
 {0,0,0,0,1,0,0,0,0,0},

Who's code will be the shortest byte solution that passes all these examples successfully?! Good luck. ;)
Any language is allowed.
on the 16th I will award the winner with a nice green tick:)
JavaScript (ES6),  162  158 bytes
Returns 0 if the grid is invalid, or a positive integer otherwise.

m=&gt;(o=0,g=u=&gt;m.some((r,y)=&gt;r.some((v,x)=&gt;v&amp;&amp;[0,1].map(d=&gt;(r=(w,X=x+!d*w,R=m[y+d*w]||0)=&gt;R[X]&amp;&amp;R[R[X]--,u&amp;(k=1&lt;&lt;w*3)*7&amp;&amp;g(u-k),r(-~w),X]++)``)))|u||++o)(668)*o

Try it online!
Commented
m =&gt; (                       // m[] = input matrix
  o = 0,                     // o = result
  g = u =&gt;                   // g is a recursive function taking a bit mask u
                             // holding the ship counters on 4 x 3 bits
  m.some((r, y) =&gt;           //   for each row r[] at position y in m[]:
    r.some((v, x) =&gt;         //     for each value v at position x in r[]:
      v &amp;&amp;                   //       abort if v is not set
      [0, 1].map(d =&gt;        //       otherwise, look for a horizontal ship (d = 0)
        (                    //       or a vertical ship (d = 1):
          r = (              //         r is a recursive function taking:
            w,               //           w = ship width - 1
            X = x + !d * w,  //           X = position of the cell in ...
            R = m[y + d * w] //           ... R[] = row of the cell
                || 0         //           (force it to 0 if undefined)
          ) =&gt;               //
          R[X] &amp;&amp;            //           abort if R[X] is not set
          R[                 //
            R[X]--,          //           otherwise, set the cell to 0
            u &amp; 7 *          //           if there's still at least one ship of
            (k = 1 &lt;&lt; w * 3) //           width w to be found in the grid:
            &amp;&amp; g(u - k),     //             do a recursive call to g with u updated
            r(-~w),          //           do a recursive call to r with w + 1
            X                //
          ]++                //           restore the cell afterwards
        )``                  //         initial call to r with u zero'ish
      )                      //       end of map()
    )                        //     end of some()
  )                          //   end of some()
  | u || ++o                 //   increment o if the grid has been cleared and all
                             //   boats have been found
)(668)                       // initial call to g with u = 668 (001 010 011 100)
* o                          // multiply by o