void daRegressionTest() { DynArr* DA = newDynArr(); unsigned int i; int var[100]; printf("============== daRegressionTest Begin ==============\n"); for(i = 0; i < 100; i++) { daAdd(DA, (void*) &var[i]); assert(daGet(DA, i) == (void*) &var[i]); assert(daGetSize(DA) <= daGetCapacity(DA)); } i = daGetSize(DA); daDel(DA, 50); assert(daGet(DA, 50) == (void*) &var[51]); assert(daGetSize(DA) == i - 1); daFastDel(DA, 50); assert(daGet(DA, 50) == (void*) &var[99]); assert(daGetSize(DA) == i - 2); delDynArr(DA); DA = newDynArr(); daReserve(DA, 21); assert(daGetCapacity(DA) == 21); for(i = 0; i < 21; i++) { daAdd(DA, (void*) &var[i]); assert(daGet(DA, i) == (void*) &var[i]); assert(daGetSize(DA) <= daGetCapacity(DA)); } assert(daGetCapacity(DA) == 21); delDynArr(DA); printf("============== daRegressionTest End ================\n"); }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { char check; char cmp; DynArr *stck; stck = newDynArr(100); do { check = nextChar(s); if (check == '(' || check == '{' || check == '[') { pushDynArr(stck, check); } else if (check == ')' || check == '}' || check == ']') { if (isEmptyDynArr(stck)) { return 0; } cmp = topDynArr(stck); if ((check == ')' && cmp == '(') || (check == '}' && cmp == '{') || (check == ']' && cmp == '[')) { popDynArr(stck); } } } while (check != '\0'); if (isEmptyDynArr(stck)) { return 1; } else return 0; }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { char c; DynArr *Parens; Parens = newDynArr(5); // Arbitrary first length //printf("DEBUG 40 s = %p\n", s); while ( (c = nextChar(s)) != '\0' ) { if (EQ(c, '(')) pushDynArr(Parens, ')'); else if (EQ(c, '{')) pushDynArr(Parens, '}'); else if (EQ(c, '[')) pushDynArr(Parens, ']'); else if (EQ(c, ')') || EQ(c,'}') || EQ(c, ']')) { if(isEmptyDynArr(Parens)) return 0; // We already know we're unbalanced else if ( EQ(topDynArr(Parens), c)) popDynArr(Parens); } } if (isEmptyDynArr(Parens)) return 1; // True, is balanced else return 0; // False, is not balanced }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { /* FIXME: You will write this function */ DynArr* work; work = newDynArr(sizeof(s)); char testChar = 0; do{ testChar = nextChar(s); if (testChar == '(') { pushDynArr(work, ')'); } else if (testChar == ')') { if (isEmptyDynArr(work)) { return 0; } else if (testChar != topDynArr(work)) { return 0; } else popDynArr(work); } else if (testChar == '[') { pushDynArr(work, ']'); } else if (testChar == ']') { if (isEmptyDynArr(work)) { return 0; } else if (testChar != topDynArr(work)) { return 0; } else popDynArr(work); } else if (testChar == '{') { pushDynArr(work, '}'); } else if (testChar == '}') { if (isEmptyDynArr(work)) { return 0; } else if (testChar != topDynArr(work)) { return 0; } else popDynArr(work); } } while (testChar != '\0'); if (!isEmptyDynArr(work)) return 0; return 1; }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { /* FIXME: You will write this function */ struct DynArr *arr = newDynArr(7); char a; if (s != 0) { while (a = nextChar(s) != '\0') { if (&a == "(") pushDynArr(arr, a); else if (&a == "{") pushDynArr(arr, a); else if (&a == "[") pushDynArr(arr, a); else if (&a == ")") { if(topDynArr(arr) == '(') popDynArr(arr); else return 0; } else if (&a == "}") { if(topDynArr(arr) == '{') popDynArr(arr); else return 0; } else if (&a == "]") { if(topDynArr(arr) == '[') popDynArr(arr); else return 0; } } } return 0; }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { /* FIXME: You will write this function */ /* Check if s is null */ assert(s); /* Create stack to hold letters */ DynArr* stack = newDynArr(16); char c = nextChar(s); while(c) { if(c == '(' || c == '{' || c == '[') pushDynArr(stack, c); else if(c == ')' || c == '}' || c == ']') { int balanced = 0; if(!isEmptyDynArr(stack)) { char top = topDynArr(stack); if(top == '(' && c == ')') balanced = 1; else if(top == '{' && c == '}') balanced = 1; else if(top == '[' && c == ']') balanced = 1; } if(balanced) popDynArr(stack); else return 0; } c = nextChar(s); } return isEmptyDynArr(stack); }
/* Resizes the underlying array to be the size cap param: v pointer to the dynamic array param: cap the new desired capacity pre: v is not null post: v has capacity newCap */ void _dynArrSetCapacity(DynArr *v, int newCap) { assert(v != 0); assert(newCap > v->capacity); DynArr* temp = newDynArr(newCap); //create a new array int size = sizeDynArr(v); //get the size of the array //copy elements from old array into new array for (int i = 0; i < size; i++) { addDynArr(temp, v->data[i]); } freeDynArr(v); //deallocate memory tied to old array *v = *temp; //replace old array with new array by overwriting the original structure free(temp); //deallocate memory tied to the temporary struct }
/* Checks whether the parentheses are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { struct DynArr *array = newDynArr(10); char c; while((c = nextChar(s)) != '0'){ switch(c){ case '{' : case '[' : case '(' : pushDynArr(array, c); break; case '}' : if(topDynArr(array) == '{'){ popDynArr(array); break; } return 0; case ']' : if(topDynArr(array) == '['){ popDynArr(array); break; } return 0; case ')' : if(topDynArr(array) == '('){ popDynArr(array); break; } return 0; } } if(array->size != 0){ return 0; } deleteDynArr(array); return 1; }
int main(int argc, char* argv[]) { #ifdef MEMORY_TEST_INCLUDED // Memory used BEFORE creating LinkedList long m1 = getMemoryUsage(); #endif if (argc != 2) { printf("Usage: %s <number of elements to add>\n", argv[0]); return 1; } DynArr *a = newDynArr(1024); int numElements = atoi(argv[1]); int i; for (i = 0 ; i < numElements; i++) { addDynArr(a, (TYPE)i); } #ifdef MEMORY_TEST_INCLUDED // Memory used AFTER creating LinkedList long m2 = getMemoryUsage(); printf("Memory used by Dynamic Array : %ld KB \n", m2 - m1); #endif double t1 = getMilliseconds(); // Time before contains() for (i = 0; i < numElements; i++) { containsDynArr(a, i); } double t2 = getMilliseconds(); // Time after contains() printf("Time for running contains() on %d elements: %g ms\n", numElements, t2 - t1); deleteDynArr(a); return 0; }
void mnInit(Menu* M, s_SharedResources* SR) { M->Menus = newDynArr(); M->CurrentMenu = 0; M->PreviousMenu = 0; M->Active = TRUE; M->ItemHeight = 25.f; M->ItemSelectedZoomFactor = 1.2f; M->ItemNormalZoomFactor = 0.5f; M->spd[0] = 0.f; M->spd[1] = 0.f; M->MenuX = 0.f; M->MenuY = -100.f; M->SubAnim = 0.f; M->Force = 0.25f; M->Friction = 0.4f; M->Type = MENU_TYPE_DEFAULT; M->MessageScale = 0.f; M->Hide = FALSE; M->UseMouse = FALSE; M->SR = SR; }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { char c = ' '; int ret_val = 0; struct DynArr* stack = newDynArr(10); assert(stack != 0); assert(s != 0); while (c != '\0'){ ret_val = 1; c = nextChar(s); if (c == '(' || c == '[' || c == '{') pushDynArr(stack,c); if (c == ')' || c == ']' || c == '}') { if (c == ')' && topDynArr(stack) == '(') popDynArr(stack); else if (c == ']' && topDynArr(stack) == '[') popDynArr(stack); else if (c == '}' && topDynArr(stack) == '{') popDynArr(stack); else return 0; } } if (ret_val) ret_val = !(isEmptyDynArr(stack)); printf("return value %d\n", ret_val); deleteDynArr(stack); return ret_val; }
// this main function contains some int main(int argc, char* argv[]){ DynArr *dyn; dyn = newDynArr(2); int i; printf("\n\nTesting addDynArr...\n"); addDynArr(dyn, 3); addDynArr(dyn, 4); addDynArr(dyn, 10); addDynArr(dyn, 5); addDynArr(dyn, 6); printf("The array's content: [3,4,10,5,6]\n"); assertTrue(EQ(getDynArr(dyn, 0), 3), "Test 1st element == 3"); assertTrue(EQ(getDynArr(dyn, 1), 4), "Test 2nd element == 4"); assertTrue(EQ(getDynArr(dyn, 2), 10), "Test 3rd element == 10"); assertTrue(EQ(getDynArr(dyn, 3), 5), "Test 4th element == 5"); assertTrue(EQ(getDynArr(dyn, 4), 6), "Test 5th element == 6"); assertTrue(sizeDynArr(dyn) == 5, "Test size = 5"); printf("\n\nTesting putDynArr...\nCalling putDynArr(dyn, 2, 7)\n"); putDynArr(dyn, 2, 7); printf("The array's content: [3,4,7,5,6]\n"); assertTrue(EQ(getDynArr(dyn, 2), 7), "Test 3rd element == 7"); assertTrue(sizeDynArr(dyn) == 5, "Test size = 5"); printf("\n\nTesting swapDynArr...\nCalling swapDynArr(dyn, 2, 4)\n"); swapDynArr(dyn, 2, 4); printf("The array's content: [3,4,6,5,7]\n"); assertTrue(EQ(getDynArr(dyn, 2), 6), "Test 3rd element == 6"); assertTrue(EQ(getDynArr(dyn, 4), 7), "Test 5th element == 7"); printf("\n\nTesting removeAtDynArr...\nCalling removeAtDynArr(dyn, 1)\n"); removeAtDynArr(dyn, 1); printf("The array's content: [3,6,5,7]\n"); assertTrue(EQ(getDynArr(dyn, 0), 3), "Test 1st element == 3"); assertTrue(EQ(getDynArr(dyn, 3), 7), "Test 4th element == 7"); assertTrue(sizeDynArr(dyn) == 4, "Test size = 4"); printf("\n\nTesting stack interface...\n"); printf("The stack's content: [3,6,5,7] <- top\n"); assertTrue(!isEmptyDynArr(dyn), "Testing isEmptyDynArr"); assertTrue(EQ(topDynArr(dyn), 7), "Test topDynArr == 7"); popDynArr(dyn); printf("Poping...\nThe stack's content: [3,6,5] <- top\n"); assertTrue(EQ(topDynArr(dyn), 5), "Test topDynArr == 5"); pushDynArr(dyn, 9); printf("Pushing 9...\nThe stack's content: [3,6,5,9] <- top\n"); assertTrue(EQ(topDynArr(dyn), 9), "Test topDynArr == 9"); printf("\n\nTesting bag interface...\n"); printf("The bag's content: [3,6,5,9]\n"); assertTrue(containsDynArr(dyn, 3), "Test containing 3"); assertTrue(containsDynArr(dyn, 6), "Test containing 6"); assertTrue(containsDynArr(dyn, 5), "Test containing 5"); assertTrue(containsDynArr(dyn, 9), "Test containing 9"); assertTrue(!containsDynArr(dyn, 7), "Test not containing 7"); removeDynArr(dyn, 3); printf("Removing 3...\nThe stack's content: [6,5,9]\n"); assertTrue(!containsDynArr(dyn, 3), "Test not containing 3"); return 0; }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { int curlyCount = 0; int squareCount = 0; int perenCount = 0; int i; /* FIXME: You will write this function */ /*for(j = 0; s[j]; j++){ size++; }*/ DynArr stack = *newDynArr(strlen(s)+1); stack.size = strlen(s); for(i=0; i < strlen(s); i++){ stack.size--; } for(i=0; i < strlen(s); i++){ pushDynArr(&stack, s[i]); switch(topDynArr(&stack)){ case '{': curlyCount++; popDynArr(&stack); break; case '}': curlyCount--; popDynArr(&stack); break; case '[': squareCount++; popDynArr(&stack); break; case ']': squareCount--; popDynArr(&stack); break; case '(': perenCount++; popDynArr(&stack); break; case ')': perenCount--; popDynArr(&stack); break; default: popDynArr(&stack); break; } } if((curlyCount==0)&&(squareCount == 0)&&(perenCount==0)){ return 1; /*It is balanced*/ } return 0; /*Is not balanced*/ }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { assert(s != NULL); int returnValue = 0; char testChar; struct DynArr *stringBalance = newDynArr((sizeof(s)/sizeof('a'))+1); do{ testChar = nextChar(s); if(testChar == '(' || testChar == '{' ||testChar == '[' ){ pushDynArr(stringBalance, testChar); returnValue = 0; }else if(testChar == ')' || testChar == '}' ||testChar == ']' ){ if(isEmptyDynArr(stringBalance)){ //if the first match is a close then the string is imbalanced returnValue = 0; break; } char top = topDynArr(stringBalance); switch(testChar){ case ')': if( top == '('){ popDynArr(stringBalance); returnValue = 1; }else { returnValue = 0; testChar = '\0'; } break; case '}': if( top == '{'){ popDynArr(stringBalance); returnValue = 1; }else { returnValue = 0; testChar = '\0'; } break; case ']': if( top == '['){ popDynArr(stringBalance); returnValue = 1; }else { returnValue = 0; testChar = '\0'; } break; } }else if(testChar == '\0'){ if(!isEmptyDynArr(stringBalance)){//if at the end of the string it is not empty then it is false returnValue = 0; } } }while(testChar != '\0'); return returnValue; }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: Returns 1 or 0 and displays corresponding response in main */ int isBalanced(char* s) { /* FIXME: You will write this function */ if (s == 0) return 0; char ch; struct DynArr *balArray = newDynArr(10); while((ch = nextChar(s)) != '\0') { //printf("%c\n",ch); //test statement //Push when ch = [,{,( if(ch == '[' || ch == '(' || ch == '{') pushDynArr(balArray, ch); //Pop when ],},) and when array is not empty if(ch == ']' || ch == ')' || ch == '}') { if (isEmptyDynArr(balArray)) return 0; //Check the individual situations and pop if matching if (ch == ']') { if (topDynArr(balArray) == '[') { popDynArr(balArray); } else return 0; } else if (ch == '}') { if (topDynArr(balArray) == '{') { popDynArr(balArray); } else return 0; } else if (ch == ')') { if (topDynArr(balArray) == '(') { popDynArr(balArray); } else return 0; } } //printf("%d", sizeDynArr(balArray));// test statement //printf("Top of Stack: %c\n", topDynArr(balArray));// test statement } if (!isEmptyDynArr(balArray)) { return 0; } else { deleteDynArr(balArray); return 1; } }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { DynArr* stack = newDynArr(DEFAULT_SIZE); //create a stack char bracket; //tracks bracket types char element; //tracks the current element in the given string //perform this loop until the end of the string is reached do { element = nextChar(s); //get the next element in the string //check the element to determine whether it is a closing or opening brace if (_isOpenBracket(element)) { pushDynArr(stack, element); //push an opening brace onto the stack } else if (_isCloseBracket(element)) { if (!isEmptyDynArr(stack)) //make sure the stack is not empty { bracket = topDynArr(stack); //check the top of the stack //make sure the brace at the top of the stack matches the right closing brace if ((bracket == '(' && element != ')') || (bracket == '{' && element != '}') || (bracket == '[' && element != ']')) { element = '\0'; //indicate the end the loop if the braces are mismatched } else { popDynArr(stack); //pop the top element off of the stack if the braces match } } else { /* ** if the stack is empty when a closing brace is encountered in the string, ** then free the stack and exit the function, indicating that the string was not balanced */ free(stack); return 0; } } } while (element != '\0'); /* ** if the stack still has elements after the end of the string has been reached, ** then free the stack and exit the function, indicating that the string was not balanced */ if (sizeDynArr(stack) > 0) { free(stack); return 0; } //otherwise, free the stack and exit the function, indicating that the string is balanced free(stack); return 1; }