Parabola calculations - follow-up Previous question

After applying the suggestions, I wanted to revise the question with the new code because I don't think this is good enough.

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;math.h&gt;
#include &lt;string.h&gt;

/* global loop counters */
int i=0, j, k;

/* to find a, b, and c from the input */
float A(const char* in){
    char c[5];
    if(in[0] != 'x'){ /* if first letter isn't x
                      ** eg there is sth in front of x */
        while(in[i] != 'x'){ /* until x in found */
            i++; /* increment i */
        }
        strncpy(c, in, i); /* copy first i characters of in to c */
        return atoi(c); /* make c an int and return */
    }

    if(in[0] == '-' &amp;&amp; in[1] == 'x') /* if first two letters are "x" */
        return -1; /* -x = -1 * x */

    return 1; /* if nothing is in front of x, a is 1 */
}

float B(const char* in){
    char c[5];
    int b=1;

    j = i += 3; /* three characters after x (^2+ or ^2-) */
    while(in[j] != 'x') { /* until x is found */
        j++; /*increment j */
    }

    if(in[j-1] != '+' &amp;&amp; in[j-1] != '-'){ /* if not -x or +x
                                          ** eg if there is b */
        strncpy(c, in+i, j); /* copy j characters starting from i */
        b = atoi(c); /* make c an int and assign this to b */
    }

    if(in[j-1] == '-') /* if there is a minus sign */
        b = -b; /* negate b */

    return b; /* return b */
}

float C(const char* in){
    char c[5];
    k = j += 1; /* one character after x (+ or -) */
    while(in[k] != '=') { /* until we find a = */
        k++; /* increment k */
    }
    strncpy(c, in+j, k); /* copy k characters starting from j */
    return atoi(c); /* make c an int and return */
}

int main(int argc, char const *argv[]) {
    if(argc == 1){ //if no arguments given
        printf("Usage: %s &lt;quadratic equation&gt;\n", argv[0]);
        return EXIT_FAILURE;
    }

    /* variables for main function */
    float discriminant;
    float a, b, c; /* coefficients */
    float vx, vy; /* vertex */
    char sign; /*positive or negative or zero */

    a=A(argv[1]);
    b=B(argv[1]);
    c=C(argv[1]);

    /*                   b^2 - 4ac     */
    discriminant = pow(b, 2) - 4 * a * c;

    if(discriminant &lt; 0) {
        sign = 'n';
        printf("Parabola doesn't have real roots.\n");
    } else if(discriminant == 0.00f) {
        sign = 'z';
        printf("Parabola has one real root.\n");
    } else if(discriminant &gt; 0) {
        sign = 'p';
        printf("Parabola has two real roots.\n");
    }

    /* vertex points */
    vx = -( b / (2*a) );
    vy = -( discriminant / (4*a) );

    printf("Parabola looks %s\n", a &lt; 0 ? "downwards" : "upwards");
    printf("Vertex: V(%.2f,%.2f)\n", vx, vy);
    printf("Axis of symmetry: %.2f\n", vx);
    printf("y-intercept: %.2f\n", c);

    if(sign=='n'); /* if negative, doesn't have roots */
    else if(sign=='z') /* if zero, root is vertex' abcsissa is root */
        printf("x-intercept: %.2f\n", vx);
    else if(sign=='p'){ /*if positive, roots can be calculated... */
        float x1, x2;
        x1=(-b + sqrt(discriminant)) / (2*a);
        x2=(-b - sqrt(discriminant)) / (2*a);
        printf("x-intercepts: %.2f and %.2f\n", x1, x2);
    }
}
General: Do not use int for float values.
Either use float and float functions like sqrtf() or use double.
When fabs(b) is close to sqrt(discriminant), OP's approach suffers severe loss of precision due to the + or -.  More numerically stable code posted.  Still needs some divide by 0.0 checks.

//x1=(-b + sqrt(discriminant)) / (2*a);
//x2=(-b - sqrt(discriminant)) / (2*a);
float s = sqrtf(discriminant);
if (b &lt; 0) {
  x1 = (-b + s)/(2*a);
  x2 = c/x1;
} else if (b &gt; 0) {
  x2 = (-b - s)/(2*a);
  x1 = c/x2;
} else {
  x1 = s/(2*a);
  x2 = -x1;
}

pow(b, 2) - 4 * a * c; also suffers from severe loss of precession when b*b is about 4*a*c.  If OP is interested there are method to better calculate that too.  It comes down to how quick you want to write/execute the code versus the need for correctness on edge conditions.
Unclear format usage.  About 45% of all float numbers will print as 0.00 with "%.2f".  Suggest a more meaningful format  

   // printf("Vertex: V(%.2f,%.2f)\n", vx, vy);
   printf("Vertex: V(%e,%e)\n", vx, vy);

Dangerous code.  Nothing stop code from incrementing into la-la land.  If this A() and B() are only used in this controlled environment, make them static, else they should robustly handle all sorts of string inputs.

float A(const char* in) {
  ...
  while(in[i] != 'x'){ /* until x in found */
    i++; /* increment i */
  }

More weak code.  Nothing insures that c will be a string after the strncpy call.  Just use strtol() or strtof().

strncpy(c, in, i); /* copy first i characters of in to c */
return atoi(c);

Unclear why code is using atoi(), yet returning float.
Corner case: With b = atoi(c);, should c have the textual value of -INT_MIN, then assignment to b is UB.
Consider printing something when sign=='n'
Make a clean separation of parsing form quadratic calculation.  (2 functions)