Algorithms

static void Main(string[] args)
{
    StringBuilder sb = new StringBuilder();
    int j = 100;
    for (int i = 100; i < 101000; i++)
    {
        if (j > 999) j = 100;
        sb.Append((j*10).ToString() + " ");
        j++;
    }
    string s = sb.ToString();


    int idx = 0;
    int startidx = 0;
    int length = s.Length;
    List<int> nrs = new List<int>((int)(length*0.25));

    var watch = Stopwatch.StartNew();
    do
    {
        if (s[idx] == ' ')
        {
            if(idx>startidx)
                nrs.Add(atoi(s, startidx, idx));
            startidx = idx + 1;
        }
        idx ++;
    }
    while (idx < length);
    Console.WriteLine(watch.ElapsedMilliseconds);
    Console.ReadLine();
}


static int atoi(string c, int start, int len) {
  int res = 0;
  int i = start;
  len += start;
  while (i<len && c[i] >= '0' && c[i] <= '9')
    res = res * 10 + c[i++] - '0';
  return res;
}

PaulowniaK wrote:

How can I improve my code in C++?

PaulowniaK wrote:

CString::Find()

// Args:
//  txt: the string
//  txt_size: the string size (including the NULL terminator)
//  a: the int array
//  max_count: the int array size.
// Returns: the number of found integers.
// Remark: if the string contains more integers than array capacity, only max_count integers will be returned.
int get_all_numbers( const char * txt, int txt_size, int * a, int max_count)
{
  const char * p0 = txt;
  const char * p1 = NULL;
  const char * guard = p0+txt_size-1;
  int count = 0;
  while (p1 < guard && count < max_count)
  {
    a[count++] = (int) strtol(p0, (char**)&p1, 10);
    p0 = p1;  
  }
  return count;
}

123lucy45 wrote:

i need an algorithm itself

Valeriant wrote:

I also read and tried the code from http://en.wikipedia.org/wiki/Ellipse[^], following the links in wikipedia. This function to generate an ellipse is almost the same as DrawClosedCurve() or DrawEllipse(), using that I still can't get the outer most point to put the line.

private class EllipseOuterXPoints
{
    internal double left_x = double.MaxValue;
    internal double left_y = double.MaxValue;
    internal double right_x = double.MinValue;
    internal double right_y = double.MinValue;

    internal void CheckPoint(double x, double y)
    {
        if (x < left_x)
        {
            left_x = x;
            left_y = y;
        }

        if (x > right_x)
        {
            right_x = x;
            right_y = y;
        }
    }
}

private EllipseOuterXPoints DrawEllipse(Graphics g, double center_x, double center_y, double semi_minor, double semi_major, double angle)
{
    // *** Return value ***
    EllipseOuterXPoints OuterPoints = new EllipseOuterXPoints();

    // *** Rotation angle in radians, sine and cosine ***
    double beta = -angle * (Math.PI / 180);
    double sin_beta = Math.Sin(beta);
    double cos_beta = Math.Cos(beta);

    // *** Calculate increment by a rough estimation of the number of points needed (empirical!) ***
    double increment = (Math.PI * 2) / (semi_major * 2);

    // *** Draw the ellipse ***
    double sin_alpha;
    double cos_alpha;
    double x1 = 0;
    double y1 = 0;
    double x2 = 0;
    double y2 = 0;
    double prev_x1 = 0;
    double prev_y1 = 0;
    double prev_x2 = 0;
    double prev_y2 = 0;
    double first_x1 = 0;
    double first_y1 = 0;
    Pen mypen = new Pen(Color.Black);
    for (double alpha = 0; alpha < Math.PI; alpha += increment)
    {
        sin_alpha = Math.Sin(alpha);
        cos_alpha = Math.Cos(alpha);

        x1 = center_x + ((semi_major * cos_alpha * cos_beta) - (semi_minor * sin_alpha * sin_beta));
        y1 = center_y + ((semi_major * cos_alpha * sin_beta) + (semi_minor * sin_alpha * cos_beta));

        sin_alpha = Math.Sin(alpha * 2);
        cos_alpha = Math.Cos(alpha * 2);

        x2 = center_x + ((semi_major * cos_alpha * cos_beta) - (semi_minor * sin_alpha * sin_beta));
        y2 = center_y + ((semi_major * cos_alpha * sin_beta) + (semi_minor * sin_alpha * cos_beta));

        if (alpha == 0)
        {
            first_x1 = x1;
            first_y1 = y1;
        }
        else
        {
            g.DrawLine(mypen, (float)prev_x1, (float)prev_y1, (float)x1, (float)y1);
            g.DrawLine(mypen, (float)prev_x2, (float)prev_y2, (float)x2, (float)y2);
        }

        // *** Find the outer X points ***
        OuterPoints.CheckPoint(x1, y1);
        OuterPoints.CheckPoint(x2, y2);

        prev_x1 = x1;
        prev_y1 = y1;

        prev_x2 = x2;
        prev_y2 = y2;
    }
    g.DrawLine(mypen, (float)x2, (float)y2, (float)first_x1, (float)first_y1);

    // *** Return outer X points ***
    return OuterPoints;
}

// *** Calculate increment by a rough estimation of the number of points needed (empirical!) ***
double increment = (Math.PI * 2) / (semi_major * 2);

private void picCanvas_Paint(object sender, PaintEventArgs e)
{
    EllipseOuterXPoints OuterPoints1 = DrawEllipse(e.Graphics, picCanvas.Size.Width / 2, picCanvas.Size.Height / 4, picCanvas.Size.Height / 8, picCanvas.Size.Width / 4, 10);
    EllipseOuterXPoints OuterPoints2 = DrawEllipse(e.Graphics, picCanvas.Size.Width / 2, (picCanvas.Size.Height / 4) * 3, picCanvas.Size.Height / 8, picCanvas.Size.Width / 4, 10);

    Pen mypen = new Pen(Color.Black);
    e.Graphics.DrawLine(mypen, (float)OuterPoints1.left_x, (float)OuterPoints1.left_y, (float)OuterPoints2.left_x, (float)OuterPoints2.left_y);
    e.Graphics.DrawLine(mypen, (float)OuterPoints1.right_x, (float)OuterPoints1.right_y, (float)OuterPoints2.right_x, (float)OuterPoints2.right_y);
}