diff --git a/Spring-2023/CS-2124/Assignment-2/.clang-format b/Spring-2023/CS-2124/Assignment-2/.clang-format new file mode 100644 index 0000000..bf3583d --- /dev/null +++ b/Spring-2023/CS-2124/Assignment-2/.clang-format @@ -0,0 +1,225 @@ +--- +Language: Cpp +# BasedOnStyle: LLVM +AccessModifierOffset: -2 +AlignAfterOpenBracket: Align +AlignArrayOfStructures: None +AlignConsecutiveAssignments: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + PadOperators: true +AlignConsecutiveBitFields: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + PadOperators: false +AlignConsecutiveDeclarations: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + PadOperators: false +AlignConsecutiveMacros: + Enabled: false + AcrossEmptyLines: false + AcrossComments: false + AlignCompound: false + PadOperators: false +AlignEscapedNewlines: Right +AlignOperands: Align +AlignTrailingComments: + Kind: Always + OverEmptyLines: 0 +AllowAllArgumentsOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: Never +AllowShortCaseLabelsOnASingleLine: false +AllowShortEnumsOnASingleLine: true +AllowShortFunctionsOnASingleLine: All +AllowShortIfStatementsOnASingleLine: Never +AllowShortLambdasOnASingleLine: All +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: MultiLine +AttributeMacros: + - __capability +BinPackArguments: true +BinPackParameters: true +BitFieldColonSpacing: Both +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: Never + AfterEnum: false + AfterExternBlock: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + BeforeCatch: false + BeforeElse: false + BeforeLambdaBody: false + BeforeWhile: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakAfterAttributes: Never +BreakAfterJavaFieldAnnotations: false +BreakArrays: true +BreakBeforeBinaryOperators: None +BreakBeforeConceptDeclarations: Always +BreakBeforeBraces: Attach +BreakBeforeInlineASMColon: OnlyMultiline +BreakBeforeTernaryOperators: true +BreakConstructorInitializers: BeforeColon +BreakInheritanceList: BeforeColon +BreakStringLiterals: true +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: false +DisableFormat: false +EmptyLineAfterAccessModifier: Never +EmptyLineBeforeAccessModifier: LogicalBlock +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IfMacros: + - KJ_IF_MAYBE +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + SortPriority: 0 + CaseSensitive: false + - Regex: '^(<|"(gtest|gmock|isl|json)/)' + Priority: 3 + SortPriority: 0 + CaseSensitive: false + - Regex: '.*' + Priority: 1 + SortPriority: 0 + CaseSensitive: false +IncludeIsMainRegex: '(Test)?$' +IncludeIsMainSourceRegex: '' +IndentAccessModifiers: false +IndentCaseBlocks: false +IndentCaseLabels: false +IndentExternBlock: AfterExternBlock +IndentGotoLabels: true +IndentPPDirectives: None +IndentRequiresClause: true +IndentWidth: 4 +IndentWrappedFunctionNames: false +InsertBraces: false +InsertNewlineAtEOF: false +InsertTrailingCommas: None +IntegerLiteralSeparator: + Binary: 0 + BinaryMinDigits: 0 + Decimal: 0 + DecimalMinDigits: 0 + Hex: 0 + HexMinDigits: 0 +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: true +LambdaBodyIndentation: Signature +LineEnding: DeriveLF +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 2 +ObjCBreakBeforeNestedBlockParam: true +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PackConstructorInitializers: BinPack +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakOpenParenthesis: 0 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyIndentedWhitespace: 0 +PenaltyReturnTypeOnItsOwnLine: 60 +PointerAlignment: Right +PPIndentWidth: -1 +QualifierAlignment: Leave +ReferenceAlignment: Pointer +ReflowComments: true +RemoveBracesLLVM: false +RemoveSemicolon: false +RequiresClausePosition: OwnLine +RequiresExpressionIndentation: OuterScope +SeparateDefinitionBlocks: Leave +ShortNamespaceLines: 1 +SortIncludes: CaseSensitive +SortJavaStaticImport: Before +SortUsingDeclarations: LexicographicNumeric +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: true +SpaceAroundPointerQualifiers: Default +SpaceBeforeAssignmentOperators: true +SpaceBeforeCaseColon: false +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatements +SpaceBeforeParensOptions: + AfterControlStatements: true + AfterForeachMacros: true + AfterFunctionDefinitionName: false + AfterFunctionDeclarationName: false + AfterIfMacros: true + AfterOverloadedOperator: false + AfterRequiresInClause: false + AfterRequiresInExpression: false + BeforeNonEmptyParentheses: false +SpaceBeforeRangeBasedForLoopColon: true +SpaceBeforeSquareBrackets: false +SpaceInEmptyBlock: false +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: Never +SpacesInConditionalStatement: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInLineCommentPrefix: + Minimum: 1 + Maximum: -1 +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Latest +StatementAttributeLikeMacros: + - Q_EMIT +StatementMacros: + - Q_UNUSED + - QT_REQUIRE_VERSION +TabWidth: 8 +UseTab: Never +WhitespaceSensitiveMacros: + - BOOST_PP_STRINGIZE + - CF_SWIFT_NAME + - NS_SWIFT_NAME + - PP_STRINGIZE + - STRINGIZE +... + diff --git a/Spring-2023/CS-2124/Assignment-2/.gitignore b/Spring-2023/CS-2124/Assignment-2/.gitignore new file mode 100644 index 0000000..0bea09f --- /dev/null +++ b/Spring-2023/CS-2124/Assignment-2/.gitignore @@ -0,0 +1,8 @@ +bin +CMakeFiles +Makefile +CMakeCache.txt +cmake_install.cmake +README.pdf +*.tex +.tex-out diff --git a/Spring-2023/CS-2124/Assignment-2/Assignment.pdf b/Spring-2023/CS-2124/Assignment-2/Assignment.pdf new file mode 100644 index 0000000..44a6e34 Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/Assignment.pdf differ diff --git a/Spring-2023/CS-2124/Assignment-2/CMakeLists.txt b/Spring-2023/CS-2124/Assignment-2/CMakeLists.txt new file mode 100644 index 0000000..32be6bb --- /dev/null +++ b/Spring-2023/CS-2124/Assignment-2/CMakeLists.txt @@ -0,0 +1,12 @@ +cmake_minimum_required(VERSION 3.25) + +set(SOURCES src/lib/vec.h src/lib/lib.h src/lib/lib.c) +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY bin) + + +project(AssignmentOne LANGUAGES C) + +add_executable(PartOne src/part_one.c ${SOURCES}) +add_executable(PartTwo src/part_two.c ${SOURCES}) +add_executable(PartThree src/part_three.c ${SOURCES}) + diff --git a/Spring-2023/CS-2124/Assignment-2/README.org b/Spring-2023/CS-2124/Assignment-2/README.org new file mode 100644 index 0000000..f6230b6 --- /dev/null +++ b/Spring-2023/CS-2124/Assignment-2/README.org @@ -0,0 +1,47 @@ +* Assignment 2 + +- ABC123: =zfp106= +- Name: =Price Hiller= +- Course: =CS2124= +- Section: =0C3= +- Semester: =Spring 2024= + +** Source Code +The full source code for this project can be found at [[https://git.orion-technologies.io/Price/college/src/branch/Development/Spring-2023/CS-2124/Assignment-2]] + +** Running the Programs +1. Install [[https://cmake.org/download/][cmake]] version 3.25 or greater. +2. Ensure you have a recent version of ~make~ at the time of writing. This project successfully + compiles with ~GNU make~ version ~4.4.1~. +3. Go the directory with ~CMakeLists.txt~ and run ~cmake .~ to generate a Makefile. +4. Run ~make all~ to compile all the programs. +5. Go into the newly created ~bin~ directory where all the compiled programs will be output to +6. Programs will be named ~PartOne~, ~PartTwo~, and ~PartThree~ + +** Program Outputs + +*** Part One +C program to Check for balanced Parentheses in an Expression using Stack. The program will +check if the expression has balanced Parentheses. + +1. [[./assets/PartOne/img1.png]] +2. [[./assets/PartOne/img2.png]] +3. [[./assets/PartOne/img3.png]] +4. [[./assets/PartOne/img4.png]] +5. [[./assets/PartOne/img5.png]] + +*** Part Two +Write a program which will take input (Infix expression) from user and converts the expression +to Postfix expression (using stacks). + +1. [[./assets/PartTwo/img1.png]] +2. [[./assets/PartTwo/img2.png]] +3. [[./assets/PartTwo/img3.png]] +4. [[./assets/PartTwo/img4.png]] + + +*** Part Three +Implement code that will tell you the time binary search took when implemented through both a +recursive method and iterative method + +1. [[./assets/PartThree/img1.png]] diff --git a/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img1.png b/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img1.png new file mode 100644 index 0000000..a9a025e Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img1.png differ diff --git a/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img2.png b/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img2.png new file mode 100644 index 0000000..65007a3 Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img2.png differ diff --git a/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img3.png b/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img3.png new file mode 100644 index 0000000..2ab1e1f Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img3.png differ diff --git a/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img4.png b/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img4.png new file mode 100644 index 0000000..8a1d2a5 Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img4.png differ diff --git a/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img5.png b/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img5.png new file mode 100644 index 0000000..a10604d Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/assets/PartOne/img5.png differ diff --git a/Spring-2023/CS-2124/Assignment-2/assets/PartThree/img1.png b/Spring-2023/CS-2124/Assignment-2/assets/PartThree/img1.png new file mode 100644 index 0000000..cc7ae27 Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/assets/PartThree/img1.png differ diff --git a/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img1.png b/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img1.png new file mode 100644 index 0000000..fbb4b2f Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img1.png differ diff --git a/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img2.png b/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img2.png new file mode 100644 index 0000000..27fe7ea Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img2.png differ diff --git a/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img3.png b/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img3.png new file mode 100644 index 0000000..b4c4617 Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img3.png differ diff --git a/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img4.png b/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img4.png new file mode 100644 index 0000000..1a279bd Binary files /dev/null and b/Spring-2023/CS-2124/Assignment-2/assets/PartTwo/img4.png differ diff --git a/Spring-2023/CS-2124/Assignment-2/src/lib/lib.c b/Spring-2023/CS-2124/Assignment-2/src/lib/lib.c new file mode 100644 index 0000000..af3b937 --- /dev/null +++ b/Spring-2023/CS-2124/Assignment-2/src/lib/lib.c @@ -0,0 +1,57 @@ +// Credit to +// https://stackoverflow.com/questions/40159892/using-asprintf-on-windows/49873938#49873938 +// with modifications by me + + +#include /* needed for va_* */ +#include /* needed for vsnprintf */ +#include /* needed for malloc, free */ + +#ifdef _MSC_VER +#include +#else +#include +#endif + +int vscprintf(const char *format, va_list ap) { + va_list ap_copy; + va_copy(ap_copy, ap); + int retval = vsnprintf(NULL, 0, format, ap_copy); + va_end(ap_copy); + return retval; +} + +/* + * asprintf, vasprintf: + * MSVC does not implement these, thus we implement them here + * GNU-C-compatible compilers implement these with the same names, thus we + * don't have to do anything + */ +int vasprintf(char **strp, const char *format, va_list ap) { + int len = vscprintf(format, ap); + if (len == -1) + return -1; + char *str = (char *)malloc((size_t)len + 1); + if (!str) + return -1; + int retval = vsnprintf(str, len + 1, format, ap); + if (retval == -1) { + free(str); + return -1; + } + *strp = str; + return retval; +} + +char* fmtstr(const char *format, ...) { + char *str = NULL; + va_list ap; + va_start(ap, format); + vasprintf(&str, format, ap); + va_end(ap); + return str; +} + +void print_header() { + printf("Price Hiller | zfp106 | \n"); +} diff --git a/Spring-2023/CS-2124/Assignment-2/src/lib/lib.h b/Spring-2023/CS-2124/Assignment-2/src/lib/lib.h new file mode 100644 index 0000000..a87b90a --- /dev/null +++ b/Spring-2023/CS-2124/Assignment-2/src/lib/lib.h @@ -0,0 +1,35 @@ +// Credit to +// https://stackoverflow.com/questions/40159892/using-asprintf-on-windows/49873938#49873938 +// with modifications by me + +#ifndef FMTSTR_H +#define FMTSTR_H + +#if defined(__GNUC__) && !defined(_GNU_SOURCE) +#define _GNU_SOURCE /* needed for (v)asprintf, affects '#include ' */ +#endif + +#include /* needed for va_* */ + +/* + * vscprintf: + * MSVC implements this as _vscprintf, thus we just 'symlink' it here + * GNU-C-compatible compilers do not implement this, thus we implement it here + */ +#ifdef _MSC_VER +#define vscprintf _vscprintf +#endif + + +#ifdef _MSC_VER +int vasprintf(char **strp, const char *format, va_list ap); +#endif + +#ifdef __GNUC__ +int vscprintf(const char *format, va_list ap); +#endif + +char* fmtstr(const char *format, ...); +void print_header(); + +#endif diff --git a/Spring-2023/CS-2124/Assignment-2/src/lib/vec.h b/Spring-2023/CS-2124/Assignment-2/src/lib/vec.h new file mode 100644 index 0000000..5494383 --- /dev/null +++ b/Spring-2023/CS-2124/Assignment-2/src/lib/vec.h @@ -0,0 +1,79 @@ +#pragma once +#define VECTOR_LIB +#include +#include + +// This code is pretty bad in all honesty, but I *really* didn't want to play +// the void pointer game. +#define DECL_VEC(type_name, type) \ + typedef struct { \ + size_t elem_count; \ + size_t capacity; \ + type *data; \ + } type_name; \ + \ + type_name type_name##_new(size_t initial_capacity) { \ + initial_capacity = (initial_capacity < 1) ? 1 : initial_capacity; \ + type_name v = {.capacity = initial_capacity, \ + .elem_count = 0, \ + .data = malloc(sizeof(type *) * initial_capacity)}; \ + return v; \ + } \ + \ + bool type_name##_alloc(type_name *v, size_t extra_capacity) { \ + if (extra_capacity == 0) { \ + return false; \ + } \ + \ + int desired_size = v->capacity + extra_capacity; \ + type *newData = realloc(v->data, sizeof(type *) * desired_size); \ + if (newData == NULL) \ + return false; \ + v->data = newData; \ + v->capacity = desired_size; \ + return true; \ + } \ + \ + bool type_name##_ensure_capacity(type_name *v, size_t capacity) { \ + if (v->capacity < capacity) \ + return type_name##_alloc(v, capacity - v->capacity); \ + return true; \ + } \ + \ + void type_name##_push(type_name *v, type item) { \ + type_name##_ensure_capacity(v, v->elem_count + 1); \ + v->data[v->elem_count++] = item; \ + } \ + \ + type *type_name##_get(type_name *v, size_t index) { \ + if (index >= 0 && index < v->elem_count) \ + return &v->data[index]; \ + return NULL; \ + } \ + \ + void type_name##_del(type_name *v, size_t index) { \ + if (index >= 0 && index < v->elem_count) { \ + for (int i = index; (i < v->elem_count - 1); ++i) { \ + v->data[i] = v->data[i + 1]; \ + } \ + v->elem_count--; \ + } \ + } \ + \ + type type_name##_pop(type_name *v) { \ + type popped_value = *type_name##_get(v, v->elem_count - 1); \ + type_name##_del(v, v->elem_count - 1); \ + return popped_value; \ + } \ + \ + type type_name##_first(type_name *v) { \ + type found_value = *type_name##_get(v, 0); \ + type_name##_del(v, 0); \ + return found_value; \ + } \ + \ + type *type_name##_peek(type_name *v) { \ + return type_name##_get(v, v->elem_count - 1); \ + } \ + \ + void type_name##_free(type_name *v) { free(v->data); } diff --git a/Spring-2023/CS-2124/Assignment-2/src/part_one.c b/Spring-2023/CS-2124/Assignment-2/src/part_one.c new file mode 100644 index 0000000..ca6e0d0 --- /dev/null +++ b/Spring-2023/CS-2124/Assignment-2/src/part_one.c @@ -0,0 +1,73 @@ +#include "lib/lib.h" +#include "lib/vec.h" +#include +#include +#include +#include + +DECL_VEC(CharVec, char); + +CharVec readStdinToNewline() { + CharVec cvec = CharVec_new(2); + int ch; + while (EOF != (ch = fgetc(stdin)) && ch != '\n') { + CharVec_push(&cvec, ch); + } + return cvec; +} + +bool pairedBraces(char open_brace, char close_brace) { + if (open_brace == '\0') + return true; + + int asciiDiff = 2; + if (open_brace == '(' || open_brace == ')') { + asciiDiff = 1; + } + return ((int)open_brace - ((int)close_brace - asciiDiff)) == 0; +} + +bool checkCharVecBalance(CharVec *cvec) { + int balance = 0; + CharVec braceStack = CharVec_new(cvec->elem_count); + char lastOpenBrace = '\0'; + while (cvec->elem_count != 0) { + char val = CharVec_first(cvec); + switch (val) { + case '(': + case '[': + case '{': + CharVec_push(&braceStack, val); + balance++; + break; + case ')': + case ']': + case '}': + if (!pairedBraces(CharVec_pop(&braceStack), val)) + return 0; + balance--; + break; + } + } + if (balance == 0) { + return -1; + } else { + return cvec->elem_count; + } +} + +int main() { + print_header(); + printf("Enter Expression: "); + CharVec cvec = readStdinToNewline(); + char *input = malloc(cvec.elem_count + 1); + strcpy(input, cvec.data); + + if (checkCharVecBalance(&cvec)) { + printf("It's balanced (^_^)\n"); + return EXIT_SUCCESS; + } else { + printf("It's Not Balanced (0_0)\n"); + return EXIT_FAILURE; + } +} diff --git a/Spring-2023/CS-2124/Assignment-2/src/part_three.c b/Spring-2023/CS-2124/Assignment-2/src/part_three.c new file mode 100644 index 0000000..afec9e5 --- /dev/null +++ b/Spring-2023/CS-2124/Assignment-2/src/part_three.c @@ -0,0 +1,104 @@ +#include "lib/lib.h" +#include +#include +#include + +void swap(int *a, int *b) { + int t = *a; + *a = *b; + *b = t; +} + +int partition(int arr[], int low, int high) { + int pivot = arr[high]; + int i = (low - 1); + + for (int j = low; j <= high - 1; j++) { + if (arr[j] < pivot) { + i++; + swap(&arr[i], &arr[j]); + } + } + swap(&arr[i + 1], &arr[high]); + return (i + 1); +} + +void q_sort(int arr[], int low, int high) { + if (low < high) { + int p = partition(arr, low, high); + q_sort(arr, low, p - 1); + q_sort(arr, p + 1, high); + } +} + +int bsearch_iterative(int arr[], int key, int len) { + int low = 0; + int high = len; + while (low < high) { + int mid = (low + high) / 2; + if (key == arr[mid]) { + return mid; + } else if (key > arr[mid]) { + low = mid + 1; + } else { + high = mid - 1; + } + } + return -1; +} + +int bsearch_recursive(int arr[], int key, int low, int high) { + if (low > high) { + return -1; + } + + int mid = (low + high) / 2; + if (key == arr[mid]) { + return mid; + } else if (key > arr[mid]) { + return bsearch_recursive(arr, key, mid + 1, high); + } else { + return bsearch_recursive(arr, key, low, mid - 1); + } +} + +int main() { + print_header(); + printf("Enter 5 elements:\n"); + int arr_len = 5; + int arr[arr_len]; + for (int i = 0; i < arr_len; i++) { + scanf("%d", &arr[i]); + } + printf("\nEnter element to search for:\n"); + int search_element; + scanf("%d", &search_element); + q_sort(arr, 0, arr_len); + + clock_t tic, toc; + printf("\n\n--------\n=> Binary Search (Iterative Approach)"); + tic = clock(); + int b_iter_index = bsearch_iterative(arr, search_element, arr_len); + toc = clock(); + if (b_iter_index == -1) { + printf("Unable to find the element '%d'!\n", search_element); + } else { + printf("Element found at index %d\n", b_iter_index); + } + printf("Total time taken by CPU (End Time - Start Time)/clock per sec: %f\n--------\n", + (double)(toc - tic) / CLOCKS_PER_SEC); + + printf("\n--------\n=> Binary Search (Recursive Approach)"); + tic = clock(); + int b_rec_index = bsearch_recursive(arr, search_element, 0, arr_len); + toc = clock(); + if (b_iter_index == -1) { + printf("Unable to find the element '%d'!\n", search_element); + } else { + printf("Element found at index %d\n", b_rec_index); + } + printf("Total time taken by CPU (End Time - Start Time)/clock per sec: %f\n--------\n", + (double)(toc - tic) / CLOCKS_PER_SEC); + + return EXIT_SUCCESS; +} diff --git a/Spring-2023/CS-2124/Assignment-2/src/part_two.c b/Spring-2023/CS-2124/Assignment-2/src/part_two.c new file mode 100644 index 0000000..7c0b615 --- /dev/null +++ b/Spring-2023/CS-2124/Assignment-2/src/part_two.c @@ -0,0 +1,66 @@ +#include "lib/lib.h" +#include "lib/vec.h" +#include +#include +#include +#include + +DECL_VEC(CharVec, char); + +int priority(char x) { + switch (x) { + case '(': + return 0; + break; + case '+': + case '-': + return 1; + case '*': + case '/': + return 2; + } + return 0; +} + +CharVec readStdinToNewline() { + CharVec cvec = CharVec_new(2); + int ch; + while (EOF != (ch = fgetc(stdin)) && ch != '\n') { + CharVec_push(&cvec, ch); + } + return cvec; +} + +int main() { + print_header(); + printf("Enter the Infix Expression:\n"); + CharVec stack = CharVec_new(2); + CharVec input = readStdinToNewline(); + printf("The Postfix expression:\n "); + while (input.elem_count != 0) { + char ch = CharVec_first(&input); + if (ch == ' ') { + continue; + } else if (isalnum(ch)) { + printf("%c ", ch); + } else if (ch == '(') { + CharVec_push(&stack, ch); + } else if (ch == ')') { + char x; + while ((x = CharVec_pop(&stack)) != '(') { + printf("%c ", x); + } + } else { + while (stack.elem_count != 0 && priority(*CharVec_peek(&stack)) >= priority(ch)) + printf("%c ", CharVec_pop(&stack)); + CharVec_push(&stack, ch); + } + } + + while (stack.elem_count != 0) { + printf("%c ", CharVec_pop(&stack)); + } + printf("\nEnd of Program\n"); + + return EXIT_SUCCESS; +}