Mad Libs number sequences
JavaScript (ES6),  158 ... 145  144 bytes
Takes input as (a,b,c,n), with \$a\$, \$b\$ and \$c\$ 0-indexed.

(a,b,c,n)=&gt;(g=x=&gt;[(d=[...x+''],i+=C=![d[0]-x%10,d+''&gt;d.sort(),/1/.test(x)][c])&gt;n,x&gt;=n,x&gt;n&amp;C][a]?a-1?x:C&amp;x==n:g([y,x+y,x+3][b],y+=b||x))(i=0,y=1)

Try it online!
Commented
(a, b, c, n) =&gt; (              // given the challenge parameters ...
  g = x =&gt;                     // g is a recursive function taking the current value x
    [                          // this is the array for A
      (                        //   a = 0:
        d = [...x + ''],       //     d[] = array of digits in x
        i += C =               //     increment i if C is true
          ![                   //     set C if the condition is false:
            d[0] - x % 10,     //       c = 0: the 1st and the last digits are not equal
            d + '' &gt; d.sort(), //       c = 1: the digits are not in sorted order
            /1/.test(x)        //       c = 2: there's a '1' in x
          ][c]                 //     pick the relevant condition for C
      ) &gt; n,                   //     exit if i is greater than n
      x &gt;= n,                  //   a = 1: exit if x is greater than or equal to n
      x &gt; n &amp; C                //   a = 2: exit if x is greater than n and C is true
    ][a]                       // pick the relevant condition for A
    ?                          // if we're done:
      a - 1 ? x                //   if a is not equal to 1, return x
            : C &amp; x == n       //   otherwise, test whether C is true and x is equal to n
    :                          // else:
      g(                       //   do a recursive call:
        [                      //     update x:
          y,                   //       b = 0: x = y (Fibonacci)
          x + y,               //       b = 1: x += y (triangular numbers)
          x + 3                //       b = 2: x += 3 (multiples of 3)
        ][b],                  //     pick the relevant update for B
        y += b || x            //     if b = 0, add x to y (for Fibonacci)
                               //     otherwise, add b to y (we actually just need to
                               //     add 1 for triangular numbers; for multiples of 3,
                               //     y is ignored anyway)
      )                        //   end of recursive call
)(i = 0, y = 1)                // initial call to g with x = i = 0 and y = 1