From e0316ca3ff9d530094216c857de72a89e7718ed9 Mon Sep 17 00:00:00 2001 From: Jose Caban <43381096+AssKoala@users.noreply.github.com> Date: Sat, 7 Jun 2025 11:38:03 -0400 Subject: [PATCH] first commit --- ArrayStack/Cpp/arraystack.cpp | 101 ++++ BreakMemory/CMakeLists.txt | 3 + BreakMemory/Cpp/CMakeLists.txt | 37 ++ BreakMemory/Cpp/breakmemory.cpp | 72 +++ CMakeLists.txt | 10 + Endian/C/CMakeLists.txt | 33 ++ Endian/C/endian.c | 24 + Endian/CMakeLists.txt | 4 + FizzBuzz/Ada/fizzbuzz.adb | 6 + FizzBuzz/C/CMakeLists.txt | 33 ++ FizzBuzz/C/fizzbuzz.c | 132 +++++ FizzBuzz/CMakeLists.txt | 4 + FizzBuzz/CSharp/fizzbuzz.cs | 39 ++ FizzBuzz/Cpp/CMakeLists.txt | 33 ++ FizzBuzz/Cpp/fizzbuzz.cpp | 32 ++ FizzBuzz/D/fizzbuzz.d | 35 ++ FizzBuzz/Fortran/fizzbuzz.f90 | 37 ++ FizzBuzz/Haskell/fizzbuzz.hs | 2 + FizzBuzz/Java/fizzbuzz.java | 40 ++ FizzBuzz/Python/fizzbuzz.py | 18 + FizzBuzz/Rust/fizzbuzz.rs | 29 + FizzBuzz/problem.txt | 5 + HelloWorld/Ada/helloworld.adb | 6 + HelloWorld/C/CMakeLists.txt | 33 ++ HelloWorld/C/helloworld.c | 8 + HelloWorld/CMakeLists.txt | 7 + HelloWorld/CSharp/helloworld.cs | 10 + HelloWorld/Cpp/CMakeLists.txt | 33 ++ HelloWorld/Cpp/helloworld.cpp | 7 + HelloWorld/D/helloworld.d | 6 + HelloWorld/Fortran/CMakeLists.txt | 34 ++ HelloWorld/Fortran/helloworld.f90 | 3 + HelloWorld/Haskell/helloworld.hs | 2 + HelloWorld/Java/helloworld.java | 16 + HelloWorld/Python/helloworld.py | 1 + HelloWorld/Rust/helloworld.rs | 4 + ProducerConsumer/CMakeLists.txt | 3 + ProducerConsumer/Cpp/CMakeLists.txt | 37 ++ ProducerConsumer/Cpp/producerconsumer.cpp | 203 +++++++ ProducerConsumer/Rust/producerconsumer.rs | 9 + RecurringRainfall/Ada/recurringrainfall.adb | 48 ++ RecurringRainfall/C/CMakeLists.txt | 33 ++ RecurringRainfall/C/recurringrainfall.c | 42 ++ RecurringRainfall/CMakeLists.txt | 4 + RecurringRainfall/CSharp/recurringrainfall.cs | 34 ++ RecurringRainfall/Cpp/CMakeLists.txt | 33 ++ RecurringRainfall/Cpp/recurringrainfall.cpp | 54 ++ RecurringRainfall/D/recurringrainfall.d | 34 ++ .../Fortran/recurringrainfall.f90 | 40 ++ RecurringRainfall/Java/recurringrainfall.java | 42 ++ RecurringRainfall/Python/recurringrainfall.py | 24 + RecurringRainfall/Rust/recurringrainfall.rs | 33 ++ RecurringRainfall/directions.txt | 5 + RecurringRainfall/icer14.pdf | Bin 0 -> 291518 bytes TestDataServer/Program.cs | 19 + TestDataServer/TestDataServer.cs | 94 ++++ TestDataServer/TestDataServer.csproj | 8 + TestDataServer/TestDataServer.sln | 25 + gen_makefiles.sh | 515 ++++++++++++++++++ l33tcode_addtwonumbers/CMakeLists.txt | 7 + l33tcode_addtwonumbers/Cpp/CMakeLists.txt | 33 ++ .../Cpp/leetcode_addtwonumbers.cpp | 126 +++++ .../Rust/leetcode_addtwonumbers.rs | 25 + l33tcode_medianofsortedarrays/CMakeLists.txt | 7 + .../Cpp/CMakeLists.txt | 33 ++ .../Cpp/l33tcode_medianofsortedarrays.cpp | 79 +++ .../Rust/l33tcode_medianofsortedarrays.rs | 5 + l33tcode_merge2sortedlists/CMakeLists.txt | 7 + l33tcode_merge2sortedlists/Cpp/CMakeLists.txt | 33 ++ .../Cpp/l33tcode_merge2sortedlists.cpp | 111 ++++ .../Rust/l33tcode_merge2sortedlists.rs | 0 l33tcode_reversewords/CMakeLists.txt | 7 + l33tcode_reversewords/Cpp/CMakeLists.txt | 33 ++ .../Cpp/l33tcode_reversewords.cpp | 64 +++ .../Rust/l33tcode_reversewords.rs | 13 + make_all.sh | 24 + malloc/Cpp/malloc.cpp | 131 +++++ solution/LanguageBasics/LanguageBasics.sln | 31 ++ .../ProducerConsumerCpp.vcxproj | 148 +++++ 79 files changed, 3155 insertions(+) create mode 100644 ArrayStack/Cpp/arraystack.cpp create mode 100644 BreakMemory/CMakeLists.txt create mode 100644 BreakMemory/Cpp/CMakeLists.txt create mode 100644 BreakMemory/Cpp/breakmemory.cpp create mode 100644 CMakeLists.txt create mode 100644 Endian/C/CMakeLists.txt create mode 100644 Endian/C/endian.c create mode 100644 Endian/CMakeLists.txt create mode 100644 FizzBuzz/Ada/fizzbuzz.adb create mode 100644 FizzBuzz/C/CMakeLists.txt create mode 100644 FizzBuzz/C/fizzbuzz.c create mode 100644 FizzBuzz/CMakeLists.txt create mode 100644 FizzBuzz/CSharp/fizzbuzz.cs create mode 100644 FizzBuzz/Cpp/CMakeLists.txt create mode 100644 FizzBuzz/Cpp/fizzbuzz.cpp create mode 100644 FizzBuzz/D/fizzbuzz.d create mode 100644 FizzBuzz/Fortran/fizzbuzz.f90 create mode 100644 FizzBuzz/Haskell/fizzbuzz.hs create mode 100644 FizzBuzz/Java/fizzbuzz.java create mode 100644 FizzBuzz/Python/fizzbuzz.py create mode 100644 FizzBuzz/Rust/fizzbuzz.rs create mode 100644 FizzBuzz/problem.txt create mode 100644 HelloWorld/Ada/helloworld.adb create mode 100644 HelloWorld/C/CMakeLists.txt create mode 100644 HelloWorld/C/helloworld.c create mode 100644 HelloWorld/CMakeLists.txt create mode 100644 HelloWorld/CSharp/helloworld.cs create mode 100644 HelloWorld/Cpp/CMakeLists.txt create mode 100644 HelloWorld/Cpp/helloworld.cpp create mode 100644 HelloWorld/D/helloworld.d create mode 100644 HelloWorld/Fortran/CMakeLists.txt create mode 100644 HelloWorld/Fortran/helloworld.f90 create mode 100644 HelloWorld/Haskell/helloworld.hs create mode 100644 HelloWorld/Java/helloworld.java create mode 100644 HelloWorld/Python/helloworld.py create mode 100644 HelloWorld/Rust/helloworld.rs create mode 100644 ProducerConsumer/CMakeLists.txt create mode 100644 ProducerConsumer/Cpp/CMakeLists.txt create mode 100644 ProducerConsumer/Cpp/producerconsumer.cpp create mode 100644 ProducerConsumer/Rust/producerconsumer.rs create mode 100644 RecurringRainfall/Ada/recurringrainfall.adb create mode 100644 RecurringRainfall/C/CMakeLists.txt create mode 100644 RecurringRainfall/C/recurringrainfall.c create mode 100644 RecurringRainfall/CMakeLists.txt create mode 100644 RecurringRainfall/CSharp/recurringrainfall.cs create mode 100644 RecurringRainfall/Cpp/CMakeLists.txt create mode 100644 RecurringRainfall/Cpp/recurringrainfall.cpp create mode 100644 RecurringRainfall/D/recurringrainfall.d create mode 100644 RecurringRainfall/Fortran/recurringrainfall.f90 create mode 100644 RecurringRainfall/Java/recurringrainfall.java create mode 100644 RecurringRainfall/Python/recurringrainfall.py create mode 100644 RecurringRainfall/Rust/recurringrainfall.rs create mode 100644 RecurringRainfall/directions.txt create mode 100644 RecurringRainfall/icer14.pdf create mode 100644 TestDataServer/Program.cs create mode 100644 TestDataServer/TestDataServer.cs create mode 100644 TestDataServer/TestDataServer.csproj create mode 100644 TestDataServer/TestDataServer.sln create mode 100644 gen_makefiles.sh create mode 100644 l33tcode_addtwonumbers/CMakeLists.txt create mode 100644 l33tcode_addtwonumbers/Cpp/CMakeLists.txt create mode 100644 l33tcode_addtwonumbers/Cpp/leetcode_addtwonumbers.cpp create mode 100644 l33tcode_addtwonumbers/Rust/leetcode_addtwonumbers.rs create mode 100644 l33tcode_medianofsortedarrays/CMakeLists.txt create mode 100644 l33tcode_medianofsortedarrays/Cpp/CMakeLists.txt create mode 100644 l33tcode_medianofsortedarrays/Cpp/l33tcode_medianofsortedarrays.cpp create mode 100644 l33tcode_medianofsortedarrays/Rust/l33tcode_medianofsortedarrays.rs create mode 100644 l33tcode_merge2sortedlists/CMakeLists.txt create mode 100644 l33tcode_merge2sortedlists/Cpp/CMakeLists.txt create mode 100644 l33tcode_merge2sortedlists/Cpp/l33tcode_merge2sortedlists.cpp create mode 100644 l33tcode_merge2sortedlists/Rust/l33tcode_merge2sortedlists.rs create mode 100644 l33tcode_reversewords/CMakeLists.txt create mode 100644 l33tcode_reversewords/Cpp/CMakeLists.txt create mode 100644 l33tcode_reversewords/Cpp/l33tcode_reversewords.cpp create mode 100644 l33tcode_reversewords/Rust/l33tcode_reversewords.rs create mode 100644 make_all.sh create mode 100644 malloc/Cpp/malloc.cpp create mode 100644 solution/LanguageBasics/LanguageBasics.sln create mode 100644 solution/LanguageBasics/ProducerConsumerCpp/ProducerConsumerCpp.vcxproj diff --git a/ArrayStack/Cpp/arraystack.cpp b/ArrayStack/Cpp/arraystack.cpp new file mode 100644 index 0000000..96bfba5 --- /dev/null +++ b/ArrayStack/Cpp/arraystack.cpp @@ -0,0 +1,101 @@ +#include +#include +#include +#include + +template class ArrayStack +{ +public: + ArrayStack() + : + m_array(nullptr) + , m_arrayLen(0) + , m_currentHead(0) + , m_growSize(growSize) + { + if (initialSize > 0) + { + grow(initialSize); + } + } + + ~ArrayStack() + { + + } + + void push(T obj) + { + if (m_currentHead+1 >= m_arrayLen) + { + grow(); + } + + m_array[m_currentHead] = obj; + m_currentHead++; + } + + void pop(T *obj) + { + if (m_currentHead > 0) + { + auto temp = m_array[m_currentHead-1]; + *obj = temp; + m_currentHead--; + } + else + { + assert(false); + } + } + + +private: + void grow(size_t size = growSize) + { + // Allocate for the new size + auto newArrayLen = size + m_arrayLen; + auto newArray = (T*)malloc(sizeof(T) * newArrayLen); + + // Copy over the old array + if (newArray) + { + memcpy(newArray, m_array, m_arrayLen * sizeof(T)); + } + + // delete the old one + if (m_array) free(m_array); + + // Set the new array + m_array = newArray; + m_arrayLen = newArrayLen; + } + + + T *m_array; + size_t m_arrayLen; + size_t m_currentHead; + const size_t m_growSize; +}; + +#ifndef EXTERN_MAIN +int main(int argc, char **argv) +{ + ArrayStack stack; + const size_t stackSize = 50; + + for (size_t i = 0; i < stackSize; i++) + { + stack.push(i); + } + + for (size_t i = 0; i < stackSize; i++) + { + int dest; + stack.pop(&dest); + printf("Got: %d\n", dest); + } + + return 0; +} +#endif diff --git a/BreakMemory/CMakeLists.txt b/BreakMemory/CMakeLists.txt new file mode 100644 index 0000000..ce8ed47 --- /dev/null +++ b/BreakMemory/CMakeLists.txt @@ -0,0 +1,3 @@ +cmake_minimum_required(VERSION 3.10) + +include(${CMAKE_CURRENT_LIST_DIR}/Cpp/CMakeLists.txt) diff --git a/BreakMemory/Cpp/CMakeLists.txt b/BreakMemory/Cpp/CMakeLists.txt new file mode 100644 index 0000000..01bd07a --- /dev/null +++ b/BreakMemory/Cpp/CMakeLists.txt @@ -0,0 +1,37 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(CppBreakMemory) +set(CURRENT_PROJECT_CODE_NAME breakmemory) +set(FILE_EXT cpp) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) + + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + list(APPEND EXTRA_LIBS "Threads::Threads") +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/BreakMemory/Cpp/breakmemory.cpp b/BreakMemory/Cpp/breakmemory.cpp new file mode 100644 index 0000000..f513152 --- /dev/null +++ b/BreakMemory/Cpp/breakmemory.cpp @@ -0,0 +1,72 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +class Incorrect +{ +public: + Incorrect(size_t iterations = 1000) + : mIterations(iterations) + { + isReady = false; + done = false; + newValue = 0xdeadbeef; + } + + void RunAndWait() + { + std::thread consumer(&Incorrect::Consumer, this); + std::thread writer(&Incorrect::Writer, this); + + writer.join(); + consumer.join(); + + } + +private: + void Consumer() + { + while (!done) + { + while (isReady != true); + auto print = newValue; + isReady = false; + printf("New Value: %d\n", print); + } + } + + void Writer() + { + for (auto i = int(mIterations); i > 0; i--) + { + while (isReady != false); + + newValue = i; + isReady = true; + } + + done = true; + } + + const size_t mIterations; + volatile bool isReady; + volatile int newValue; + volatile bool done; +}; + + +int main() +{ + Incorrect incorrect; + incorrect.RunAndWait(); + return 0; +} + diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..183202c --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,10 @@ +cmake_minimum_required(VERSION 3.10) + +project(LanguageBasics) + +include(${CMAKE_CURRENT_SOURCE_DIR}/HelloWorld/CMakeLists.txt) +include(${CMAKE_CURRENT_SOURCE_DIR}/FizzBuzz/CMakeLists.txt) +include(${CMAKE_CURRENT_SOURCE_DIR}/RecurringRainfall/CMakeLists.txt) +include(${CMAKE_CURRENT_SOURCE_DIR}/Endian/CMakeLists.txt) +include(${CMAKE_CURRENT_SOURCE_DIR}/ProducerConsumer/CMakeLists.txt) +include(${CMAKE_CURRENT_SOURCE_DIR}/BreakMemory/CMakeLists.txt) diff --git a/Endian/C/CMakeLists.txt b/Endian/C/CMakeLists.txt new file mode 100644 index 0000000..2464c1f --- /dev/null +++ b/Endian/C/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(CEndian) +set(CURRENT_PROJECT_CODE_NAME endian) +set(FILE_EXT c) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/Endian/C/endian.c b/Endian/C/endian.c new file mode 100644 index 0000000..ce22ed4 --- /dev/null +++ b/Endian/C/endian.c @@ -0,0 +1,24 @@ +#include + +void show_memory(const char* begin, size_t length) +{ + size_t i = 0; + for (; i < length; i++) + { + printf(" %.2x", 0xff & begin[i]); // 0xff is necessary due to type promotion + } + printf("\n"); +} + +int main(int argc, char** argv) +{ + (void)argc; + (void)argv; + float f = 42654.2312f; + int i = 7753238; + printf("Printing float %f with size %ld\n", f, sizeof(f)); + show_memory((char*)&f, sizeof(f)); + printf("Printing int %d with size %ld\n", i, sizeof(f)); + show_memory((char*)&i, sizeof(i)); + return 0; +} diff --git a/Endian/CMakeLists.txt b/Endian/CMakeLists.txt new file mode 100644 index 0000000..c1e88f6 --- /dev/null +++ b/Endian/CMakeLists.txt @@ -0,0 +1,4 @@ +cmake_minimum_required(VERSION 3.10) + +include(${CMAKE_CURRENT_LIST_DIR}/C/CMakeLists.txt) +#include(${CMAKE_CURRENT_LIST_DIR}/Cpp/CMakeLists.txt) diff --git a/FizzBuzz/Ada/fizzbuzz.adb b/FizzBuzz/Ada/fizzbuzz.adb new file mode 100644 index 0000000..72de7b7 --- /dev/null +++ b/FizzBuzz/Ada/fizzbuzz.adb @@ -0,0 +1,6 @@ +with Ada.Text_IO; + +procedure FizzBuzz is +begin + Ada.Text_IO.Put_Line("Hello, world!"); +end FizzBuzz; diff --git a/FizzBuzz/C/CMakeLists.txt b/FizzBuzz/C/CMakeLists.txt new file mode 100644 index 0000000..427872b --- /dev/null +++ b/FizzBuzz/C/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(CFizzBuzz) +set(CURRENT_PROJECT_CODE_NAME fizzbuzz) +set(FILE_EXT c) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/FizzBuzz/C/fizzbuzz.c b/FizzBuzz/C/fizzbuzz.c new file mode 100644 index 0000000..f43240b --- /dev/null +++ b/FizzBuzz/C/fizzbuzz.c @@ -0,0 +1,132 @@ +#include +#include + +void fizzbuzz(int n) +{ + int i; + for (i = 1; i <= n; i++) + { + if (i%3 == 0 || i%5 == 0) + { + if (i % 3 == 0 && i % 5 == 0) + printf("fizzbuzz\n"); + else if (i%3==0) + printf("fizz\n"); + else + printf("buzz\n"); + } + else + { + printf("%d\n", i); + } + } +} + +#define BUF_SIZE 1024 + +void fizzbuzz_fast(int n) +{ + int i; + + char str[BUF_SIZE]; + int curr_str_pos = 0; + + for (i = 1; i <= n; i++) + { + if (i % 3 == 0 || i % 5 == 0) + { + char* strToPrint; + int result; + + if (i % 3 == 0 && i % 5 == 0) + { + strToPrint = "fizzbuzz\n"; + } + else if (i % 3 == 0) + { + strToPrint = "fizz\n"; + } + else + { + strToPrint = "buzz\n"; + } + + result = snprintf(str + curr_str_pos, BUF_SIZE - curr_str_pos, "%s", strToPrint); + if (!(result < BUF_SIZE - curr_str_pos)) + { + printf("%s", str); + curr_str_pos = 0; + result = snprintf(str + curr_str_pos, BUF_SIZE - curr_str_pos, "%s", strToPrint); + } + curr_str_pos += result; + } + else + { + int result; + result = snprintf(str + curr_str_pos, BUF_SIZE - curr_str_pos, "%d\n", i); + + if (!(result < BUF_SIZE - curr_str_pos)) + { + printf("%s", str); + curr_str_pos = 0; + result = snprintf(str + curr_str_pos, BUF_SIZE - curr_str_pos, "%d\n", i); + } + curr_str_pos += result; + } + } + + if (curr_str_pos != 0) + { + printf("%s", str); + } +} + +void fizzbuzz_branchless(int n) +{ + char *zzc[]={"fizz\n","buzz\n","fizzbuzz\n","%d\n"}; + int zxc[]={3,0,0,1,0,0,2}; + for (int i = 1; i < n; ++i) + { + int a=i%3==0; + int b=i%5==0; + int t=b^a; + printf(zzc[zxc[a<<2|(b<<1)|t]],i); + } +} + +int main(int argc, char **argv) +{ + (void)argc; + (void)argv; + + int n; + + clock_t reg_start, reg_end, branchless_start, branchless_end, fast_start, fast_end; + + printf("How many fizzbuzzes?: "); + int ret = scanf("%d", &n); + if (ret) + { + reg_start = clock(); + fizzbuzz(n); + reg_end = clock(); + + branchless_start = clock(); + fizzbuzz_branchless(n); + branchless_end = clock(); + + fast_start = clock(); + fizzbuzz_fast(n); + fast_end = clock(); + + printf("regular time: %ld\n", reg_end - reg_start); + printf("branchless time: %ld\n", branchless_end - branchless_start); + printf("fast time: %ld\n", fast_end - fast_start); + } + else + { + printf("Invalid input\n"); + } + + return 0; +} diff --git a/FizzBuzz/CMakeLists.txt b/FizzBuzz/CMakeLists.txt new file mode 100644 index 0000000..2619a62 --- /dev/null +++ b/FizzBuzz/CMakeLists.txt @@ -0,0 +1,4 @@ +cmake_minimum_required(VERSION 3.10) + +include(${CMAKE_CURRENT_LIST_DIR}/C/CMakeLists.txt) +include(${CMAKE_CURRENT_LIST_DIR}/Cpp/CMakeLists.txt) diff --git a/FizzBuzz/CSharp/fizzbuzz.cs b/FizzBuzz/CSharp/fizzbuzz.cs new file mode 100644 index 0000000..2928d67 --- /dev/null +++ b/FizzBuzz/CSharp/fizzbuzz.cs @@ -0,0 +1,39 @@ +namespace LanguageBasics +{ + class CSharpFizzBuzz + { + static void FizzBuzz(int n) + { + for (int i = 1; i <= n; i++) + { + if (i%3==0 || i%5==0) + { + if (i%3==0) + { + System.Console.Write("Fizz"); + } + if (i%5==0) + { + System.Console.Write("Buzz"); + } + } + else + { + System.Console.Write(i); + } + System.Console.WriteLine(""); + } + } + + static void Main() + { + System.Console.WriteLine("How many fizzbuzzes?: "); + string input = System.Console.ReadLine(); + + if (System.Int32.TryParse(input, out int num)) + FizzBuzz(num); + else + System.Console.WriteLine("Invalid input"); + } + } +} diff --git a/FizzBuzz/Cpp/CMakeLists.txt b/FizzBuzz/Cpp/CMakeLists.txt new file mode 100644 index 0000000..7399b0b --- /dev/null +++ b/FizzBuzz/Cpp/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(CppFizzBuzz) +set(CURRENT_PROJECT_CODE_NAME fizzbuzz) +set(FILE_EXT cpp) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/FizzBuzz/Cpp/fizzbuzz.cpp b/FizzBuzz/Cpp/fizzbuzz.cpp new file mode 100644 index 0000000..a69b3f3 --- /dev/null +++ b/FizzBuzz/Cpp/fizzbuzz.cpp @@ -0,0 +1,32 @@ +#include + +void fizzbuzz(int n) +{ + for (auto i = 1; i <= n; i++) + { + if (i%3 == 0 || i%5 == 0) + { + if (i%3 == 0) + std::cout << "fizz"; + if (i%5 == 0) + std::cout << "buzz"; + } + else + { + std::cout << i; + } + std::cout << std::endl; + } +} + +int main() +{ + int n; + std::cout << "How many fizzbuzzes?: "; + std::cin >> n; + if (!std::cin.fail()) + fizzbuzz(n); + else + printf("Invalid input\n"); + return 0; +} diff --git a/FizzBuzz/D/fizzbuzz.d b/FizzBuzz/D/fizzbuzz.d new file mode 100644 index 0000000..519c8e3 --- /dev/null +++ b/FizzBuzz/D/fizzbuzz.d @@ -0,0 +1,35 @@ +import std.stdio; + +void fizzBuzz(int n) +{ + for (int i = 1; i<= n; i++) + { + if (i%3==0 || i%5==0) + { + if (i%3==0) + write("fizz"); + if (i%5==0) + write("buzz"); + } + else + { + write(i); + } + writeln(""); + } +} + +void main() +{ + int i; + write("How many fizzbuzzes?: "); + try { + readf("%d", i); + fizzBuzz(i); + } catch (Exception e) + { + writeln("Invalid input"); + } + + +} diff --git a/FizzBuzz/Fortran/fizzbuzz.f90 b/FizzBuzz/Fortran/fizzbuzz.f90 new file mode 100644 index 0000000..371a1a3 --- /dev/null +++ b/FizzBuzz/Fortran/fizzbuzz.f90 @@ -0,0 +1,37 @@ +subroutine fizzbuzzsub(n) + implicit none + integer, intent(in) :: n + integer :: i + + do i = 1, n + if ((modulo(i,3) == 0) .OR. (modulo(i,5) == 0)) then + if (mod(i,3)==0) then + write(*, "(a)", advance="no") "Fizz" + end if + if (mod(i,5)==0) then + write(*, "(a)", advance="no") "Buzz" + end if + else + write(*, "(i0)", advance="no") i + end if + print *,"" + end do + + + +end subroutine fizzbuzzsub + +program fizzbuzz + implicit none + integer :: n + integer :: Reason + + print *, "How many fizzbuzzes?: " + read (*,*,IOSTAT=Reason) n + + if (Reason > 0) then + print *, "Invalid input" + else + call fizzbuzzsub(n) + end if +end program fizzbuzz diff --git a/FizzBuzz/Haskell/fizzbuzz.hs b/FizzBuzz/Haskell/fizzbuzz.hs new file mode 100644 index 0000000..83a086a --- /dev/null +++ b/FizzBuzz/Haskell/fizzbuzz.hs @@ -0,0 +1,2 @@ +main :: IO() +main = putStrLn "Hello, World!" diff --git a/FizzBuzz/Java/fizzbuzz.java b/FizzBuzz/Java/fizzbuzz.java new file mode 100644 index 0000000..cde8990 --- /dev/null +++ b/FizzBuzz/Java/fizzbuzz.java @@ -0,0 +1,40 @@ +class fizzbuzz +{ + private static void fizzBuzz(int n) + { + for (int i = 1; i <= n; i++) + { + if (i%3 == 0 || i%5 == 0) + { + if (i%3 == 0) + System.out.print("fizz"); + if (i%5 == 0) + System.out.print("buzz"); + } + else + { + System.out.print(i); + } + System.out.println(""); + } + } + + // Your program begins with a call to main(). + // Prints "Hello, World" to the terminal window. + public static void main(String args[]) + { + System.out.print("How many fizzbuzzes?: "); + String input = System.console().readLine(); + + try + { + int n = Integer.parseInt(input); + fizzBuzz(n); + } + catch (Exception e) + { + System.out.println("Invalid input"); + return; + } + } +} diff --git a/FizzBuzz/Python/fizzbuzz.py b/FizzBuzz/Python/fizzbuzz.py new file mode 100644 index 0000000..a531621 --- /dev/null +++ b/FizzBuzz/Python/fizzbuzz.py @@ -0,0 +1,18 @@ +import sys + +try: + N = int(input("How many fizzbuzzes?: ")) +except: + print("Invalid input") + sys.exit() + +for x in range(1,N+1): + if x % 3 == 0 or x % 5 == 0: + if x % 3 == 0: + print("fizz", end="") + if x % 5 == 0: + print("buzz", end="") + else: + print(x, end="") + print("") + diff --git a/FizzBuzz/Rust/fizzbuzz.rs b/FizzBuzz/Rust/fizzbuzz.rs new file mode 100644 index 0000000..da756e6 --- /dev/null +++ b/FizzBuzz/Rust/fizzbuzz.rs @@ -0,0 +1,29 @@ +fn fizzbuzz(n: u32) { + for i in 1..=n { + if i%3==0 || i%5==0 + { + if i%3==0 { + print!("fizz"); + } + if i%5==0 { + print!("buzz"); + } + } + else { + print!("{}",i); + } + println!(""); + } +} + +fn main() { + println!("How many fizzbuzzes? "); + + let mut input_text = String::new(); + std::io::stdin().read_line(&mut input_text).expect("Failed to read from stdin"); + let trimmed = input_text.trim(); + match trimmed.parse::() { + Ok(i) => fizzbuzz(i), + Err(..) => println!("Invalid input"), + }; +} diff --git a/FizzBuzz/problem.txt b/FizzBuzz/problem.txt new file mode 100644 index 0000000..451a74f --- /dev/null +++ b/FizzBuzz/problem.txt @@ -0,0 +1,5 @@ +/* + Write a program that prints the numbers from 1 to 100. + But for multiples of three print “Fizz” instead of the number and for the multiples of five print “Buzz”. + For numbers which are multiples of both three and five print “FizzBuzz”. +*/ \ No newline at end of file diff --git a/HelloWorld/Ada/helloworld.adb b/HelloWorld/Ada/helloworld.adb new file mode 100644 index 0000000..1429a3b --- /dev/null +++ b/HelloWorld/Ada/helloworld.adb @@ -0,0 +1,6 @@ +with Ada.Text_IO; + +procedure Helloworld is +begin + Ada.Text_IO.Put_Line("Hello, world!"); +end Helloworld; diff --git a/HelloWorld/C/CMakeLists.txt b/HelloWorld/C/CMakeLists.txt new file mode 100644 index 0000000..4d61021 --- /dev/null +++ b/HelloWorld/C/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(CHelloWorld) +set(CURRENT_PROJECT_CODE_NAME helloworld) +set(FILE_EXT c) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/HelloWorld/C/helloworld.c b/HelloWorld/C/helloworld.c new file mode 100644 index 0000000..36c7572 --- /dev/null +++ b/HelloWorld/C/helloworld.c @@ -0,0 +1,8 @@ +#include + +int main(int argc, char **argv) +{ + (void)argc; + (void)argv; + return printf("Hello, World!\n"); +} diff --git a/HelloWorld/CMakeLists.txt b/HelloWorld/CMakeLists.txt new file mode 100644 index 0000000..c63888c --- /dev/null +++ b/HelloWorld/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.10) + +include(${CMAKE_CURRENT_LIST_DIR}/C/CMakeLists.txt) +include(${CMAKE_CURRENT_LIST_DIR}/Cpp/CMakeLists.txt) +if (!WIN32) + include(${CMAKE_CURRENT_LIST_DIR}/Fortran/CMakeLists.txt) +endif() diff --git a/HelloWorld/CSharp/helloworld.cs b/HelloWorld/CSharp/helloworld.cs new file mode 100644 index 0000000..afc4f98 --- /dev/null +++ b/HelloWorld/CSharp/helloworld.cs @@ -0,0 +1,10 @@ +namespace LanguageBasics +{ + class CSharpHelloWorld + { + static void Main() + { + System.Console.WriteLine("Hello, World!"); + } + } +} diff --git a/HelloWorld/Cpp/CMakeLists.txt b/HelloWorld/Cpp/CMakeLists.txt new file mode 100644 index 0000000..5fcfd9a --- /dev/null +++ b/HelloWorld/Cpp/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(CppHelloWorld) +set(CURRENT_PROJECT_CODE_NAME helloworld) +set(FILE_EXT cpp) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/HelloWorld/Cpp/helloworld.cpp b/HelloWorld/Cpp/helloworld.cpp new file mode 100644 index 0000000..11d982c --- /dev/null +++ b/HelloWorld/Cpp/helloworld.cpp @@ -0,0 +1,7 @@ +#include + +int main() +{ + std::cout << "Hello, World!" << std::endl; + return 0; +} diff --git a/HelloWorld/D/helloworld.d b/HelloWorld/D/helloworld.d new file mode 100644 index 0000000..5de808e --- /dev/null +++ b/HelloWorld/D/helloworld.d @@ -0,0 +1,6 @@ +import std.stdio; + +void main() +{ + writeln("Hello, World!"); +} diff --git a/HelloWorld/Fortran/CMakeLists.txt b/HelloWorld/Fortran/CMakeLists.txt new file mode 100644 index 0000000..afc649f --- /dev/null +++ b/HelloWorld/Fortran/CMakeLists.txt @@ -0,0 +1,34 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(FortranHelloWorld) +set(CURRENT_PROJECT_CODE_NAME helloworld) +set(FILE_EXT f90) +enable_language(Fortran) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/HelloWorld/Fortran/helloworld.f90 b/HelloWorld/Fortran/helloworld.f90 new file mode 100644 index 0000000..5ca6552 --- /dev/null +++ b/HelloWorld/Fortran/helloworld.f90 @@ -0,0 +1,3 @@ +program hello + print *, "Hello World!" +end program hello diff --git a/HelloWorld/Haskell/helloworld.hs b/HelloWorld/Haskell/helloworld.hs new file mode 100644 index 0000000..83a086a --- /dev/null +++ b/HelloWorld/Haskell/helloworld.hs @@ -0,0 +1,2 @@ +main :: IO() +main = putStrLn "Hello, World!" diff --git a/HelloWorld/Java/helloworld.java b/HelloWorld/Java/helloworld.java new file mode 100644 index 0000000..98448e4 --- /dev/null +++ b/HelloWorld/Java/helloworld.java @@ -0,0 +1,16 @@ +/* + * Implementation note: for simplicity in the makefiles, we violate the + * Coding standard for the name. Rather than use HelloWorld, we write + * helloworld to match the file name. + * It's not the best reason, but it means the makefiles wont build stuff + * that is already built. + */ +class helloworld +{ + // Your program begins with a call to main(). + // Prints "Hello, World" to the terminal window. + public static void main(String args[]) + { + System.out.println("Hello, World"); + } +} diff --git a/HelloWorld/Python/helloworld.py b/HelloWorld/Python/helloworld.py new file mode 100644 index 0000000..78309db --- /dev/null +++ b/HelloWorld/Python/helloworld.py @@ -0,0 +1 @@ +print("Hello, World!") diff --git a/HelloWorld/Rust/helloworld.rs b/HelloWorld/Rust/helloworld.rs new file mode 100644 index 0000000..449508c --- /dev/null +++ b/HelloWorld/Rust/helloworld.rs @@ -0,0 +1,4 @@ + +fn main() { + println!("Hello, World!"); +} diff --git a/ProducerConsumer/CMakeLists.txt b/ProducerConsumer/CMakeLists.txt new file mode 100644 index 0000000..ce8ed47 --- /dev/null +++ b/ProducerConsumer/CMakeLists.txt @@ -0,0 +1,3 @@ +cmake_minimum_required(VERSION 3.10) + +include(${CMAKE_CURRENT_LIST_DIR}/Cpp/CMakeLists.txt) diff --git a/ProducerConsumer/Cpp/CMakeLists.txt b/ProducerConsumer/Cpp/CMakeLists.txt new file mode 100644 index 0000000..93d2f94 --- /dev/null +++ b/ProducerConsumer/Cpp/CMakeLists.txt @@ -0,0 +1,37 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(CppProducerConsumer) +set(CURRENT_PROJECT_CODE_NAME producerconsumer) +set(FILE_EXT cpp) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) + + set(THREADS_PREFER_PTHREAD_FLAG ON) + find_package(Threads REQUIRED) + list(APPEND EXTRA_LIBS "Threads::Threads") +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/ProducerConsumer/Cpp/producerconsumer.cpp b/ProducerConsumer/Cpp/producerconsumer.cpp new file mode 100644 index 0000000..49e5ae9 --- /dev/null +++ b/ProducerConsumer/Cpp/producerconsumer.cpp @@ -0,0 +1,203 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cpp_lib_semaphore + #include + using PCSemaphore = std::counting_semaphore::max()>; +#else + // Simple semaphore since it's not a part of the C++ std + class semaphore final + { + private: + std::mutex m_mutex; + std::condition_variable m_cv; + int m_count; + + public: + semaphore(const int& initValue = 0) : m_count(initValue) {}; + void acquire() // Wait for a signal to unblock the thread + { + std::unique_lock lock(m_mutex); + while (m_count == 0) + { + m_cv.wait(lock); + } + m_count--; + } + + void release() // Notify waiters that data is available for access + { + std::unique_lock lock(m_mutex); + m_count++; + m_cv.notify_one(); + } + }; + using PCSemaphore = semaphore; +#endif + +/* + Simple producer consumer example. + + N producers write ints into a shared queue (mConsumerData). + M consumers read these ints, one at a time, then "sleep" that time to pretend its processing + + Once all the data is done, the threads join and exit. They know based on the global exit flag + + Producers P P P P + write to --> mConsumerData -> Post Semaphore --> repeat + Consumers C C C C C C + wait on semaphore --> pop oldest mConsumerData --> repeat + + The "data" is just an int for how long the consumer will "process" data. + + Essentially, the producer sleeps for some time [min,max] then pushes an int [min,max] + into the queue to simulate producing data. + The consumers wait on that int then sleep for that time to simulate processing of data. +*/ + +class ProducerConsumer final +{ +public: + struct InitParams + { + InitParams() {} + + size_t ProduceCount = 100; // How much "data" to produce + size_t MinProduceDelayMs = 0; // Min time to produce "data" + size_t MaxProduceDelayMs = 100; // Max time to produce "data" + size_t MinConsumeDelayMs = 25; // Min time to consume "data" + size_t MaxConsumeDelayMs = 1000; // Max time to consume "data" + size_t ProducerThreads = 4; // Number of producer threads to start up + size_t ConsumerThreads = 10; // Number of consumer threads to start up + }; + + ProducerConsumer(const InitParams ¶ms = InitParams()); + void Start(); + void WaitDone(); + +private: + void Producer(); + void Consumer(); + + static const int sExitFlag; + InitParams mInitParams; + std::mutex mListLock; + PCSemaphore mSemaphore; + std::queue mConsumerData; + std::vector mProducers; + std::vector mConsumers; + std::atomic_uint mProduced; + std::atomic_bool mShouldExit; +}; + +const int ProducerConsumer::sExitFlag = -1; + +ProducerConsumer::ProducerConsumer(const InitParams ¶ms) + : mInitParams(params) + , mSemaphore(0) + , mProduced(0) + , mShouldExit(false) +{ +} + +void ProducerConsumer::Start() +{ + mShouldExit = false; + + // Kick off all the consumer threads + for (size_t i = 0; i < mInitParams.ConsumerThreads; i++) + { + mConsumers.push_back(std::thread(&ProducerConsumer::Consumer, this)); + } + + // Kick off all the producer threads + for (size_t i = 0; i < mInitParams.ProducerThreads; i++) + { + mProducers.push_back(std::thread(&ProducerConsumer::Producer, this)); + } +} + +void ProducerConsumer::WaitDone() +{ + // Wait for all the producers to finish producing and exit + for (auto &t : mProducers) + { t.join(); } + + // Push the exit data flag to all the consumer threads + mListLock.lock(); + for (size_t i = 0; i < mInitParams.ConsumerThreads; i++) + { + mConsumerData.push(sExitFlag); + mSemaphore.release(); + } + mListLock.unlock(); + + + std::cout << "Waiting on consumers..." << std::endl; + for (auto &t : mConsumers) // Wait for all the consumers to finish and exit + { t.join(); } + std::cout << "All consumers done. Exiting now." << std::endl; +} + +void ProducerConsumer::Producer() +{ + unsigned int oldVal; + std::random_device randDevice; + + while (oldVal = mProduced.fetch_add(1), oldVal < mInitParams.ProduceCount) + { + // "Produce" data + std::cout << "Producing #" << oldVal << std::endl; + int delay = int((randDevice() % mInitParams.MaxProduceDelayMs) + mInitParams.MinProduceDelayMs); + std::this_thread::sleep_for(std::chrono::milliseconds(delay)); + + // push the "data" onto the queue + mListLock.lock(); + mConsumerData.push(int((randDevice() % mInitParams.MaxConsumeDelayMs) + mInitParams.MinConsumeDelayMs)); + mListLock.unlock(); + + mSemaphore.release(); + } +} + +void ProducerConsumer::Consumer() +{ + int nextData; + + while (true) + { + mSemaphore.acquire(); + + // Pull the next bit of data from the queue + mListLock.lock(); + nextData = mConsumerData.front(); + mConsumerData.pop(); + mListLock.unlock(); + + // When we pull the exit "data", we just need to break + if (nextData == sExitFlag) break; + + // otherwise, "consume" the data + std::cout << "Consuming for " << nextData << "ms" << std::endl; + std::this_thread::sleep_for(std::chrono::milliseconds(nextData)); + } +} + +int main() +{ + ProducerConsumer prod; + + prod.Start(); + prod.WaitDone(); + + return 0; +} + diff --git a/ProducerConsumer/Rust/producerconsumer.rs b/ProducerConsumer/Rust/producerconsumer.rs new file mode 100644 index 0000000..9fb4fdc --- /dev/null +++ b/ProducerConsumer/Rust/producerconsumer.rs @@ -0,0 +1,9 @@ +use std::sync::{Arc, Mutex}; +use std::thread; +use std::collections::VecDeque; + +fn main() { + let shared_queue: VecDeque = VecDeque::new(); + + println!("Hello, World!"); +} diff --git a/RecurringRainfall/Ada/recurringrainfall.adb b/RecurringRainfall/Ada/recurringrainfall.adb new file mode 100644 index 0000000..4100f98 --- /dev/null +++ b/RecurringRainfall/Ada/recurringrainfall.adb @@ -0,0 +1,48 @@ +with Ada.Text_IO; +with Ada.Text_IO.Unbounded_IO; +with Ada.Strings.Unbounded; +with Ada.Integer_Text_IO; +with Ada.IO_Exceptions; + +procedure RecurringRainfall is + Current_Average : Float := 0.0; + Current_Count : Integer := 0; + Input_Integer : Integer; + + -- Recursively attempt to get a new integer + function Get_Next_Input return Integer is + Input_Integer : Integer; + Clear_String : Ada.Strings.Unbounded.Unbounded_String; + begin + Ada.Text_IO.Put("Enter rainfall int, 99999 to quit: "); + Ada.Integer_Text_IO.Get(Input_Integer); + return Input_Integer; + exception + when Ada.IO_Exceptions.Data_Error => + Ada.Text_IO.Put_Line("Invalid input"); + -- We need to call Get_Line to make sure we flush the kb buffer + -- The pragma is to ignore the fact that we are not using the result + pragma Warnings (Off, Clear_String); + Clear_String := Ada.Text_IO.Unbounded_IO.Get_Line; + -- Recursively call self -- it'll break when valid input is hit + -- We disable the infinite recursion because we're intentionally + -- doing this. It will "break" when the user inputs valid input + -- or kills the program + pragma Warnings (Off, "infinite recursion"); + return Get_Next_Input; + pragma Warnings (On, "infinite recursion"); + end Get_Next_Input; + +begin + loop + Input_Integer := Get_Next_Input; + exit when Input_Integer = 99999; + + Current_Count := Current_Count + 1; + Current_Average := Current_Average + (Float(1) / Float(Current_Count))*Float(Input_Integer) - (Float(1) / Float(Current_Count))*Current_Average; + + Ada.Text_IO.Put("New Average: "); + Ada.Text_IO.Put_Line(Float'image(Current_Average)); + + end loop; +end RecurringRainfall; diff --git a/RecurringRainfall/C/CMakeLists.txt b/RecurringRainfall/C/CMakeLists.txt new file mode 100644 index 0000000..cdd839b --- /dev/null +++ b/RecurringRainfall/C/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(CRecurringRainfall) +set(CURRENT_PROJECT_CODE_NAME recurringrainfall) +set(FILE_EXT c) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/RecurringRainfall/C/recurringrainfall.c b/RecurringRainfall/C/recurringrainfall.c new file mode 100644 index 0000000..f555eed --- /dev/null +++ b/RecurringRainfall/C/recurringrainfall.c @@ -0,0 +1,42 @@ +#include + +int main(int argc, char **argv) +{ + // Unused variables + (void)argc; + (void)argv; + + float currentAverage = 0; + unsigned int currentEntryNumber = 0; + + for (;;) + { + int ret, entry; + + printf("Enter rainfall int, 99999 to quit: "); + ret = scanf("%d", &entry); + + if (ret) + { + if (entry == 99999) + { + printf("User requested quit.\n"); + break; + } + else + { + currentEntryNumber++; + currentAverage = currentAverage + (1.0f/currentEntryNumber)*entry - (1.0f/currentEntryNumber)*currentAverage; + + printf("New Average: %f\n", currentAverage); + } + } + else + { + printf("Invalid input\n"); + while (getchar() != '\n'); // Clear input buffer before asking again + } + } + + return 0; +} diff --git a/RecurringRainfall/CMakeLists.txt b/RecurringRainfall/CMakeLists.txt new file mode 100644 index 0000000..2619a62 --- /dev/null +++ b/RecurringRainfall/CMakeLists.txt @@ -0,0 +1,4 @@ +cmake_minimum_required(VERSION 3.10) + +include(${CMAKE_CURRENT_LIST_DIR}/C/CMakeLists.txt) +include(${CMAKE_CURRENT_LIST_DIR}/Cpp/CMakeLists.txt) diff --git a/RecurringRainfall/CSharp/recurringrainfall.cs b/RecurringRainfall/CSharp/recurringrainfall.cs new file mode 100644 index 0000000..b1950ed --- /dev/null +++ b/RecurringRainfall/CSharp/recurringrainfall.cs @@ -0,0 +1,34 @@ +namespace LanguageBasics +{ + class CSharpRecurringRainfall + { + static int ReadNextInput() + { + System.Console.Write("Enter rainfall int, 99999 to quit: "); + string input = System.Console.ReadLine(); + + if (System.Int32.TryParse(input, out int num)) + { + return num; + } + else + { + System.Console.WriteLine("Invalid input"); + return ReadNextInput(); + } + } + + static void Main() + { + double currentAverage = 0; + int currentEntryNumber = 0; + + for (int lastInput = ReadNextInput(); lastInput != 99999; lastInput = ReadNextInput()) + { + currentEntryNumber++; + currentAverage = currentAverage + (1.0/(float)currentEntryNumber)*lastInput - (1.0/(float)currentEntryNumber)*currentAverage; + System.Console.WriteLine("New Average: " + currentAverage); + } + } + } +} diff --git a/RecurringRainfall/Cpp/CMakeLists.txt b/RecurringRainfall/Cpp/CMakeLists.txt new file mode 100644 index 0000000..f3cfd11 --- /dev/null +++ b/RecurringRainfall/Cpp/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(CppRecurringRainfall) +set(CURRENT_PROJECT_CODE_NAME recurringrainfall) +set(FILE_EXT cpp) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/RecurringRainfall/Cpp/recurringrainfall.cpp b/RecurringRainfall/Cpp/recurringrainfall.cpp new file mode 100644 index 0000000..1240402 --- /dev/null +++ b/RecurringRainfall/Cpp/recurringrainfall.cpp @@ -0,0 +1,54 @@ +/* + Write a program that will read in integers and + output their average. Stop reading when the + value 99999 is input. + + Example program output/input: + Enter int: 0 + Average: 0 + Enter int: 2 + Average: 1 + ... + Enter int: 99999 +*/ + +#include +#include + +int main() +{ + float currentAverage = 0; + unsigned int currentEntryNumber = 0; + + for (;;) + { + int entry; + + std::cout << "Enter rainfall int, 99999 to quit: "; + std::cin >> entry; + + if (!std::cin.fail()) + { + if (entry == 99999) + { + std::cout << "User requested quit." << std::endl; + break; + } + else + { + currentEntryNumber++; + currentAverage = currentAverage + (1.0f/currentEntryNumber)*entry - (1.0f/currentEntryNumber)*currentAverage; + + std::cout << "New Average: " << currentAverage << std::endl; + } + } + else + { + std::cout << "Invalid input" << std::endl; + std::cin.clear(); + std::cin.ignore(std::numeric_limits::max(), '\n'); + } + } + + return 0; +} diff --git a/RecurringRainfall/D/recurringrainfall.d b/RecurringRainfall/D/recurringrainfall.d new file mode 100644 index 0000000..75610f6 --- /dev/null +++ b/RecurringRainfall/D/recurringrainfall.d @@ -0,0 +1,34 @@ +import std.stdio; + +void main() +{ + float currentAverage = 0; + uint currentEntryNumber = 0; + + for (;;) + { + int entry; + + write("Enter rainfall int, 99999 to quit: "); + + try { + readf("%d", entry); + readln(); + } + catch (Exception e) { + writeln("Invalid input"); + readln(); + continue; + } + + if (entry == 99999) { + writeln("User requested quit."); + break; + } else { + currentEntryNumber++; + currentAverage = currentAverage + (1.0/currentEntryNumber)*entry - (1.0/currentEntryNumber)*currentAverage; + + writeln("New Average: ", currentAverage); + } + } +} diff --git a/RecurringRainfall/Fortran/recurringrainfall.f90 b/RecurringRainfall/Fortran/recurringrainfall.f90 new file mode 100644 index 0000000..37d34b4 --- /dev/null +++ b/RecurringRainfall/Fortran/recurringrainfall.f90 @@ -0,0 +1,40 @@ +function getNextInput() result(Input) + implicit none + integer :: Input + integer :: Reason + Reason = 1 + + do while (Reason > 0) + print *, "Enter rainfall int, 99999 to quit: " + read (*,*,IOSTAT=Reason) Input + + if (Reason > 0) then + print *, "Invalid input" + end if + enddo + +end function getNextInput + +program recurringrainfall + implicit none + real :: currentAverage + integer :: currentCount + integer :: lastInput + integer :: getNextInput + + currentAverage = 0 + currentCount = 0 + + do + lastInput = getNextInput() + + if (lastInput == 99999) exit + + currentCount = currentCount + 1 + currentAverage = currentAverage + (1/real(currentCount))*lastInput - (1/real(currentCount))*currentAverage + + print *, 'New Average: ', currentAverage + enddo + + +end program recurringrainfall diff --git a/RecurringRainfall/Java/recurringrainfall.java b/RecurringRainfall/Java/recurringrainfall.java new file mode 100644 index 0000000..09ff691 --- /dev/null +++ b/RecurringRainfall/Java/recurringrainfall.java @@ -0,0 +1,42 @@ +class recurringrainfall +{ + private static int GetNextInt() + { + while (true) + { + System.out.print("Enter rainfall int, 99999 to quit: "); + String input = System.console().readLine(); + + try + { + int n = Integer.parseInt(input); + return n; + } + catch (Exception e) + { + System.out.println("Invalid input"); + } + } + } + + private static void recurringRainfall() { + float currentAverage = 0; + int currentEntryNumber = 0; + + while (true) { + int entry = GetNextInt(); + + if (entry == 99999) + return; + + currentEntryNumber++; + currentAverage = currentAverage + ((float)1/currentEntryNumber)*entry - ((float)1/currentEntryNumber)*currentAverage; + + System.out.println("New Average: " + currentAverage); + } + } + + public static void main(String args[]) { + recurringRainfall(); + } +} diff --git a/RecurringRainfall/Python/recurringrainfall.py b/RecurringRainfall/Python/recurringrainfall.py new file mode 100644 index 0000000..d089f09 --- /dev/null +++ b/RecurringRainfall/Python/recurringrainfall.py @@ -0,0 +1,24 @@ +import sys + +def get_next_input(): + try: + num = int(input("Enter rainfall int, 99999 to quit: ")) + except: + print("Invalid input") + return get_next_input() + return num + +current_average = 0.0 +current_count = 0 + +while True: + next = get_next_input() + + if next == 99999: + sys.exit() + else: + current_count += 1 + current_average = current_average + (1.0/current_count)*next - (1.0/current_count)*current_average + + print("New average: ", current_average) + diff --git a/RecurringRainfall/Rust/recurringrainfall.rs b/RecurringRainfall/Rust/recurringrainfall.rs new file mode 100644 index 0000000..4c7626b --- /dev/null +++ b/RecurringRainfall/Rust/recurringrainfall.rs @@ -0,0 +1,33 @@ + +fn main() { + + let mut current_average:f32 = 0.0; + let mut current_entry_number:u32 = 0; + + loop + { + let current_entry; + + println!("Enter rainfall int, 99999 to quit: "); + let mut input_text = String::new(); + std::io::stdin().read_line(&mut input_text).expect("Failed to read from stdin"); + let trimmed = input_text.trim(); + match trimmed.parse::() { + Ok(new_entry) => current_entry = new_entry, + Err(..) => { println!("Invalid input"); continue; } + }; + + if current_entry == 99999 + { + println!("User requested quit."); + break; + } + else + { + current_entry_number = current_entry_number + 1; + current_average = current_average + (1.0 / current_entry_number as f32)*(current_entry as f32) - (1.0 / current_entry_number as f32)*current_average; + + println!("New Average: {}", current_average); + } + } +} diff --git a/RecurringRainfall/directions.txt b/RecurringRainfall/directions.txt new file mode 100644 index 0000000..cf64384 --- /dev/null +++ b/RecurringRainfall/directions.txt @@ -0,0 +1,5 @@ +/* + Write a program that will read in integers and + output their average. Stop reading when the + value 99999 is input. +*/ diff --git a/RecurringRainfall/icer14.pdf b/RecurringRainfall/icer14.pdf new file mode 100644 index 0000000000000000000000000000000000000000..9b2609b3358cb1a64d99f9558fe7cb15dcdf9490 GIT binary patch literal 291518 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 literal 0 HcmV?d00001 diff --git a/TestDataServer/Program.cs b/TestDataServer/Program.cs new file mode 100644 index 0000000..1c7e20a --- /dev/null +++ b/TestDataServer/Program.cs @@ -0,0 +1,19 @@ +using System; + +namespace TestDataServer +{ + class Program + { + static void Main(string[] args) + { + TestDataServer server = new TestDataServer(); + + server.StartListening(); + + //server.StopListening(); + + server.WaitUntilThreadsClose(); + + } + } +} diff --git a/TestDataServer/TestDataServer.cs b/TestDataServer/TestDataServer.cs new file mode 100644 index 0000000..00d5fb6 --- /dev/null +++ b/TestDataServer/TestDataServer.cs @@ -0,0 +1,94 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Net; +using System.Net.Sockets; +using System.Threading; + +namespace TestDataServer +{ + class TestDataServer + { + private Mutex Mutex { get; set; } + private Thread Thread { get; set; } + private bool ShouldRun { get; set; } + + public TestDataServer() + { + Mutex = new Mutex(); + ShouldRun = false; + } + + public void StartListening() + { + if (Thread == null) + { + ShouldRun = true; + Thread = new Thread(new ThreadStart(this.ListenFunction)); + Thread.Start(); + } + } + + public void StopListening() + { + ShouldRun = false; + } + + void ListenFunction() + { + Socket listenSocket = new Socket(AddressFamily.InterNetwork, + SocketType.Stream, + ProtocolType.Tcp); + + int port = 2664; + + // bind the listening socket to the port + IPAddress hostIP = (Dns.GetHostEntry(IPAddress.Any.ToString())).AddressList[0]; + IPEndPoint ep = new IPEndPoint(hostIP, port); + listenSocket.Bind(ep); + + // start listening + listenSocket.Listen(64); + + + while (ShouldRun) + { + Socket clientSocket = listenSocket.Accept(); + ThreadPool.QueueUserWorkItem(ClientProcessingFunction, clientSocket); + } + } + + void ClientProcessingFunction(object context) + { + Socket clientSocket = context as Socket; + + byte[] socketBuffer = new byte[1024]; + string data = null; + + // Read data from client until EOF + while (true) + { + int numByte = clientSocket.Receive(socketBuffer); + + data += Encoding.ASCII.GetString(socketBuffer, + 0, numByte); + + if (data.IndexOf("") > -1) + break; + } + + Console.WriteLine("{0}: Text received -> {1} ", Thread.ManagedThreadId, data); + byte[] message = Encoding.ASCII.GetBytes("Test Server"); + + clientSocket.Close(); + } + + public void WaitUntilThreadsClose() + { + while (Thread.IsAlive) + { + Thread.Sleep(33); + } + } + } +} diff --git a/TestDataServer/TestDataServer.csproj b/TestDataServer/TestDataServer.csproj new file mode 100644 index 0000000..7322fb3 --- /dev/null +++ b/TestDataServer/TestDataServer.csproj @@ -0,0 +1,8 @@ + + + + Exe + netcoreapp3.0 + + + diff --git a/TestDataServer/TestDataServer.sln b/TestDataServer/TestDataServer.sln new file mode 100644 index 0000000..f3da4ca --- /dev/null +++ b/TestDataServer/TestDataServer.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29519.87 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestDataServer", "TestDataServer.csproj", "{C8E78006-51C2-4C27-AD65-F15ABD8C05DA}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {C8E78006-51C2-4C27-AD65-F15ABD8C05DA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C8E78006-51C2-4C27-AD65-F15ABD8C05DA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C8E78006-51C2-4C27-AD65-F15ABD8C05DA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C8E78006-51C2-4C27-AD65-F15ABD8C05DA}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {0722B7ED-F7FA-4DD6-B2E0-BDC3C59FA03A} + EndGlobalSection +EndGlobal diff --git a/gen_makefiles.sh b/gen_makefiles.sh new file mode 100644 index 0000000..b28ca81 --- /dev/null +++ b/gen_makefiles.sh @@ -0,0 +1,515 @@ +#!/usr/bin/env bash + +# Programs +declare -A PROGRAMS + +PROGRAMS[HelloWorld]="HelloWorld" +PROGRAMS[FizzBuzz]="FizzBuzz" +PROGRAMS[RecurringRainfall]="RecurringRainfall" +PROGRAMS[ProducerConsumer]="ProducerConsumer" +PROGRAMS[ArrayStack]="ArrayStack" +PROGRAMS[Endian]="Endian" +PROGRAMS[BreakMemory]="BreakMemory" +PROGRAMS[AddTwoNumbers]="l33tcode_addtwonumbers" +PROGRAMS[MedianOfSortedArrays]="l33tcode_medianofsortedarrays" +PROGRAMS[ReverseWords]="l33tcode_reversewords" +PROGRAMS[merge2sortedlists]="l33tcode_merge2sortedlists" + +######################### +# DON'T EDIT BELOW HERE # +######################### + +declare -A CC_EXISTS +declare -A CC_EXE +declare -A CC_OPTS +declare -A LINK_OPTS + +operating_system=$(uname) + +# Detect command line +if [ $# == 0 ] || [ $1 == 'opt' ]; then + echo "[INFO] Enabling optimizations and Enabling debugging" + ENABLE_OPTS=true + ENABLE_DEBUG=true +elif [ $1 == 'help' ]; then + echo "Usage: gen_makefiles.sh " + echo " args:" + echo " help - This message" + echo " debug - Generate makefiles with optimizations off and debugging enabled" + echo " opt - Generate makefiles with optimizations on and debugging enabled" + echo " release - Generate makefiles with optimizations and debugging disabled" + echo " If no args are provided, opt is the default" + exit 1 +elif [ $1 == 'debug' ]; then + echo "[INFO] Disabling optimizations and Enabling debugging" + ENABLE_OPTS=false + ENABLE_DEBUG=true +elif [ $1 == 'release' ]; then + echo "[INFO] Enabling optimizations and Disabling debugging" + ENABLE_OPTS=true + ENABLE_DEBUG=false +else + echo "[ERR] Unknown option, use gen_makefiles.sh help for help" + exit 2 +fi + +################### +# Detect compilers +# +# Tries to find the compilers on the host system +# If a compiler isn't found, it won't generate makefiles for that target +# +# Priority order: +# LLVM -> GCC -> Closed Source +function detect_compilers() { + + # Handy default to avoid copy/paste + INTERNAL_GCC_WARNINGS="-Wall" + + if [ $ENABLE_OPTS == 'true' ]; then + INTERNAL_GCC_STYLE_DEFAULT_OPTS="-O3" + fi + + if [ $ENABLE_DEBUG == 'true' ]; then + INTERNAL_GCC_STYLE_DEBUG="-g" + fi + + INTERNAL_GCC_STYLE_FLAGS="$INTERNAL_GCC_STYLE_DEFAULT_OPTS $INTERNAL_GCC_WARNINGS $INTERNAL_GCC_STYLE_DEBUG" + + # Ada Compiler + type -a gnatmake &> /dev/null + if [ $? == 0 ]; then + echo [INFO] Found Ada gnatmake, using gnatmake for Ada + CC_EXISTS['Ada']=true + CC_EXE['Ada']=gnatmake + CC_OPTS['Ada']=$INTERNAL_GCC_STYLE_FLAGS + else + echo [WARN] No Ada compiler found, no Ada makefiles will be generated + fi + + # C Compiler + type -a clang &> /dev/null + INT_HAS_CLANG=$? + type -a gcc &> /dev/null + INT_HAS_GCC=$? + if [ $INT_HAS_CLANG == 0 ]; then + echo [INFO] Found clang, using clang for C + CC_EXISTS['C']=true + CC_EXE['C']=clang + CC_OPTS['C']=$INTERNAL_GCC_STYLE_FLAGS + elif [ $INT_HAS_GCC == 0 ]; then + echo [INFO] No clang, found gcc, using gcc for C + CC_EXISTS['C']=true + CC_EXE['C']=gcc + CC_OPTS['C']=$INTERNAL_GCC_STYLE_FLAGS + else + echo [WARN] No C compiler found, no C makefiles will be generated + fi + + # Cpp Compiler + type -a clang++ &> /dev/null + INT_HAS_CLANGPP=$? + type -a g++ &> /dev/null + INT_HAS_GPP=$? + if [ $INT_HAS_CLANGPP == 0 ]; then + echo [INFO] Found clang++, using clang for C++ + CC_EXISTS['Cpp']=true + CC_EXE['Cpp']=clang++ + CC_OPTS['Cpp']=$INTERNAL_GCC_STYLE_FLAGS + elif [ $INT_HAS_GPP == 0 ]; then + echo [INFO] No clang++, found g++, using g++ for C++ + CC_EXISTS['Cpp']=true + CC_EXE['Cpp']=g++ + CC_OPTS['Cpp']=$INTERNAL_GCC_STYLE_FLAGS + else + echo [WARN] No C++ compiler found, no C++ makefiles will be generated + fi + + if [ $operating_system == 'Linux' ]; then + LINK_OPTS['Cpp']="-lpthread" + elif [ $operating_system == 'FreeBSD' ]; then + LINK_OPTS['Cpp']="-lpthread" + fi + + # C# Compiler + type -a mcs &> /dev/null + if [ $? == 0 ]; then + echo [INFO] Found mcs, using mcs for C# + CC_EXISTS['CSharp']=true + CC_EXE['CSharp']=mcs + + if [ $ENABLE_DEBUG == true ]; then + CSHARP_DEBUG="-debug" + fi + + if [ $ENABLE_OPTS == true ]; then + CSHARP_OPTS="-optimize" + fi + + CC_OPTS['CSharp']="$CSHARP_DEBUG $CSHARP_OPTS" + else + echo [WARN] No C# compiler found, no C# makefiles will be generated + fi + + # D Compiler + type -a ldc2 &> /dev/null + INT_HAS_LDC2=$? + type -a gdc &> /dev/null + INT_HAS_GDC=$? + if [ $INT_HAS_LDC2 == 0 ]; then + echo [INFO] Found ldc2, using ldc2 for D + CC_EXISTS['D']=true + CC_EXE['D']=ldc2 + + if [ $ENABLE_DEBUG == true ]; then + D_DEBUG="-g" + fi + + if [ $ENABLE_OPTS == true ]; then + D_OPTS="-O3" + fi + + CC_OPTS['D']="$D_DEBUG $D_OPTS" + elif [ $INT_HAS_GDC == 0 ]; then + echo [INFO] No ldc2, found gdc, using gdc for D + CC_EXISTS['D']=true + CC_EXE['D']=gdc + CC_OPTS['D']=$INTERNAL_GCC_STYLE_FLAGS + else + echo [WARN] No D compiler found, no D makefiles will be generated + fi + + # Fortran compiler + type -a flang &> /dev/null + INT_HAS_FLANG=$? + type -a gfortran &> /dev/null + INT_HAS_GFORTRAN=$? + if [ $INT_HAS_FLANG == 0 ]; then + echo [INFO] Found flang, using flang for Fortran + CC_EXISTS['Fortran']=true + CC_EXE['Fortran']=flang + if [ $operating_system == 'FreeBSD' ]; then + CC_OPTS['Fortran']="$INTERNAL_GCC_STYLE_FLAGS -lexecinfo" + else + CC_OPTS['Fortran']=$INTERNAL_GCC_STYLE_FLAGS + fi + elif [ $INT_HAS_GFORTRAN == 0 ]; then + echo [INFO] No flang, found gfortran, using gfortran for Fortran + CC_EXISTS['Fortran']=true + CC_EXE['Fortran']=gfortran + CC_OPTS['Fortran']=$INTERNAL_GCC_STYLE_FLAGS + else + echo [WARN] No Fortran compiler found, no Fortran makefiles will be generated + fi + + # Haskell Compiler + type -a ghc &> /dev/null + if [ $? == 0 ]; then + echo [INFO] Found ghc, using ghc for Haskell + CC_EXISTS['Haskell']=true + CC_EXE['Haskell']=ghc + if [ $ENABLE_DEBUG == true ]; then + HASKELL_DEBUG="-g" + fi + + if [ $ENABLE_OPTS == true ]; then + HASKELL_OPTS="-O3" + fi + CC_OPTS['Haskell']="-Wall $HASKELL_DEBUG $HASKELL_OPTS" + else + echo [WARN] No Haskell compiler found, no Haskell makefiles will be generated + fi + + # Java compiler + type -a javac &> /dev/null + if [ $? == 0 ]; then + echo [INFO] Found javac, using javac for Java + CC_EXISTS['Java']=true + CC_EXE['Java']=javac + CC_OPTS['Java']= + if [ $ENABLE_DEBUG == true ]; then + CC_OPTS['Java']="-g" + fi + else + echo [WARN] No Java compiler found, no Java makefiles will be generated + fi + + # Rust compiler + type -a rustc &> /dev/null + if [ $? == 0 ]; then + echo [INFO] Found rustc, using rustc for Rust + CC_EXISTS['Rust']=true + CC_EXE['Rust']=rustc + + if [ $ENABLE_DEBUG == true ]; then + RUST_DEBUG="-g" + fi + + if [ $ENABLE_OPTS == true ]; then + RUST_OPTS="-C opt-level=3" + fi + CC_OPTS['Rust']="$RUST_DEBUG $RUST_OPTS" + else + echo [WARN] No Rust compiler found, no Rust makefiles will be generated + fi +} + +function gen_std_program_makefile() { + declare makefile=$1 + + echo "\$(PROB): \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + printf "\t%s\n\n" "\$(CC) \$(CC_OPTS) -o \$(PROB) \$(DIR)/\$(PROB).\$(EXT) \$(LINK_OPTS)" >> $makefile + echo "clean:" >> $makefile + printf "\t%s\n" "rm \$(PROB)" >> $makefile +} + +function gen_ghc_program_makefile() { + declare makefile=$1 + + echo "\$(PROB): \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + printf "\t%s\n\n" "\$(CC) \$(CC_OPTS) -o \$(PROB) \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + echo "clean:" >> $makefile + printf "\t%s\n" "rm \$(PROB) \$(DIR)/\$(PROB).o \$(DIR)/\$(PROB).hi" >> $makefile +} + + +function gen_gnat_program_makefile() { + declare makefile=$1 + + echo "\$(PROB): \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + printf "\t%s\n\n" "\$(CC) \$(CC_OPTS) -o \$(PROB) \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + echo "clean:" >> $makefile + printf "\t%s\n" "rm \$(PROB) \$(PROB).o \$(PROB).ali" >> $makefile +} + +function gen_ldc_program_makefile() { + declare makefile=$1 + + echo "\$(PROB): \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + printf "\t%s\n\n" "\$(CC) \$(CC_OPTS) -of=\$(PROB) \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + echo "clean:" >> $makefile + printf "\t%s\n" "rm \$(PROB) \$(PROB).o" >> $makefile +} + +function gen_mcs_program_makefile() { + declare makefile=$1 + + echo "\$(PROB): \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + printf "\t%s\n\n" "\$(CC) \$(CC_OPTS) -out:\$(PROB) \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + echo "clean:" >> $makefile + printf "\t%s\n" "rm \$(PROB)" >> $makefile +} + +function gen_javac_program_makefile() { + declare makefile=$1 + + echo "\$(PROB).class: \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + printf "\t%s\n\n" "\$(CC) \$(CC_OPTS) -d . \$(DIR)/\$(PROB).\$(EXT)" >> $makefile + echo "clean:" >> $makefile + printf "\t%s\n" "rm *.class" >> $makefile +} + +function gen_Ada_program_makefile() { + declare program=$1 + declare makefile=$2 + declare src_dir=$3 + declare cc_exe=$4 + declare cc_opts=$5 + + echo [GEN] Writing makefile for Ada:$program to $makefile + + echo PROB=${program,,} > $makefile + echo EXT=adb >> $makefile + echo CC=$cc_exe >> $makefile + echo CC_OPTS=$cc_opts >> $makefile + echo DIR=$src_dir >> $makefile + echo "" >> $makefile + + gen_gnat_program_makefile $makefile +} + +function gen_C_program_makefile() { + declare program=$1 + declare makefile=$2 + declare src_dir=$3 + declare cc_exe=$4 + declare cc_opts=$5 + declare link_opts=$6 + + echo [GEN] Writing makefile for C:$program to $makefile + + echo PROB=${program,,} > $makefile + echo EXT=c >> $makefile + echo CC=$cc_exe >> $makefile + echo CC_OPTS=$cc_opts >> $makefile + echo LINK_OPTS=$link_opts >> $makefile + echo DIR=$src_dir >> $makefile + echo "" >> $makefile + + gen_std_program_makefile $makefile +} + +function gen_Cpp_program_makefile() { + declare program=$1 + declare makefile=$2 + declare src_dir=$3 + declare cc_exe=$4 + declare cc_opts=$5 + declare link_opts=$6 + + echo [GEN] Writing makefile for Cpp:$program to $makefile + + echo PROB=${program,,} > $makefile + echo EXT=cpp >> $makefile + echo CC=$cc_exe >> $makefile + echo CC_OPTS=$cc_opts >> $makefile + echo LINK_OPTS=$link_opts >> $makefile + echo DIR=$src_dir >> $makefile + echo "" >> $makefile + + gen_std_program_makefile $makefile +} + +function gen_CSharp_program_makefile() { + declare program=$1 + declare makefile=$2 + declare src_dir=$3 + declare cc_exe=$4 + declare cc_opts=$5 + + echo [GEN] Writing makefile for CSharp:$program to $makefile + + echo PROB=${program,,} > $makefile + echo EXT=cs >> $makefile + echo CC=$cc_exe >> $makefile + echo CC_OPTS=$cc_opts >> $makefile + echo DIR=$src_dir >> $makefile + echo "" >> $makefile + + gen_mcs_program_makefile $makefile +} + +function gen_D_program_makefile() { + declare program=$1 + declare makefile=$2 + declare src_dir=$3 + declare cc_exe=$4 + declare cc_opts=$5 + + echo [GEN] Writing makefile for D:$program to $makefile + + echo PROB=${program,,} > $makefile + echo EXT=d >> $makefile + echo CC=$cc_exe >> $makefile + echo CC_OPTS=$cc_opts >> $makefile + echo DIR=$src_dir >> $makefile + echo "" >> $makefile + + if [[ $cc_exe == ldc2 ]]; then + gen_ldc_program_makefile $makefile + else + gen_std_program_makefile $makefile + fi +} + +function gen_Fortran_program_makefile() { + declare program=$1 + declare makefile=$2 + declare src_dir=$3 + declare cc_exe=$4 + declare cc_opts=$5 + + echo [GEN] Writing makefile for Fortran:$program to $makefile + + echo PROB=${program,,} > $makefile + echo EXT=f90 >> $makefile + echo CC=$cc_exe >> $makefile + echo CC_OPTS=$cc_opts >> $makefile + echo DIR=$src_dir >> $makefile + echo "" >> $makefile + + gen_std_program_makefile $makefile +} + +function gen_Haskell_program_makefile() { + declare program=$1 + declare makefile=$2 + declare src_dir=$3 + declare cc_exe=$4 + declare cc_opts=$5 + + echo [GEN] Writing makefile for Haskell:$program to $makefile + + echo PROB=${program,,} > $makefile + echo EXT=hs >> $makefile + echo CC=$cc_exe >> $makefile + echo CC_OPTS=$cc_opts >> $makefile + echo DIR=$src_dir >> $makefile + echo "" >> $makefile + + gen_ghc_program_makefile $makefile +} + +function gen_Java_program_makefile() { + declare program=$1 + declare makefile=$2 + declare src_dir=$3 + declare cc_exe=$4 + declare cc_opts=$5 + + echo [GEN] Writing makefile for Java:$program to $makefile + + echo PROB=${program,,} > $makefile + echo EXT=java >> $makefile + echo CC=$cc_exe >> $makefile + echo CC_OPTS=$cc_opts >> $makefile + echo DIR=$src_dir >> $makefile + echo "" >> $makefile + + gen_javac_program_makefile $makefile +} + +function gen_Rust_program_makefile() { + declare program=$1 + declare makefile=$2 + declare src_dir=$3 + declare cc_exe=$4 + declare cc_opts=$5 + + echo [GEN] Writing makefile for Rust:$program to $makefile + + echo PROB=${program,,} > $makefile + echo EXT=rs >> $makefile + echo CC=$cc_exe >> $makefile + echo CC_OPTS=$cc_opts >> $makefile + echo DIR=$src_dir >> $makefile + echo "" >> $makefile + + gen_std_program_makefile $makefile +} + +function gen_program_makefile() { + declare program=$1 + + echo [INFO] Writing makes files for $program + + cd $program + + for lang_name in *; do + if [ ${CC_EXISTS[${lang_name}]} ]; then + mkdir -p ../build/$program/$lang_name + COMMAND="gen_${lang_name}_program_makefile $program ../build/$program/$lang_name/Makefile ../../../$program/$lang_name ${CC_EXE[${lang_name}]} '${CC_OPTS[${lang_name}]}' '${LINK_OPTS[${lang_name}]}'" + eval $COMMAND + else + echo [INFO] $lang_name has no compiler, skipping makefile generation + fi + done + + cd .. +} + +detect_compilers + +for program in "${PROGRAMS[@]}"; do + gen_program_makefile $program +done diff --git a/l33tcode_addtwonumbers/CMakeLists.txt b/l33tcode_addtwonumbers/CMakeLists.txt new file mode 100644 index 0000000..7346449 --- /dev/null +++ b/l33tcode_addtwonumbers/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.10) + +#include(${CMAKE_CURRENT_LIST_DIR}/C/CMakeLists.txt) +include(${CMAKE_CURRENT_LIST_DIR}/Cpp/CMakeLists.txt) +if (!WIN32) + include(${CMAKE_CURRENT_LIST_DIR}/Fortran/CMakeLists.txt) +endif() diff --git a/l33tcode_addtwonumbers/Cpp/CMakeLists.txt b/l33tcode_addtwonumbers/Cpp/CMakeLists.txt new file mode 100644 index 0000000..f158109 --- /dev/null +++ b/l33tcode_addtwonumbers/Cpp/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(Cppl33tcode_addtwonumbers) +set(CURRENT_PROJECT_CODE_NAME l33tcode_addtwonumbers) +set(FILE_EXT cpp) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/l33tcode_addtwonumbers/Cpp/leetcode_addtwonumbers.cpp b/l33tcode_addtwonumbers/Cpp/leetcode_addtwonumbers.cpp new file mode 100644 index 0000000..b385d60 --- /dev/null +++ b/l33tcode_addtwonumbers/Cpp/leetcode_addtwonumbers.cpp @@ -0,0 +1,126 @@ +// AddTwoNumbers.cpp : This file contains the 'main' function. Program execution begins and ends there. +// + +#include +#include + +struct ListNode { + int val; + ListNode* next; + ListNode() : val(0), next(nullptr) {} + ListNode(int x) : val(x), next(nullptr) {} + ListNode(int x, ListNode* next) : val(x), next(next) {} + + void print() + { + ListNode* head = this; + while (head) + { + printf("(%d)->", head->val); + head = head->next; + } + printf("\n"); + } +}; + +class Solution { +private: + static inline void iterate(ListNode*& l1, ListNode*& l2) + { + l1 = l1->next; + l2 = l2->next; + } + + static inline void iterate(ListNode*& l) + { + l = l->next; + } + +public: + ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { + ListNode* left = l1, *right = l2; + ListNode* toRet = new ListNode(); + ListNode* current = toRet, *prev = nullptr; + + int carryover = 0; + + short val = (left->val + right->val); + current->val = val % 10; + carryover = val >= 10 ? 1 : 0; + current->next = nullptr; + prev = current; + iterate(current); + + iterate(left, right); + + while (true) + { + if (left && right) + { + short val = (carryover + left->val + right->val); + carryover = val >= 10 ? 1 : 0; + current = new ListNode(val % 10, nullptr); + prev->next = current; + prev = current; + iterate(current); + + iterate(left, right); + } + else if (left || right) + { + ListNode** toAdd = left ? &left : &right; + while (*toAdd) + { + short val = (carryover + (*toAdd)->val); + carryover = val >= 10 ? 1 : 0; + current = new ListNode(val % 10, nullptr); + + prev->next = current; + prev = current; + iterate(current); + + iterate(*toAdd); + } + } + else + { + if (carryover) + { + current = new ListNode(1, nullptr); + + prev->next = current; + prev = current; + iterate(current); + } + break; + } + } + + return toRet; + } +}; + +int main() +{ + ListNode num1(9, new ListNode(9, nullptr)); // 32 + ListNode num2(9, new ListNode(9, new ListNode(9, nullptr))); // 54 + + num1.print(); + num2.print(); + + Solution s; + s.addTwoNumbers(&num1, &num2)->print(); + + return 0; +} + +// Run program: Ctrl + F5 or Debug > Start Without Debugging menu +// Debug program: F5 or Debug > Start Debugging menu + +// Tips for Getting Started: +// 1. Use the Solution Explorer window to add/manage files +// 2. Use the Team Explorer window to connect to source control +// 3. Use the Output window to see build output and other messages +// 4. Use the Error List window to view errors +// 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project +// 6. In the future, to open this project again, go to File > Open > Project and select the .sln file diff --git a/l33tcode_addtwonumbers/Rust/leetcode_addtwonumbers.rs b/l33tcode_addtwonumbers/Rust/leetcode_addtwonumbers.rs new file mode 100644 index 0000000..691d1a1 --- /dev/null +++ b/l33tcode_addtwonumbers/Rust/leetcode_addtwonumbers.rs @@ -0,0 +1,25 @@ +// Definition for singly-linked list. +#[derive(PartialEq, Eq, Clone, Debug)] +pub struct ListNode { + pub val: i32, + pub next: Option> +} + +impl ListNode { + #[inline] + fn new(val: i32) -> Self { + ListNode { + next: None, + val + } + } +} +impl Solution { + pub fn add_two_numbers(l1: Option>, l2: Option>) -> Option> { + + } +} + +fn main() { + println!("Hello, World!"); +} \ No newline at end of file diff --git a/l33tcode_medianofsortedarrays/CMakeLists.txt b/l33tcode_medianofsortedarrays/CMakeLists.txt new file mode 100644 index 0000000..7346449 --- /dev/null +++ b/l33tcode_medianofsortedarrays/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.10) + +#include(${CMAKE_CURRENT_LIST_DIR}/C/CMakeLists.txt) +include(${CMAKE_CURRENT_LIST_DIR}/Cpp/CMakeLists.txt) +if (!WIN32) + include(${CMAKE_CURRENT_LIST_DIR}/Fortran/CMakeLists.txt) +endif() diff --git a/l33tcode_medianofsortedarrays/Cpp/CMakeLists.txt b/l33tcode_medianofsortedarrays/Cpp/CMakeLists.txt new file mode 100644 index 0000000..88c76b5 --- /dev/null +++ b/l33tcode_medianofsortedarrays/Cpp/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(Cppl33tcode_medianofsortedarrays) +set(CURRENT_PROJECT_CODE_NAME l33tcode_medianofsortedarrays) +set(FILE_EXT cpp) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/l33tcode_medianofsortedarrays/Cpp/l33tcode_medianofsortedarrays.cpp b/l33tcode_medianofsortedarrays/Cpp/l33tcode_medianofsortedarrays.cpp new file mode 100644 index 0000000..19e5848 --- /dev/null +++ b/l33tcode_medianofsortedarrays/Cpp/l33tcode_medianofsortedarrays.cpp @@ -0,0 +1,79 @@ +// MedianOfSortedArrays.cpp : This file contains the 'main' function. Program execution begins and ends there. +// + +#include +#include + +using namespace std; + +class Solution { +public: + double findMedianSortedArrays(vector& nums1, vector& nums2) + { + vector combined; + combined.resize(nums1.size() + nums2.size()); + + size_t i = 0, j = 0; + size_t index = 0, max = nums1.size() + nums2.size(); + + for (; i < nums1.size() && j < nums2.size(); ) + { + if (nums1[i] < nums2[j]) + { + combined[index] = nums1[i]; + index++, i++; + } + else + { + combined[index] = nums2[j]; + index++, j++; + } + } + + for (; i < nums1.size(); i++) + { + combined[index] = nums1[i]; + index++; + } + for (; j < nums2.size(); j++) + { + combined[index] = nums2[j]; + index++; + } + + double median; + size_t size = combined.size(); + if (combined.size() % 2 == 0) + { + median = (combined[size / 2 - 1] + combined[size / 2]) / 2.0f; + } + else + { + median = combined[size / 2]; + } + + return median; + } +}; + +int main() +{ + vector s1{ 1,2 }; + vector s2{ 3,4}; + Solution s; + + cout << s.findMedianSortedArrays(s1, s2) << endl; + + +} + +// Run program: Ctrl + F5 or Debug > Start Without Debugging menu +// Debug program: F5 or Debug > Start Debugging menu + +// Tips for Getting Started: +// 1. Use the Solution Explorer window to add/manage files +// 2. Use the Team Explorer window to connect to source control +// 3. Use the Output window to see build output and other messages +// 4. Use the Error List window to view errors +// 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project +// 6. In the future, to open this project again, go to File > Open > Project and select the .sln file diff --git a/l33tcode_medianofsortedarrays/Rust/l33tcode_medianofsortedarrays.rs b/l33tcode_medianofsortedarrays/Rust/l33tcode_medianofsortedarrays.rs new file mode 100644 index 0000000..0b4c482 --- /dev/null +++ b/l33tcode_medianofsortedarrays/Rust/l33tcode_medianofsortedarrays.rs @@ -0,0 +1,5 @@ +impl Solution { + pub fn find_median_sorted_arrays(nums1: Vec, nums2: Vec) -> f64 { + + } +} \ No newline at end of file diff --git a/l33tcode_merge2sortedlists/CMakeLists.txt b/l33tcode_merge2sortedlists/CMakeLists.txt new file mode 100644 index 0000000..7346449 --- /dev/null +++ b/l33tcode_merge2sortedlists/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.10) + +#include(${CMAKE_CURRENT_LIST_DIR}/C/CMakeLists.txt) +include(${CMAKE_CURRENT_LIST_DIR}/Cpp/CMakeLists.txt) +if (!WIN32) + include(${CMAKE_CURRENT_LIST_DIR}/Fortran/CMakeLists.txt) +endif() diff --git a/l33tcode_merge2sortedlists/Cpp/CMakeLists.txt b/l33tcode_merge2sortedlists/Cpp/CMakeLists.txt new file mode 100644 index 0000000..75f792c --- /dev/null +++ b/l33tcode_merge2sortedlists/Cpp/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(Cppl33tcode_merge2sortedlists) +set(CURRENT_PROJECT_CODE_NAME l33tcode_merge2sortedlists) +set(FILE_EXT cpp) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/l33tcode_merge2sortedlists/Cpp/l33tcode_merge2sortedlists.cpp b/l33tcode_merge2sortedlists/Cpp/l33tcode_merge2sortedlists.cpp new file mode 100644 index 0000000..c096c86 --- /dev/null +++ b/l33tcode_merge2sortedlists/Cpp/l33tcode_merge2sortedlists.cpp @@ -0,0 +1,111 @@ +// Merge2SortedLists.cpp : This file contains the 'main' function. Program execution begins and ends there. +// + +#include + +struct ListNode { + int val; + ListNode* next; + ListNode() : val(0), next(nullptr) {} + ListNode(int x) : val(x), next(nullptr) {} + ListNode(int x, ListNode* next) : val(x), next(next) {} + +}; + +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode() : val(0), next(nullptr) {} + * ListNode(int x) : val(x), next(nullptr) {} + * ListNode(int x, ListNode *next) : val(x), next(next) {} + * }; + */ +class Solution { +public: + ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { + ListNode* head = nullptr; + + if (l1 && l2 && l1->val < l2->val) + { + head = l1; + l1 = l1->next; + head->next = nullptr; + } + else if (l2) + { + head = l2; + l2 = l2->next; + head->next = nullptr; + } + + ListNode* newList = head; + + if (l1 && l2) + { + while (l1 != nullptr && l2 != nullptr) + { + if (l1->val < l2->val) + { + newList->next = l1; + l1 = l1->next; + newList = newList->next; + newList->next = nullptr; + } + else + { + newList->next = l2; + l2 = l2->next; + newList = newList->next; + newList->next = nullptr; + } + } + } + + while (l1 != nullptr) + { + newList->next = l1; + newList = newList->next; + newList->next = nullptr; + } + + while (l2 != nullptr) + { + newList->next = l2; + newList = newList->next; + newList->next = nullptr; + } + + return head; + } +}; + +int main() +{ + Solution s; + s.mergeTwoLists(nullptr, nullptr); + + ListNode *one = new ListNode(4); + ListNode* two = new ListNode(2, one); + ListNode* three = new ListNode(1, two); + + ListNode* one1 = new ListNode(4); + ListNode* two1 = new ListNode(3, one); + ListNode* three1 = new ListNode(1, two); + + s.mergeTwoLists(three, three1); + + std::cout << "Hello World!\n"; +} + +// Run program: Ctrl + F5 or Debug > Start Without Debugging menu +// Debug program: F5 or Debug > Start Debugging menu + +// Tips for Getting Started: +// 1. Use the Solution Explorer window to add/manage files +// 2. Use the Team Explorer window to connect to source control +// 3. Use the Output window to see build output and other messages +// 4. Use the Error List window to view errors +// 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project +// 6. In the future, to open this project again, go to File > Open > Project and select the .sln file diff --git a/l33tcode_merge2sortedlists/Rust/l33tcode_merge2sortedlists.rs b/l33tcode_merge2sortedlists/Rust/l33tcode_merge2sortedlists.rs new file mode 100644 index 0000000..e69de29 diff --git a/l33tcode_reversewords/CMakeLists.txt b/l33tcode_reversewords/CMakeLists.txt new file mode 100644 index 0000000..7346449 --- /dev/null +++ b/l33tcode_reversewords/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 3.10) + +#include(${CMAKE_CURRENT_LIST_DIR}/C/CMakeLists.txt) +include(${CMAKE_CURRENT_LIST_DIR}/Cpp/CMakeLists.txt) +if (!WIN32) + include(${CMAKE_CURRENT_LIST_DIR}/Fortran/CMakeLists.txt) +endif() diff --git a/l33tcode_reversewords/Cpp/CMakeLists.txt b/l33tcode_reversewords/Cpp/CMakeLists.txt new file mode 100644 index 0000000..b007f3b --- /dev/null +++ b/l33tcode_reversewords/Cpp/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.10) + +# Modify only these if one source file! +project(Cppl33tcode_reversewords) +set(CURRENT_PROJECT_CODE_NAME l33tcode_reversewords) +set(FILE_EXT cpp) +# End + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED True) +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED True) + +# We want all the warnings and as errors enabled +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +add_executable(${CMAKE_PROJECT_NAME} ${CMAKE_CURRENT_LIST_DIR}/${CURRENT_PROJECT_CODE_NAME}.${FILE_EXT}) + +target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_INCLUDES} + ) + +target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC + ${EXTRA_LIBS} + ) + + diff --git a/l33tcode_reversewords/Cpp/l33tcode_reversewords.cpp b/l33tcode_reversewords/Cpp/l33tcode_reversewords.cpp new file mode 100644 index 0000000..dc8cc3f --- /dev/null +++ b/l33tcode_reversewords/Cpp/l33tcode_reversewords.cpp @@ -0,0 +1,64 @@ +// https://leetcode.com/problems/reverse-words-in-a-string/ + +#include +#include +#include +#include +#include + +using namespace std; + +static string_view findWord(const string& str, size_t &index) +{ + size_t startIndex, endIndex; + + // Start of word + while (index < str.size() && isspace(str[index])) index++; + startIndex = index; + + // Last letter + while (index < str.size() && !isspace(str[index])) index++; + endIndex = index; + + return string_view(str.c_str() + startIndex, endIndex - startIndex); + +} + +class Solution { +public: + string reverseWords(string s) { + vector words; + size_t index = 0; + do + { + string_view sv = findWord(s, index); + if (!sv.empty()) + { + words.push_back(sv); + } + } while (index < s.size()); + + string toRet; + toRet.reserve(s.size()); + + for (auto iter = words.crbegin(); iter != words.crend(); iter++) + { + toRet += *iter; + toRet += " "; + } + toRet.resize(toRet.size() - 1); + + return toRet; + + } +}; + +int main() +{ + Solution s; + cout << s.reverseWords("the sky is blue") << endl; + cout << s.reverseWords(" hello world ") << endl; + cout << s.reverseWords("a good example") << endl; + cout << s.reverseWords(" Bob Loves Alice ") << endl; +} + diff --git a/l33tcode_reversewords/Rust/l33tcode_reversewords.rs b/l33tcode_reversewords/Rust/l33tcode_reversewords.rs new file mode 100644 index 0000000..4612b55 --- /dev/null +++ b/l33tcode_reversewords/Rust/l33tcode_reversewords.rs @@ -0,0 +1,13 @@ +trait Solution { + fn reverse_words(s: String) -> String; +} + +impl Solution { + pub fn reverse_words(s: String) -> String { + + } +} + +fn main() { + println!("Hello, World!"); +} diff --git a/make_all.sh b/make_all.sh new file mode 100644 index 0000000..5f663c2 --- /dev/null +++ b/make_all.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash + +if [ $# == 0 ]; then + bash gen_makefiles.sh +else + bash gen_makefiles.sh $1 + if [ $? == 2 ]; then + exit 2 + fi +fi + +cd build + +for program in *; do + cd $program + for lang_name in *; do + cd $lang_name + make + cd .. + done + cd .. +done + +cd .. diff --git a/malloc/Cpp/malloc.cpp b/malloc/Cpp/malloc.cpp new file mode 100644 index 0000000..55cf854 --- /dev/null +++ b/malloc/Cpp/malloc.cpp @@ -0,0 +1,131 @@ +#include +#include + +/* + * Contains functions provided by the operating system + */ +namespace OurImaginaryOS +{ + /* + * Return 1024byte aligned page of size PAGE_SIZE * pageCount + * e.g. GetNewPage(1) returns a 32MiB page (PAGE_SIZE) + * GetNewPage(2) returns two contiguous pages, totaling 64MiB + * GetNewPage(0) is undefined. + */ + void *GetNewPage(size_t pageCount = 1); + void FreePage(void *p); + + const size_t PAGE_SIZE = 32 * 1024 * 1024; +} + +/* IAllocator interface for memory allocations. + Example Usage: + + struct Foo() { + IAllocator &mAllocator; + MyDynamicObject *mDynamicObject; + + void Foo(IAllocator &allocator) + : mAllocator(allocator) + { + mDynamicObject = new(mAllocator.Alloc(sizeof(*mDynamicObject)) MyDynamicObject(); + } + + void ~Foo() + { + mDynamicObject->~MyDynamicObject(); + mAllocator.Free(mDynamicObject); + } + } +*/ +class IAllocator +{ +public: + // size in bytes + // alignment in bytes, 0 means don't care + // alignOffset: offset to align returned pointer. E.g. alignoffset of 4: + // ptr aligned start point that matches alignment parameter. + // ^ ^ + // | 4 bytes | Rest of block of size "size - alignOffset" | + // flags - currently unused + virtual void *Alloc(size_t size, size_t alignment = 0, size_t alignOffset = 0, int64_t flags = 0) = 0; + virtual void Free(void *ptr) = 0; + + virtual ~IAllocator() = default; +}; + +using namespace OurImaginaryOS; + +class MyAllocator : public IAllocator +{ +public: + MyAllocator() + { + + } + + virtual void *Alloc(size_t size, size_t alignment = 0, size_t alignOffset = 0, int64_t flags = 0) + { + return nullptr; + } + + virtual void Free(void *ptr) + { + } + + virtual ~MyAllocator() + { + + } +}; + +int main() +{ + return 0; +} + +/*********************************************************/ +// Stuff to make coding game syntax highlighting work +// Don't worry about what's below here. + +#include +#include + +namespace OurImaginaryOS +{ + static std::mutex s_internalPagesLock; + static std::vector s_internalPages; + + void *GetNewPage(size_t pageCount) + { + void *newPage = malloc(PAGE_SIZE * pageCount); + + s_internalPagesLock.lock(); + s_internalPages.push_back(newPage); + s_internalPagesLock.unlock(); + + return newPage; + } + + void FreePage(void *p) + { + void *toFree = nullptr; + + s_internalPagesLock.lock(); + for (auto iter = s_internalPages.begin(); iter != s_internalPages.end(); iter++) + { + if (*iter == p) + { + toFree = p; + s_internalPages.erase(iter); + break; + } + } + s_internalPagesLock.unlock(); + + if (toFree) + { + free(p); + } + } +} diff --git a/solution/LanguageBasics/LanguageBasics.sln b/solution/LanguageBasics/LanguageBasics.sln new file mode 100644 index 0000000..281f4b3 --- /dev/null +++ b/solution/LanguageBasics/LanguageBasics.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.30611.23 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ProducerConsumerCpp", "ProducerConsumerCpp\ProducerConsumerCpp.vcxproj", "{DAD3BB7C-72DF-40DB-BFC3-F24A39E5DA1A}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {DAD3BB7C-72DF-40DB-BFC3-F24A39E5DA1A}.Debug|x64.ActiveCfg = Debug|x64 + {DAD3BB7C-72DF-40DB-BFC3-F24A39E5DA1A}.Debug|x64.Build.0 = Debug|x64 + {DAD3BB7C-72DF-40DB-BFC3-F24A39E5DA1A}.Debug|x86.ActiveCfg = Debug|Win32 + {DAD3BB7C-72DF-40DB-BFC3-F24A39E5DA1A}.Debug|x86.Build.0 = Debug|Win32 + {DAD3BB7C-72DF-40DB-BFC3-F24A39E5DA1A}.Release|x64.ActiveCfg = Release|x64 + {DAD3BB7C-72DF-40DB-BFC3-F24A39E5DA1A}.Release|x64.Build.0 = Release|x64 + {DAD3BB7C-72DF-40DB-BFC3-F24A39E5DA1A}.Release|x86.ActiveCfg = Release|Win32 + {DAD3BB7C-72DF-40DB-BFC3-F24A39E5DA1A}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {F74E0D73-9C68-40B3-A717-470ACF50BA2A} + EndGlobalSection +EndGlobal diff --git a/solution/LanguageBasics/ProducerConsumerCpp/ProducerConsumerCpp.vcxproj b/solution/LanguageBasics/ProducerConsumerCpp/ProducerConsumerCpp.vcxproj new file mode 100644 index 0000000..5db92ee --- /dev/null +++ b/solution/LanguageBasics/ProducerConsumerCpp/ProducerConsumerCpp.vcxproj @@ -0,0 +1,148 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + + + 16.0 + Win32Proj + {dad3bb7c-72df-40db-bfc3-f24a39e5da1a} + ProducerConsumerCpp + 10.0 + + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + false + + + true + + + false + + + + Level3 + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + stdcpplatest + + + Console + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + Level3 + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + + \ No newline at end of file