#include <math.h>
#include <stdio.h>

double func( double arr[], unsigned n, double* max )
{
	double sum =  0 . 0 ;
	unsigned int i =  0 , flag =  0 , insPos =  0 ;
	
	while( i < n ) {
		double val = arr[i];
		if( val ==  0 . 0  ) {
			if( !insPos ) insPos = i+ 1 ;
		} else {
			if( val >  0 . 0  ) {
				if( flag <  2  ) { flag =  1 ; sum += val; }
			} else {
				if( flag ==  1  ) { flag =  2 ; }
				val = fabs( val );
			}
			if( *max < val ) *max = val;
			if( insPos ) {
				arr[ insPos++ -  1  ] = arr[ i ];
			}
		}
		i++;
	}
	if( insPos )
		for( --insPos; insPos < n; insPos++ ) arr[ insPos ] =  0 . 0 ;
	return sum;
}

int main()
{
	double arr[] = { - 3 . 0 , - 2 . 0 ,  5 ,  0 ,  0 ,  7 ,  6 ,  0 , - 4 . 0 ,  3 ,  4  };
	unsigned sz = sizeof(arr)/sizeof(double), i;
	double max =  0 . 0 ;
	
	double sum = func( arr, sz, &max );

	printf( "Sum = %f, |Max| = %f, array:\n", sum, max );
	for( i =  0 ; i < sz; i++ )
		printf( "[%d] = %f\n", i, arr[i] );
	return  0 ;
}

#include <math.h>
#include <stdio.h>

double func( double arr[], unsigned n, double* max )
{
	double sum =  0 . 0 ;
	unsigned int i =  0 , flag =  0 , insPos =  0 ;
	
	while( i < n ) {
		double val = arr[i];
		if( val ==  0 . 0  ) {
			if( !insPos ) insPos = i+ 1 ;
		} else {
			if( val >  0 . 0  )	flag++;
			else {
				if( flag ==  1  ) sum += val;
				val = fabs( val );
			}
			if( *max < val ) *max = val;
			if( insPos ) arr[ insPos++ -  1  ] = arr[ i ];
		}
		i++;
	}
	if( insPos )
		for( --insPos; insPos < n; insPos++ ) arr[ insPos ] =  0 . 0 ;
	return sum;
}

int main()
{
	double arr[] = {  8 , - 3 . 0 , - 2 . 0 ,  5 ,  0 ,  0 ,  7 ,  6 ,  0 , - 12 . 0 ,  3 ,  4  };
	unsigned sz = sizeof(arr)/sizeof(double), i;
	double max =  0 . 0 ;
	
	double sum = func( arr, sz, &max );

	printf( "Sum = %f, |Max| = %f, array:\n", sum, max );
	for( i =  0 ; i < sz; i++ )
		printf( "[%d] = %f\n", i, arr[i] );
	return  0 ;
}

		if( val ==  0 . 0  ) {
			flag++;
			if( !insPos ) insPos = i+ 1 ;
		} else {

double sumbetween(double*a,int n)
{
   double sum =  0 ;
   int i =  0 ;
   while(a[i++]<= 0 );
   while(a[i]<= 0 )sum+=a[i++];
   return sum;
}

::memmove(arr[i], arr[i +  1 ], (--n - i) * sizeof(double))

::memmove(&arr[i], &arr[i +  1 ], (--n - i) * sizeof(double))

void * memmove(void *dst0, const void *src0, size_t length)
{
        char *dst = dst0;
        const char *src = src0;
        size_t t;

        if (length ==  0  || dst == src)          /* nothing to do */
                goto done;

        /*
         * Macros: loop-t-times; and loop-t-times, t>0
         */
#define TLOOP(s) if (t) TLOOP1(s)
#define TLOOP1(s) do { s; } while (--t)

        if ((unsigned long)dst < (unsigned long)src) {
                /*
                 * Copy forward.
                 */
                t = (uintptr_t)src;     /* only need low bits */
                if ((t | (uintptr_t)dst) & wmask) {
                        /*
                         * Try to align operands.  This cannot be done
                         * unless the low bits match.
                         */
                        if ((t ^ (uintptr_t)dst) & wmask || length < wsize)
                                t = length;
                        else
                                t = wsize - (t & wmask);
                        length -= t;
                        TLOOP1(*dst++ = *src++);
                }
                /*
                 * Copy whole words, then mop up any trailing bytes.
                 */
                t = length / wsize;
                TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize);
                t = length & wmask;
                TLOOP(*dst++ = *src++);
        } else {
                /*
                 * Copy backwards.  Otherwise essentially the same.
                 * Alignment works as before, except that it takes
                 * (t&wmask) bytes to align, not wsize-(t&wmask).
                 */
                src += length;
                dst += length;
                t = (uintptr_t)src;
                if ((t | (uintptr_t)dst) & wmask) {
                        if ((t ^ (uintptr_t)dst) & wmask || length <= wsize)
                                t = length;
                        else
                                t &= wmask;
                        length -= t;
                        TLOOP1(*--dst = *--src);
                }
                t = length / wsize;
                TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src);
                t = length & wmask;
                TLOOP(*--dst = *--src);
        }
done:
        return (dst0);
}

typedef int word;               /* "word" used for optimal copy speed */

#define wsize   sizeof(word)
#define wmask   (wsize -  1 )

double bigarr[ 100000 ];

int main()
{
	int n =  0 ;
	double arr[] = {  8 ,  0 , - 2 . 0 ,  5 ,  0 ,  0 ,  7 ,  6 ,  0 , - 12 . 0  };
	for( n =  0 ; n <  10000 ; n++ ) memcpy( &bigarr[n], arr,  10 *sizeof(double) );
	unsigned sz = sizeof(bigarr)/sizeof(double), i;
	double max =  0 . 0 , sum;

	time_t b = time(NULL);
	sum = func( bigarr, sz, &max );
	printf( "func(): %f\n", difftime( time(NULL), b ) );

	for( n =  0 ; n <  10000 ; n++ ) memcpy( &bigarr[n], arr,  10 *sizeof(double) );

	b = time(NULL);
	sum = func1( bigarr, sz, &max );
	printf( "func1(): %f\n", difftime( time(NULL), b ) );
	
	return  0 ;
}

bs@Hearse:~/prj> gcc -O3 -o test1 test.c 
bs@Hearse:~/prj> ./test1
func(): 0.000000
func1(): 33.000000