kuhyx/testsAndMisc
1
0
Fork 0
mirror of https://github.com/kuhyx/testsAndMisc.git synced 2026-07-04 13:03:13 +02:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

feat: great beautiful fixes

Browse Source
This commit is contained in:
Krzysztof Rudnicki 2026-02-20 00:37:32 +01:00
parent 9e4fee54d7
commit 96eb511c83
32 changed files with 3138 additions and 1576 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
.pre-commit-config.yaml
View File

@ -1,5 +1,5 @@
# ==============================================================================
# Pre-commit Configuration - AGGRESSIVE Python Linting & Formatting
# Pre-commit Configuration - Multi-language Linting & Formatting
# ==============================================================================
# Install: pre-commit install
# Run all: pre-commit run --all-files
@ -262,6 +262,62 @@ repos:
- id: shellcheck
args: [--severity=warning]
# ===========================================================================
# CLANG-FORMAT - C/C++ code formatting
# ===========================================================================
- repo: https://github.com/pre-commit/mirrors-clang-format
rev: v19.1.6
hooks:
- id: clang-format
types_or: [c, c++]
# ===========================================================================
# CPPCHECK - C/C++ static analysis
# ===========================================================================
- repo: local
hooks:
- id: cppcheck
name: cppcheck
entry: cppcheck
language: system
types_or: [c, c++]
args:
- --enable=warning,style,performance,portability
- --inconclusive
- --force
- --quiet
- --error-exitcode=1
- --inline-suppr
- --suppress=missingIncludeSystem
- --std=c11
# ===========================================================================
# FLAWFINDER - C/C++ security scanner
# ===========================================================================
- repo: local
hooks:
- id: flawfinder
name: flawfinder
entry: flawfinder
language: system
types_or: [c, c++]
args:
- --error-level=4
- --quiet
- --columns
# ===========================================================================
# ESLINT - TypeScript/JavaScript linting
# ===========================================================================
- repo: local
hooks:
- id: eslint
name: eslint
entry: npx eslint --no-warn-ignored
language: system
types_or: [ts, tsx]
files: ^TS/
# ===========================================================================
# REMOVE EMPTY DIRECTORIES - Clean up empty folders in the repo
# ===========================================================================

350
C/vocabulary_curve/main.c
View File

@ -9,81 +9,90 @@
* ./vocabulary_curve test.txt 50
*/
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>
#define MAX_WORD_LEN 64
#define MAX_WORDS 500000
#define MAX_UNIQUE_WORDS 100000
#define HASH_SIZE 200003 /* Prime number for better distribution */
#define HASH_SIZE 200003 /* Prime number for better distribution */
/* Word entry for hash table */
typedef struct WordEntry {
char word[MAX_WORD_LEN];
int count;
int rank; /* 1-indexed rank by frequency (1 = most common) */
typedef struct WordEntry
{
char word[MAX_WORD_LEN];
int count;
int rank; /* 1-indexed rank by frequency (1 = most common) */
struct WordEntry *next;
} WordEntry;
/* Hash table for word lookup */
static WordEntry *hash_table[HASH_SIZE];
static WordEntry *all_entries[MAX_UNIQUE_WORDS];
static int num_unique_words = 0;
static int num_unique_words = 0;
/* All words in order of appearance - store POINTERS not indices */
static WordEntry *word_sequence[MAX_WORDS];
static int num_words = 0;
static int num_words = 0;
/* Result for each excerpt length */
typedef struct {
typedef struct
{
int excerpt_length;
int min_vocab_needed;
int start_pos; /* Start position in word_sequence */
int start_pos; /* Start position in word_sequence */
} ExcerptResult;
/* Simple hash function */
static unsigned int hash_word(const char *word) {
static unsigned int hash_word(const char *word)
{
unsigned int hash = 5381;
int c;
while ((c = *word++)) {
int c;
while ((c = *word++))
{
hash = ((hash << 5) + hash) + c;
}
return hash % HASH_SIZE;
}
/* Find or create word entry */
static WordEntry *get_or_create_word(const char *word) {
unsigned int h = hash_word(word);
WordEntry *entry = hash_table[h];
static WordEntry *get_or_create_word(const char *word)
{
unsigned int h = hash_word(word);
WordEntry *entry = hash_table[h];
while (entry) {
if (strcmp(entry->word, word) == 0) {
while (entry)
{
if (strcmp(entry->word, word) == 0)
{
return entry;
}
entry = entry->next;
}
/* Create new entry */
if (num_unique_words >= MAX_UNIQUE_WORDS) {
if (num_unique_words >= MAX_UNIQUE_WORDS)
{
fprintf(stderr, "Too many unique words\n");
exit(1);
}
entry = malloc(sizeof(WordEntry));
if (!entry) {
if (!entry)
{
fprintf(stderr, "Memory allocation failed\n");
exit(1);
}
strncpy(entry->word, word, MAX_WORD_LEN - 1);
entry->word[MAX_WORD_LEN - 1] = '\0';
entry->count = 0;
entry->rank = 0;
entry->next = hash_table[h];
hash_table[h] = entry;
entry->count = 0;
entry->rank = 0;
entry->next = hash_table[h];
hash_table[h] = entry;
all_entries[num_unique_words++] = entry;
@ -91,41 +100,48 @@ static WordEntry *get_or_create_word(const char *word) {
}
/* Compare function for sorting by frequency (descending) */
static int compare_by_count(const void *a, const void *b) {
static int compare_by_count(const void *a, const void *b)
{
const WordEntry *wa = *(const WordEntry **)a;
const WordEntry *wb = *(const WordEntry **)b;
return wb->count - wa->count; /* Descending */
return wb->count - wa->count; /* Descending */
}
/* Check if character is part of a word */
static bool is_word_char(int c) {
return isalnum(c) || c == '_' || (unsigned char)c >= 128;
}
static bool is_word_char(int c) { return isalnum(c) || c == '_' || (unsigned char)c >= 128; }
/* Read and process file */
static bool process_file(const char *filename) {
static bool process_file(const char *filename)
{
FILE *fp = fopen(filename, "r");
if (!fp) {
if (!fp)
{
fprintf(stderr, "Cannot open file: %s\n", filename);
return false;
}
char word[MAX_WORD_LEN];
int word_len = 0;
int c;
int word_len = 0;
int c;
while ((c = fgetc(fp)) != EOF) {
if (is_word_char(c)) {
if (word_len < MAX_WORD_LEN - 1) {
while ((c = fgetc(fp)) != EOF)
{
if (is_word_char(c))
{
if (word_len < MAX_WORD_LEN - 1)
{
word[word_len++] = tolower(c);
}
} else if (word_len > 0) {
}
else if (word_len > 0)
{
word[word_len] = '\0';
WordEntry *entry = get_or_create_word(word);
entry->count++;
if (num_words >= MAX_WORDS) {
if (num_words >= MAX_WORDS)
{
fprintf(stderr, "Too many words in file\n");
fclose(fp);
return false;
@ -139,12 +155,14 @@ static bool process_file(const char *filename) {
}
/* Handle last word if file doesn't end with whitespace */
if (word_len > 0) {
word[word_len] = '\0';
if (word_len > 0)
{
word[word_len] = '\0';
WordEntry *entry = get_or_create_word(word);
entry->count++;
if (num_words < MAX_WORDS) {
if (num_words < MAX_WORDS)
{
word_sequence[num_words++] = entry;
}
}
@ -154,7 +172,8 @@ static bool process_file(const char *filename) {
}
/* Assign ranks based on frequency */
static void assign_ranks(void) {
static void assign_ranks(void)
{
/* Sort all_entries by frequency (this doesn't affect word_sequence) */
qsort(all_entries, num_unique_words, sizeof(WordEntry *), compare_by_count);
@ -162,13 +181,19 @@ static void assign_ranks(void) {
* Words with same frequency get same rank.
* Next rank is current_position + 1 (skipping numbers).
* Example: counts 5,3,3,2 -> ranks 1,2,2,4 (not 1,2,3,4) */
for (int i = 0; i < num_unique_words; i++) {
if (i == 0) {
for (int i = 0; i < num_unique_words; i++)
{
if (i == 0)
{
all_entries[i]->rank = 1;
} else if (all_entries[i]->count == all_entries[i-1]->count) {
}
else if (all_entries[i]->count == all_entries[i - 1]->count)
{
/* Same frequency as previous word - same rank */
all_entries[i]->rank = all_entries[i-1]->rank;
} else {
all_entries[i]->rank = all_entries[i - 1]->rank;
}
else
{
/* Different frequency - rank is position + 1 */
all_entries[i]->rank = i + 1;
}
@ -176,7 +201,8 @@ static void assign_ranks(void) {
}
/* Analyze excerpt and return max rank needed */
static int analyze_excerpt(int start, int length) {
static int analyze_excerpt(int start, int length)
{
/* Track which entries we've seen using a simple visited array */
/* We use the rank field is already assigned, so we can check uniqueness */
static bool seen_rank[MAX_UNIQUE_WORDS + 1];
@ -184,13 +210,16 @@ static int analyze_excerpt(int start, int length) {
int max_rank = 0;
for (int i = start; i < start + length; i++) {
for (int i = start; i < start + length; i++)
{
WordEntry *entry = word_sequence[i];
int rank = entry->rank;
int rank = entry->rank;
if (!seen_rank[rank]) {
if (!seen_rank[rank])
{
seen_rank[rank] = true;
if (rank > max_rank) {
if (rank > max_rank)
{
max_rank = rank;
}
}
@ -200,56 +229,69 @@ static int analyze_excerpt(int start, int length) {
}
/* Find optimal excerpts for each length */
static void find_optimal_excerpts(int max_length, ExcerptResult *results) {
for (int length = 1; length <= max_length && length <= num_words; length++) {
static void find_optimal_excerpts(int max_length, ExcerptResult *results)
{
for (int length = 1; length <= max_length && length <= num_words; length++)
{
int best_vocab = num_unique_words + 1;
int best_start = 0;
/* Slide window through text */
for (int start = 0; start <= num_words - length; start++) {
for (int start = 0; start <= num_words - length; start++)
{
int vocab_needed = analyze_excerpt(start, length);
if (vocab_needed < best_vocab) {
if (vocab_needed < best_vocab)
{
best_vocab = vocab_needed;
best_start = start;
}
}
results[length - 1].excerpt_length = length;
results[length - 1].excerpt_length = length;
results[length - 1].min_vocab_needed = best_vocab;
results[length - 1].start_pos = best_start;
results[length - 1].start_pos = best_start;
}
}
/* Print excerpt words */
static void print_excerpt(int start, int length) {
for (int i = start; i < start + length; i++) {
if (i > start) printf(" ");
static void print_excerpt(int start, int length)
{
for (int i = start; i < start + length; i++)
{
if (i > start)
printf(" ");
printf("%s", word_sequence[i]->word);
}
}
/* Print words needed (sorted by rank) */
static void print_words_needed(int start, int length) {
static void print_words_needed(int start, int length)
{
/* Collect unique entries */
static WordEntry *unique_entries[MAX_UNIQUE_WORDS];
static bool seen_rank[MAX_UNIQUE_WORDS + 1];
static bool seen_rank[MAX_UNIQUE_WORDS + 1];
memset(seen_rank, 0, (num_unique_words + 1) * sizeof(bool));
int count = 0;
for (int i = start; i < start + length; i++) {
for (int i = start; i < start + length; i++)
{
WordEntry *entry = word_sequence[i];
if (!seen_rank[entry->rank]) {
seen_rank[entry->rank] = true;
if (!seen_rank[entry->rank])
{
seen_rank[entry->rank] = true;
unique_entries[count++] = entry;
}
}
/* Sort by rank (simple bubble sort - small arrays) */
for (int i = 0; i < count - 1; i++) {
for (int j = i + 1; j < count; j++) {
if (unique_entries[i]->rank > unique_entries[j]->rank) {
WordEntry *tmp = unique_entries[i];
for (int i = 0; i < count - 1; i++)
{
for (int j = i + 1; j < count; j++)
{
if (unique_entries[i]->rank > unique_entries[j]->rank)
{
WordEntry *tmp = unique_entries[i];
unique_entries[i] = unique_entries[j];
unique_entries[j] = tmp;
}
@ -257,14 +299,17 @@ static void print_words_needed(int start, int length) {
}
/* Print */
for (int i = 0; i < count; i++) {
if (i > 0) printf(", ");
for (int i = 0; i < count; i++)
{
if (i > 0)
printf(", ");
printf("%s(#%d)", unique_entries[i]->word, unique_entries[i]->rank);
}
}
/* Print results */
static void print_results(ExcerptResult *results, int max_length) {
static void print_results(ExcerptResult *results, int max_length)
{
printf("======================================================================\n");
printf("VOCABULARY LEARNING CURVE\n");
printf("======================================================================\n");
@ -279,13 +324,16 @@ static void print_results(ExcerptResult *results, int max_length) {
int prev_vocab = 0;
int actual_max = max_length;
if (actual_max > num_words) actual_max = num_words;
if (actual_max > num_words)
actual_max = num_words;
for (int i = 0; i < actual_max; i++) {
for (int i = 0; i < actual_max; i++)
{
ExcerptResult *r = &results[i];
printf("\n[Length %d] Vocab needed: %d", r->excerpt_length, r->min_vocab_needed);
if (r->min_vocab_needed > prev_vocab) {
if (r->min_vocab_needed > prev_vocab)
{
printf(" (+%d)", r->min_vocab_needed - prev_vocab);
}
printf("\n");
@ -303,7 +351,8 @@ static void print_results(ExcerptResult *results, int max_length) {
printf("\n----------------------------------------------------------------------\n");
if (actual_max > 0) {
if (actual_max > 0)
{
ExcerptResult *final = &results[actual_max - 1];
printf("\nTo understand a %d-word excerpt,\n", final->excerpt_length);
printf("you need to learn at minimum %d top words.\n", final->min_vocab_needed);
@ -311,17 +360,22 @@ static void print_results(ExcerptResult *results, int max_length) {
}
/* Free memory */
static void cleanup(void) {
for (int i = 0; i < num_unique_words; i++) {
static void cleanup(void)
{
for (int i = 0; i < num_unique_words; i++)
{
free(all_entries[i]);
}
}
/* Dump all vocabulary with ranks (for Python integration) */
static void dump_vocabulary(int max_rank) {
static void dump_vocabulary(int max_rank)
{
printf("VOCAB_DUMP_START\n");
for (int i = 0; i < num_unique_words; i++) {
if (all_entries[i]->rank <= max_rank) {
for (int i = 0; i < num_unique_words; i++)
{
if (all_entries[i]->rank <= max_rank)
{
printf("%s;%d\n", all_entries[i]->word, all_entries[i]->rank);
}
}
@ -329,22 +383,28 @@ static void dump_vocabulary(int max_rank) {
}
/* Find longest excerpt using only top N words (inverse mode) */
static void find_longest_excerpt(int max_vocab) {
static void find_longest_excerpt(int max_vocab)
{
/* Sliding window: find longest contiguous sequence where all words have rank <= max_vocab */
int best_start = 0;
int best_start = 0;
int best_length = 0;
int left = 0;
for (int right = 0; right < num_words; right++) {
for (int right = 0; right < num_words; right++)
{
/* If current word is outside our vocabulary, move left past it */
if (word_sequence[right]->rank > max_vocab) {
if (word_sequence[right]->rank > max_vocab)
{
left = right + 1;
} else {
}
else
{
/* Current window [left, right] is valid */
int length = right - left + 1;
if (length > best_length) {
if (length > best_length)
{
best_length = length;
best_start = left;
best_start = left;
}
}
}
@ -361,10 +421,13 @@ static void find_longest_excerpt(int max_vocab) {
printf("----------------------------------------------------------------------\n");
printf("\n");
if (best_length == 0) {
if (best_length == 0)
{
printf("No valid excerpt found with top %d words.\n", max_vocab);
printf("The text may require rarer words from the very beginning.\n");
} else {
}
else
{
printf("LONGEST EXCERPT: %d words\n", best_length);
printf("Position: words %d to %d\n", best_start + 1, best_start + best_length);
printf("\n");
@ -374,12 +437,14 @@ static void find_longest_excerpt(int max_vocab) {
printf("\n");
/* Find the rarest word in the excerpt */
int max_rank_used = 0;
const char *rarest_word = NULL;
for (int i = best_start; i < best_start + best_length; i++) {
if (word_sequence[i]->rank > max_rank_used) {
int max_rank_used = 0;
const char *rarest_word = NULL;
for (int i = best_start; i < best_start + best_length; i++)
{
if (word_sequence[i]->rank > max_rank_used)
{
max_rank_used = word_sequence[i]->rank;
rarest_word = word_sequence[i]->word;
rarest_word = word_sequence[i]->word;
}
}
printf("Rarest word used: %s (#%d)\n", rarest_word, max_rank_used);
@ -388,8 +453,10 @@ static void find_longest_excerpt(int max_vocab) {
static bool seen_rank[MAX_UNIQUE_WORDS + 1];
memset(seen_rank, 0, (num_unique_words + 1) * sizeof(bool));
int unique_count = 0;
for (int i = best_start; i < best_start + best_length; i++) {
if (!seen_rank[word_sequence[i]->rank]) {
for (int i = best_start; i < best_start + best_length; i++)
{
if (!seen_rank[word_sequence[i]->rank])
{
seen_rank[word_sequence[i]->rank] = true;
unique_count++;
}
@ -400,49 +467,67 @@ static void find_longest_excerpt(int max_vocab) {
printf("\n----------------------------------------------------------------------\n");
}
int main(int argc, char *argv[]) {
if (argc < 2) {
int main(int argc, char *argv[])
{
if (argc < 2)
{
fprintf(stderr, "Usage: %s <file.txt> [options]\n", argv[0]);
fprintf(stderr, "\nModes:\n");
fprintf(stderr, " (default) Find minimum vocab needed for each excerpt length\n");
fprintf(stderr, " --max-vocab N INVERSE: Find longest excerpt using only top N words\n");
fprintf(stderr,
" --max-vocab N INVERSE: Find longest excerpt using only top N words\n");
fprintf(stderr, "\nOptions:\n");
fprintf(stderr, " max_length Maximum excerpt length to analyze (default: 30)\n");
fprintf(stderr, " --dump-vocab [N] Output all words with ranks up to N\n");
fprintf(stderr, "\nExamples:\n");
fprintf(stderr, " %s book.txt 50 # Analyze excerpts up to 50 words\n", argv[0]);
fprintf(stderr, " %s book.txt --max-vocab 500 # Find longest excerpt with top 500 words\n", argv[0]);
fprintf(stderr, " %s book.txt 50 # Analyze excerpts up to 50 words\n",
argv[0]);
fprintf(stderr, " %s book.txt --max-vocab 500 # Find longest excerpt with top 500 words\n",
argv[0]);
return 1;
}
const char *filename = argv[1];
int max_length = 30;
bool dump_vocab = false;
int dump_max_rank = 0;
int max_vocab_mode = 0; /* 0 = normal mode, >0 = inverse mode with this vocab limit */
const char *filename = argv[1];
int max_length = 30;
bool dump_vocab = false;
int dump_max_rank = 0;
int max_vocab_mode = 0; /* 0 = normal mode, >0 = inverse mode with this vocab limit */
/* Parse arguments */
for (int i = 2; i < argc; i++) {
if (strcmp(argv[i], "--dump-vocab") == 0) {
for (int i = 2; i < argc; i++)
{
if (strcmp(argv[i], "--dump-vocab") == 0)
{
dump_vocab = true;
if (i + 1 < argc && argv[i + 1][0] != '-') {
if (i + 1 < argc && argv[i + 1][0] != '-')
{
dump_max_rank = atoi(argv[++i]);
}
} else if (strcmp(argv[i], "--max-vocab") == 0) {
if (i + 1 < argc) {
}
else if (strcmp(argv[i], "--max-vocab") == 0)
{
if (i + 1 < argc)
{
max_vocab_mode = atoi(argv[++i]);
if (max_vocab_mode < 1) {
if (max_vocab_mode < 1)
{
fprintf(stderr, "Error: --max-vocab requires a positive number\n");
return 1;
}
} else {
}
else
{
fprintf(stderr, "Error: --max-vocab requires a number\n");
return 1;
}
} else if (argv[i][0] != '-') {
}
else if (argv[i][0] != '-')
{
max_length = atoi(argv[i]);
if (max_length < 1) max_length = 1;
if (max_length > 1000) max_length = 1000;
if (max_length < 1)
max_length = 1;
if (max_length > 1000)
max_length = 1000;
}
}
@ -450,11 +535,13 @@ int main(int argc, char *argv[]) {
memset(hash_table, 0, sizeof(hash_table));
/* Process file */
if (!process_file(filename)) {
if (!process_file(filename))
{
return 1;
}
if (num_words == 0) {
if (num_words == 0)
{
fprintf(stderr, "No words found in file\n");
return 1;
}
@ -463,12 +550,15 @@ int main(int argc, char *argv[]) {
assign_ranks();
/* Inverse mode: find longest excerpt with limited vocabulary */
if (max_vocab_mode > 0) {
if (max_vocab_mode > 0)
{
find_longest_excerpt(max_vocab_mode);
/* Dump vocabulary if requested */
if (dump_vocab) {
if (dump_max_rank == 0) dump_max_rank = max_vocab_mode;
if (dump_vocab)
{
if (dump_max_rank == 0)
dump_max_rank = max_vocab_mode;
dump_vocabulary(dump_max_rank);
}
@ -478,7 +568,8 @@ int main(int argc, char *argv[]) {
/* Normal mode: find optimal excerpts */
ExcerptResult *results = malloc(max_length * sizeof(ExcerptResult));
if (!results) {
if (!results)
{
fprintf(stderr, "Memory allocation failed\n");
cleanup();
return 1;
@ -490,12 +581,15 @@ int main(int argc, char *argv[]) {
print_results(results, max_length);
/* Dump vocabulary if requested */
if (dump_vocab) {
if (dump_vocab)
{
/* If no max_rank specified, use the max from the excerpt */
if (dump_max_rank == 0 && max_length > 0) {
if (dump_max_rank == 0 && max_length > 0)
{
dump_max_rank = results[max_length - 1].min_vocab_needed;
}
if (dump_max_rank > 0) {
if (dump_max_rank > 0)
{
dump_vocabulary(dump_max_rank);
}
}

35
CPP/miscelanious/Pi/main.cpp
View File

@ -1,25 +1,24 @@
#include <math.h>
#include <iostream>
#include <iomanip>
#include <iostream>
#include <math.h>
const unsigned long long int ITERATIONS = 10000;
long double getPi()
{
long double pi = 4;
bool negative = 1;
for(unsigned int i = 3; i < ITERATIONS; i += 2)
{
if(negative) pi -= 4.0 / i;
else pi += 4.0 / i;
negative = !negative;
}
std::cout << std::setprecision(2000) << pi << std::endl;
return pi;
long double getPi() {
long double pi = 4;
bool negative = 1;
for (unsigned int i = 3; i < ITERATIONS; i += 2) {
if (negative)
pi -= 4.0 / i;
else
pi += 4.0 / i;
negative = !negative;
}
std::cout << std::setprecision(2000) << pi << std::endl;
return pi;
}
int main()
{
getPi();
return 0;
int main() {
getPi();
return 0;
}

717
CPP/miscelanious/brydz/brydz.cpp
View File

@ -1,11 +1,12 @@
#include <iostream>
#include <vector>
const std::vector <std::string> ATUTY = {"BA", "Trefl", "Karo", "Kier", "Pik"};
const std::vector<std::string> ATUTY = {"BA", "Trefl", "Karo", "Kier", "Pik"};
const bool A_ID = 0;
const bool B_ID = 1;
const std::vector <std::string> GRACZE = {};
const std::vector <std::string> PO_PARTII {"Nikt", GRACZE[A_ID], GRACZE[B_ID], "Obaj Gracze"};
const std::vector<std::string> GRACZE = {};
const std::vector<std::string> PO_PARTII{"Nikt", GRACZE[A_ID], GRACZE[B_ID],
"Obaj Gracze"};
const int DOMYSLNE_LEWY = 6;
const int BEZ_ATUTU_ID = 1;
const int TREFL_ID = 2;
@ -19,392 +20,372 @@ const int MAKSYMALNY_LEW = 7;
const int MINIMALNY_LEW = 1;
const int ILOSC_LEW = 13;
void print(const std::string s)
{
std::cout << s << std::endl;
void print(const std::string s) { std::cout << s << std::endl; }
void tabela(std::vector<int> punktyA, std::vector<int> punktyB) {
std::cout << "Numer Gry" << " Po Partii" << " " << GRACZE[A_ID]
<< " " << GRACZE[B_ID] << std::endl;
for (int i = 0; i < punktyA.size(); i++) {
std::cout << i + 1 << " " << PO_PARTII[i % CYKL_PO_PARTII]
<< " " << punktyA[i] << " "
<< punktyB[i] << std::endl;
}
}
void tabela(std::vector <int> punktyA, std::vector <int> punktyB)
{
std::cout << "Numer Gry" << " Po Partii" << " " << GRACZE[A_ID] << " " << GRACZE[B_ID] << std::endl;
for(int i = 0; i < punktyA.size(); i++)
{
std::cout << i + 1 << " " << PO_PARTII[i % CYKL_PO_PARTII] << " " << punktyA[i] << " " << punktyB[i] << std::endl;
}
void lwyAtut(int lwy, int atut) {
if (lwy == SZLEMIK) {
print("Wybrano szlemik!");
return;
}
if (lwy == SZLEM) {
print("Wybrano szlema!");
return;
}
std::cout << "Wybrano kontrakt: " << lwy << " " << ATUTY[atut - 1]
<< std::endl;
}
void lwyAtut(int lwy, int atut)
{
if(lwy == SZLEMIK)
{
print("Wybrano szlemik!");
return;
}
if(lwy == SZLEM)
{
print("Wybrano szlema!");
return;
}
std::cout << "Wybrano kontrakt: " << lwy << " " << ATUTY[atut - 1] << std::endl;
int zagraneLwy() {
int lwy;
bool flagaLwy;
do {
flagaLwy = 0;
print("Ile lew?");
char lwyC;
std::cin >> lwyC;
lwy = lwyC - '0';
if (lwy < MINIMALNY_LEW) {
print("Podales za malo lew!");
flagaLwy = 1;
}
if (lwy > MAKSYMALNY_LEW) {
print("Podales za duzo lew!");
flagaLwy = 1;
}
} while (flagaLwy);
return lwy;
}
int zagraneLwy()
{
int lwy;
bool flagaLwy;
do
{
flagaLwy = 0;
print("Ile lew?");
char lwyC;
std::cin >> lwyC;
lwy = lwyC - '0';
if(lwy < MINIMALNY_LEW)
{
print("Podales za malo lew!");
flagaLwy = 1;
}
if(lwy > MAKSYMALNY_LEW)
{
print("Podales za duzo lew!");
flagaLwy = 1;
}
}while(flagaLwy);
return lwy;
int zagranyAtut(int lwy) {
int atut;
bool flagaAtut;
if (lwy > 6)
return 1;
do {
flagaAtut = 0;
print("Jaki atut?");
print("1 - BA");
print("2 - Trefl");
print("3 - Karo");
print("4 - Kier");
print("5 - Pik");
char atutC;
std::cin >> atutC;
atut = atutC - '0';
if (atut < 1 || atut > 5) {
print("Wybrales zla liczbe!");
flagaAtut = 1;
}
} while (flagaAtut);
return atut;
}
int zagranyAtut(int lwy)
{
int atut;
bool flagaAtut;
if(lwy > 6) return 1;
do
{
flagaAtut = 0;
print("Jaki atut?");
print("1 - BA");
print("2 - Trefl");
print("3 - Karo");
print("4 - Kier");
print("5 - Pik");
char atutC;
std::cin >> atutC;
atut = atutC - '0';
if(atut < 1 || atut > 5)
{
print("Wybrales zla liczbe!");
flagaAtut = 1;
}
}while(flagaAtut);
return atut;
bool zagranaKontra() {
char kontraC = '0';
print("Czy zostala zagrana kontra?");
print("1 - TAK");
print("0 - NIE");
std::cin >> kontraC;
bool kontraBool = kontraC - '0';
return kontraBool;
}
bool zagranaKontra()
{
char kontraC = '0';
print("Czy zostala zagrana kontra?");
print("1 - TAK");
print("0 - NIE");
std::cin >> kontraC;
bool kontraBool = kontraC - '0';
return kontraBool;
bool zagranaRekontra() {
char rekontraC = '0';
print("Czy zostala zagrana rekontra?");
print("1 - TAK");
print("0 - NIE");
std::cin >> rekontraC;
bool rekontraBool = rekontraC - '0';
return rekontraBool;
}
bool zagranaRekontra()
{
char rekontraC = '0';
print("Czy zostala zagrana rekontra?");
print("1 - TAK");
print("0 - NIE");
std::cin >> rekontraC;
bool rekontraBool = rekontraC - '0';
return rekontraBool;
void stanGry(int lwy, int atut, bool kontraBool, bool rekontraBool,
int ktoraGra, int ktoKontrakt) {
std::cout << "Kontrakt Wygrali: " << GRACZE[ktoKontrakt] << std::endl;
lwyAtut(lwy, atut);
if (kontraBool) {
if (rekontraBool)
print("Zostala zagrana REkontra!");
else
print("Zostala zagrana Kontra!");
}
std::cout << "Po partii sa: " << PO_PARTII[ktoraGra % 4] << std::endl;
}
void stanGry(int lwy, int atut, bool kontraBool, bool rekontraBool, int ktoraGra, int ktoKontrakt)
{
std::cout << "Kontrakt Wygrali: " << GRACZE[ktoKontrakt] << std::endl;
lwyAtut(lwy, atut);
if(kontraBool)
{
if(rekontraBool) print("Zostala zagrana REkontra!");
else print("Zostala zagrana Kontra!");
}
std::cout << "Po partii sa: " << PO_PARTII[ktoraGra % 4] << std::endl;
int ktoKontrakt() {
char ktoKontraktC;
print("Kto wygral Kontrakt?");
std::cout << "1. " << GRACZE[A_ID] << std::endl;
std::cout << "2. " << GRACZE[B_ID] << std::endl;
std::cin >> ktoKontraktC;
int ktoKontraktI = ktoKontraktC - '1';
std::cout << "ktoKontraktI " << ktoKontraktI;
return ktoKontraktI;
}
int ktoKontrakt()
{
char ktoKontraktC;
print("Kto wygral Kontrakt?");
std::cout << "1. " << GRACZE[A_ID] << std::endl;
std::cout << "2. " << GRACZE[B_ID] << std::endl;
std::cin >> ktoKontraktC;
int ktoKontraktI = ktoKontraktC - '1';
std::cout << "ktoKontraktI " << ktoKontraktI;
return ktoKontraktI;
int ileWpadek() {
std::string ileWpadekS;
print("ile lew wygrali obroncy?");
std::cin >> ileWpadekS;
int ileWpadek = stoi(ileWpadekS);
return ileWpadek;
}
int ileWpadek()
{
std::string ileWpadekS;
print("ile lew wygrali obroncy?");
std::cin >> ileWpadekS;
int ileWpadek = stoi(ileWpadekS);
return ileWpadek;
void punkty(std::vector<int> &punktyA, std::vector<int> &punktyB, int lwy,
int atut, bool kontraBool, bool rekontraBool, int ktoraGra,
int ktoKontraktI, bool rozgrywajacyWygral, int wpadki) {
int sumaPunktow = 0;
if (rozgrywajacyWygral) {
int zdobyteLewy = ILOSC_LEW - wpadki - DOMYSLNE_LEWY;
int nadrobki = zdobyteLewy - lwy;
int punktyZaLew;
std::cout << "wartosc kontraBool: " << kontraBool
<< "; wartosc rekontraBool: " << rekontraBool << std::endl;
// Lewy Deklarowane
if (atut == TREFL_ID || atut == KARO_ID) {
print("kontrakt TREFL lub KARO kazda karta kontraktowa za 20");
punktyZaLew = 20;
if (kontraBool) {
print("kontra TREFL lub KARO, kazda karta kontraktowa za 40");
punktyZaLew = 40;
}
if (rekontraBool) {
print("rekontra TREFL lub KARO, kazda karta kontraktowa za 80");
punktyZaLew = 80;
}
std::cout << "Ilosc lew w kontrakcie: " << lwy
<< " do punktow dodaje sie " << lwy * punktyZaLew << std::endl;
sumaPunktow += (lwy * punktyZaLew);
}
if (atut == KIER_ID || atut == PIK_ID) {
print("kontrakt KIER lub PIK, kazda kontraktowa 30");
punktyZaLew = 30;
if (kontraBool) {
print("kontra KIER lub PIK, kazda kontraktowa za 60");
punktyZaLew = 60;
}
if (rekontraBool) {
print("rekontra KIER lub PIK, kazda kontraktowa za 120");
punktyZaLew = 120;
}
std::cout << "Ilosc lew w kontrakcie: " << lwy
<< " do punktow dodaje sie " << lwy * punktyZaLew << std::endl;
sumaPunktow += (lwy * punktyZaLew);
}
if (atut == BEZ_ATUTU_ID) {
punktyZaLew = 30;
print("kontrakt BEZ_ATUTU, pierwsza lewa za 40, kazda nastepna za 30");
sumaPunktow = 40;
if (kontraBool) {
print("kontrakt BEZ_ATUTU, pierwsza lewa za 80, kazda nastepna za 60");
sumaPunktow = 80;
punktyZaLew = 60;
}
if (rekontraBool) {
print(
"kontrakt BEZ_ATUTU, pierwsza lewa za 160, kazda nastepna za 120");
sumaPunktow = 160;
punktyZaLew = 120;
}
sumaPunktow += ((lwy - 1) * punktyZaLew);
}
bool czyRozgrywajacyPoPartii =
(((ktoraGra % CYKL_PO_PARTII) - 1) == ktoKontraktI ||
ktoraGra % CYKL_PO_PARTII == 3);
if (lwy == SZLEMIK) {
if (czyRozgrywajacyPoPartii)
sumaPunktow += 750;
else
sumaPunktow += 500;
}
if (lwy == SZLEM) {
if (czyRozgrywajacyPoPartii)
sumaPunktow += 1500;
else
sumaPunktow += 1000;
}
bool dograna = (sumaPunktow >= 100);
if (dograna) {
if (czyRozgrywajacyPoPartii)
sumaPunktow += 500;
else
sumaPunktow += 300;
} else
sumaPunktow += 50;
// Nadrobki
if (!kontraBool && !rekontraBool) {
int punktyZaNadrobki = punktyZaLew;
sumaPunktow += nadrobki * punktyZaNadrobki;
}
if (kontraBool && !rekontraBool) {
int punktyZaNadrobki = 100;
if (czyRozgrywajacyPoPartii)
punktyZaNadrobki = 200;
sumaPunktow += nadrobki * punktyZaNadrobki;
}
if (kontraBool && rekontraBool) {
int punktyZaNadrobki = 200;
if (czyRozgrywajacyPoPartii)
punktyZaNadrobki = 400;
sumaPunktow += nadrobki * punktyZaNadrobki;
}
if (kontraBool && !rekontraBool)
sumaPunktow += 50;
if (kontraBool && rekontraBool)
sumaPunktow += 100;
std::cout << "Rozgrywajacy zdobyl: " << sumaPunktow << std::endl;
if (ktoKontraktI == A_ID) {
punktyA.push_back(sumaPunktow);
punktyB.push_back(0);
} else {
punktyB.push_back(sumaPunktow);
punktyA.push_back(0);
}
return;
} else {
int zebraneLewy = ILOSC_LEW - wpadki;
int lewyWpadkowe = (lwy + DOMYSLNE_LEWY) - zebraneLewy;
int sumaPunktow = 0;
bool broniacyPoPartii =
(((ktoraGra % CYKL_PO_PARTII) - 1) == !ktoKontraktI ||
ktoraGra % CYKL_PO_PARTII == 3);
if (broniacyPoPartii) {
if (!kontraBool && !rekontraBool) {
sumaPunktow = 100;
for (int i = 1; i < lewyWpadkowe; i++) {
if (i < 4)
sumaPunktow += 100;
else
sumaPunktow += 0;
}
}
if (kontraBool && !rekontraBool) {
sumaPunktow = 200;
for (int i = 1; i < lewyWpadkowe; i++) {
if (i < 4)
sumaPunktow += 300;
else
sumaPunktow += 0;
}
}
if (kontraBool && rekontraBool) {
sumaPunktow = 400;
for (int i = 1; i < lewyWpadkowe; i++) {
if (i < 4)
sumaPunktow += 600;
else
sumaPunktow += 0;
}
}
} else {
if (!kontraBool && !rekontraBool) {
sumaPunktow = 50;
for (int i = 1; i < lewyWpadkowe; i++) {
if (i < 4)
sumaPunktow += 50;
else
sumaPunktow += 0;
}
}
if (kontraBool && !rekontraBool) {
sumaPunktow = 100;
for (int i = 1; i < lewyWpadkowe; i++) {
if (i < 4)
sumaPunktow += 200;
else
sumaPunktow += 100;
}
}
if (kontraBool && rekontraBool) {
sumaPunktow = 200;
for (int i = 1; i < lewyWpadkowe; i++) {
if (i < 4)
sumaPunktow += 400;
else
sumaPunktow += 200;
}
}
}
std::cout << "Broniacy zdobyli: " << sumaPunktow << std::endl;
if (ktoKontraktI == A_ID) {
punktyB.push_back(sumaPunktow);
punktyA.push_back(0);
} else {
punktyA.push_back(sumaPunktow);
punktyB.push_back(0);
}
return;
}
}
void punkty(std::vector <int> &punktyA, std::vector <int> &punktyB, int lwy, int atut, bool kontraBool, bool rekontraBool,
int ktoraGra, int ktoKontraktI, bool rozgrywajacyWygral, int wpadki)
{
int sumaPunktow = 0;
if(rozgrywajacyWygral)
{
int zdobyteLewy = ILOSC_LEW - wpadki - DOMYSLNE_LEWY;
int nadrobki = zdobyteLewy - lwy;
int punktyZaLew;
std::cout << "wartosc kontraBool: " << kontraBool << "; wartosc rekontraBool: " << rekontraBool << std::endl;
bool gra() {
bool koniecGry = 0;
std::vector<int> punktyA;
std::vector<int> punktyB;
do {
int ktoraGra = 0;
tabela(punktyA, punktyB);
int ktoKontraktI = ktoKontrakt();
int lwy = zagraneLwy();
int atut = zagranyAtut(lwy);
bool kontraBool = zagranaKontra();
bool rekontraBool = 0;
if (kontraBool)
rekontraBool = zagranaRekontra();
stanGry(lwy, atut, kontraBool, rekontraBool, ktoraGra, ktoKontraktI);
int wpadki = ileWpadek();
int zebraneLewy = ILOSC_LEW - wpadki;
// Lewy Deklarowane
if(atut == TREFL_ID || atut == KARO_ID)
{
print("kontrakt TREFL lub KARO kazda karta kontraktowa za 20");
punktyZaLew = 20;
if(kontraBool)
{
print("kontra TREFL lub KARO, kazda karta kontraktowa za 40");
punktyZaLew = 40;
}
if(rekontraBool)
{
print("rekontra TREFL lub KARO, kazda karta kontraktowa za 80");
punktyZaLew = 80;
}
std::cout << "Ilosc lew w kontrakcie: " << lwy << " do punktow dodaje sie " << lwy * punktyZaLew << std::endl;
sumaPunktow += (lwy * punktyZaLew);
}
if(atut == KIER_ID || atut == PIK_ID)
{
print("kontrakt KIER lub PIK, kazda kontraktowa 30");
punktyZaLew = 30;
if(kontraBool)
{
print("kontra KIER lub PIK, kazda kontraktowa za 60");
punktyZaLew = 60;
}
if(rekontraBool)
{
print("rekontra KIER lub PIK, kazda kontraktowa za 120");
punktyZaLew = 120;
}
std::cout << "Ilosc lew w kontrakcie: " << lwy << " do punktow dodaje sie " << lwy * punktyZaLew << std::endl;
sumaPunktow += (lwy * punktyZaLew);
}
if(atut == BEZ_ATUTU_ID)
{
punktyZaLew = 30;
print("kontrakt BEZ_ATUTU, pierwsza lewa za 40, kazda nastepna za 30");
sumaPunktow = 40;
if(kontraBool)
{
print("kontrakt BEZ_ATUTU, pierwsza lewa za 80, kazda nastepna za 60");
sumaPunktow = 80;
punktyZaLew = 60;
}
if(rekontraBool)
{
print("kontrakt BEZ_ATUTU, pierwsza lewa za 160, kazda nastepna za 120");
sumaPunktow = 160;
punktyZaLew = 120;
}
sumaPunktow += ( (lwy - 1) * punktyZaLew);
}
bool czyRozgrywajacyPoPartii = ( ( (ktoraGra % CYKL_PO_PARTII) - 1) == ktoKontraktI || ktoraGra % CYKL_PO_PARTII == 3);
if(lwy == SZLEMIK)
{
if(czyRozgrywajacyPoPartii) sumaPunktow += 750;
else sumaPunktow += 500;
}
if(lwy == SZLEM)
{
if(czyRozgrywajacyPoPartii) sumaPunktow += 1500;
else sumaPunktow += 1000;
}
bool dograna = (sumaPunktow >= 100);
if(dograna)
{
if(czyRozgrywajacyPoPartii) sumaPunktow += 500;
else sumaPunktow += 300;
}else sumaPunktow += 50;
// Nadrobki
if(!kontraBool && !rekontraBool)
{
int punktyZaNadrobki = punktyZaLew;
sumaPunktow += nadrobki * punktyZaNadrobki;
}
if(kontraBool && !rekontraBool)
{
int punktyZaNadrobki = 100;
if(czyRozgrywajacyPoPartii) punktyZaNadrobki = 200;
sumaPunktow += nadrobki * punktyZaNadrobki;
}
if(kontraBool && rekontraBool)
{
int punktyZaNadrobki = 200;
if(czyRozgrywajacyPoPartii) punktyZaNadrobki = 400;
sumaPunktow += nadrobki * punktyZaNadrobki;
}
if(kontraBool && !rekontraBool) sumaPunktow += 50;
if(kontraBool && rekontraBool) sumaPunktow += 100;
std::cout << "Rozgrywajacy zdobyl: " << sumaPunktow << std::endl;
if(ktoKontraktI == A_ID)
{
punktyA.push_back(sumaPunktow);
punktyB.push_back(0);
}
else
{
punktyB.push_back(sumaPunktow);
punktyA.push_back(0);
}
return;
}else
{
int zebraneLewy = ILOSC_LEW - wpadki;
int lewyWpadkowe = (lwy + DOMYSLNE_LEWY) - zebraneLewy;
int sumaPunktow = 0;
bool broniacyPoPartii = ( ((ktoraGra % CYKL_PO_PARTII) - 1) == !ktoKontraktI || ktoraGra % CYKL_PO_PARTII == 3);
if(broniacyPoPartii)
{
if(!kontraBool && !rekontraBool)
{
sumaPunktow = 100;
for(int i = 1; i < lewyWpadkowe; i++)
{
if(i < 4) sumaPunktow += 100;
else sumaPunktow += 0;
}
}
if(kontraBool && !rekontraBool)
{
sumaPunktow = 200;
for(int i = 1; i < lewyWpadkowe; i++)
{
if(i < 4) sumaPunktow += 300;
else sumaPunktow += 0;
}
}
if(kontraBool && rekontraBool)
{
sumaPunktow = 400;
for(int i = 1; i < lewyWpadkowe; i++)
{
if(i < 4) sumaPunktow += 600;
else sumaPunktow += 0;
}
}
}else
{
if(!kontraBool && !rekontraBool)
{
sumaPunktow = 50;
for(int i = 1; i < lewyWpadkowe; i++)
{
if(i < 4) sumaPunktow += 50;
else sumaPunktow += 0;
}
}
if(kontraBool && !rekontraBool)
{
sumaPunktow = 100;
for(int i = 1; i < lewyWpadkowe; i++)
{
if(i < 4) sumaPunktow += 200;
else sumaPunktow += 100;
}
}
if(kontraBool && rekontraBool)
{
sumaPunktow = 200;
for(int i = 1; i < lewyWpadkowe; i++)
{
if(i < 4) sumaPunktow += 400;
else sumaPunktow += 200;
}
}
}
std::cout << "Broniacy zdobyli: " << sumaPunktow << std::endl;
if(ktoKontraktI == A_ID)
{
punktyB.push_back(sumaPunktow);
punktyA.push_back(0);
}
else
{
punktyA.push_back(sumaPunktow);
punktyB.push_back(0);
}
return;
}
bool rozgrywajacyWygral = 1;
if (zebraneLewy >= lwy + DOMYSLNE_LEWY)
rozgrywajacyWygral = 1;
else
rozgrywajacyWygral = 0;
punkty(punktyA, punktyB, lwy, atut, kontraBool, rekontraBool, ktoraGra,
ktoKontraktI, rozgrywajacyWygral, wpadki);
print("Czy koniec gry? 1 - TAK, 0 - NIE");
std::cin >> koniecGry;
} while (!koniecGry);
tabela(punktyA, punktyB);
return 0;
}
bool gra()
{
bool koniecGry = 0;
std::vector <int> punktyA;
std::vector <int> punktyB;
do{
int ktoraGra = 0;
tabela(punktyA, punktyB);
int ktoKontraktI = ktoKontrakt();
int lwy = zagraneLwy();
int atut = zagranyAtut(lwy);
bool kontraBool = zagranaKontra();
bool rekontraBool = 0;
if(kontraBool) rekontraBool = zagranaRekontra();
stanGry(lwy, atut, kontraBool, rekontraBool, ktoraGra, ktoKontraktI);
int wpadki = ileWpadek();
int zebraneLewy = ILOSC_LEW - wpadki;
bool rozgrywajacyWygral = 1;
if( zebraneLewy >= lwy + DOMYSLNE_LEWY) rozgrywajacyWygral = 1;
else rozgrywajacyWygral = 0;
punkty(punktyA, punktyB, lwy, atut, kontraBool, rekontraBool, ktoraGra, ktoKontraktI, rozgrywajacyWygral, wpadki);
print("Czy koniec gry? 1 - TAK, 0 - NIE");
std::cin >> koniecGry;
}while(!koniecGry);
tabela(punktyA, punktyB);
return 0;
}
int main()
{
while(gra());
return 0;
int main() {
while (gra())
;
return 0;
}

105
CPP/miscelanious/calculateShotsDarts/basic.cpp
View File

@ -1,91 +1,72 @@
#ifndef BASIC_CPP
#define BASIC_CPP
#include <iostream>
#include <string>
#include <vector>
#include <iostream>
#include <windows.h>
void print(const std::string s) { std::cout << s << std::endl; }
void printErrorStringContainsNotNumber(const std::string s)
{
std::cout << "string: \"" << s
<< "\" contains character different than number " << std::endl;
void printErrorStringContainsNotNumber(const std::string s) {
std::cout << "string: \"" << s
<< "\" contains character different than number " << std::endl;
}
void printNumberTooLow(const int number, const int min)
{
std::cout << "number: " << number
<< " is too low. Minimal number is: " << min << std::endl;
void printNumberTooLow(const int number, const int min) {
std::cout << "number: " << number << " is too low. Minimal number is: " << min
<< std::endl;
}
void printNumberTooHigh(const int number, const int max)
{
std::cout << "number: " << number
<< " is too high. Maximal number is: " << max << std::endl;
void printNumberTooHigh(const int number, const int max) {
std::cout << "number: " << number
<< " is too high. Maximal number is: " << max << std::endl;
}
void printNotValidStringLength(const std::string s, const int desiredLength)
{
std::cout << "String: \"" << s << "\" is too short/too long, it is: "
<< s.length() << " characters long but should be: " << desiredLength
<< " characters long " << std::endl;
void printNotValidStringLength(const std::string s, const int desiredLength) {
std::cout << "String: \"" << s
<< "\" is too short/too long, it is: " << s.length()
<< " characters long but should be: " << desiredLength
<< " characters long " << std::endl;
}
void printInvalidCharacter(const char c, const char desiredCharacter)
{
std::cout << "[ " << c << " ] Is invalid character, expected: [ "
<< desiredCharacter << " ]" << std::endl;
void printInvalidCharacter(const char c, const char desiredCharacter) {
std::cout << "[ " << c << " ] Is invalid character, expected: [ "
<< desiredCharacter << " ]" << std::endl;
}
void printContainsIllegalCharacter( const std::string s,
const char illegalCharacter )
{
std::cout << "String: " << s << " consists of illegal sign: ["
<< illegalCharacter << "]!" << std::endl;
void printContainsIllegalCharacter(const std::string s,
const char illegalCharacter) {
std::cout << "String: " << s << " consists of illegal sign: ["
<< illegalCharacter << "]!" << std::endl;
}
bool numberTooLow(const int number, const int min)
{
if(number < min)
{
printNumberTooLow(number, min);
return 1;
}
return 0;
bool numberTooLow(const int number, const int min) {
if (number < min) {
printNumberTooLow(number, min);
return 1;
}
return 0;
}
bool numberTooHigh(const int number, const int max)
{
if(number > max)
{
printNumberTooHigh(number, max);
return 1;
}
return 0;
bool numberTooHigh(const int number, const int max) {
if (number > max) {
printNumberTooHigh(number, max);
return 1;
}
return 0;
}
bool containsIllegalCharacter(const std::string s, const char illegalCharacter)
{
if( s.find(illegalCharacter) != std::string::npos)
{
printContainsIllegalCharacter(s, illegalCharacter);
return 1;
}
return 0;
bool containsIllegalCharacter(const std::string s,
const char illegalCharacter) {
if (s.find(illegalCharacter) != std::string::npos) {
printContainsIllegalCharacter(s, illegalCharacter);
return 1;
}
return 0;
}
void e() { print("Poor man breakboint"); }
void e()
{
print("Poor man breakboint");
}
bool charIsNumber(const char c)
{
return c >= '0' && c <= '9';
}
bool charIsNumber(const char c) { return c >= '0' && c <= '9'; }
#endif

108
CPP/miscelanious/calculateShotsDarts/main.cpp
View File

@ -1,89 +1,79 @@
#ifndef MAIN_CPP
#define MAIN_CPP
#include "basic.cpp"
#include <iostream>
#include <string>
#include <vector>
#include "basic.cpp"
std::vector <int> fillVector(const int min, const int max)
{
std::vector <int> newVector;
for(int i = min; i <= max; i++)
{
newVector.push_back(i);
}
return newVector;
std::vector<int> fillVector(const int min, const int max) {
std::vector<int> newVector;
for (int i = min; i <= max; i++) {
newVector.push_back(i);
}
return newVector;
}
const int MAX_SPOT = 20;
const int MIN_SPOT = 1;
const std::vector <int> NORMAL_POINTS = fillVector(MIN_SPOT, MAX_SPOT);
const std::vector<int> NORMAL_POINTS = fillVector(MIN_SPOT, MAX_SPOT);
std::vector <int> multiplyVector(const std::vector <int> v, int multiplyBy)
{
std::vector <int> newVector;
for(unsigned int i = 0; i < v.size(); i++)
{
newVector.push_back(v.at(i)*multiplyBy);
}
return newVector;
std::vector<int> multiplyVector(const std::vector<int> v, int multiplyBy) {
std::vector<int> newVector;
for (unsigned int i = 0; i < v.size(); i++) {
newVector.push_back(v.at(i) * multiplyBy);
}
return newVector;
}
const std::vector <int> DOUBLE_POINTS = multiplyVector(NORMAL_POINTS, 2);
const std::vector <int> TRIPLE_POINTS = multiplyVector(NORMAL_POINTS, 3);
const std::vector<int> DOUBLE_POINTS = multiplyVector(NORMAL_POINTS, 2);
const std::vector<int> TRIPLE_POINTS = multiplyVector(NORMAL_POINTS, 3);
const int MAX_ONE_HIT = TRIPLE_POINTS.at(TRIPLE_POINTS.size() - 1);
const int THROWS_IN_ONE_HIT = 3;
const int MAX_POINTS_TURN = THROWS_IN_ONE_HIT * MAX_ONE_HIT;
const int STARTING_POINTS = 501;
const int FINAL_POINTS = 0;
bool validString(const std::string s)
{
for(unsigned int i = 0; i < s.length(); i++)
{
if(!charIsNumber(s.at(i)))
{
printErrorStringContainsNotNumber(s);
return 0;
}
}
return 1;
bool validString(const std::string s) {
for (unsigned int i = 0; i < s.length(); i++) {
if (!charIsNumber(s.at(i))) {
printErrorStringContainsNotNumber(s);
return 0;
}
}
return 1;
}
bool validNumberInput(const std::string input, const int min, const int max)
{
if(!validString(input)) return 0;
int inputInt = std::stoi(input);
if(numberTooLow(inputInt, min)) return 0;
if(numberTooHigh(inputInt, max)) return 0;
return 1;
bool validNumberInput(const std::string input, const int min, const int max) {
if (!validString(input))
return 0;
int inputInt = std::stoi(input);
if (numberTooLow(inputInt, min))
return 0;
if (numberTooHigh(inputInt, max))
return 0;
return 1;
}
bool validInput(const std::string s)
{
if(s.length() > 3) return 0;
if(!validNumberInput(s, FINAL_POINTS, STARTING_POINTS)) return 0;
return 1;
bool validInput(const std::string s) {
if (s.length() > 3)
return 0;
if (!validNumberInput(s, FINAL_POINTS, STARTING_POINTS))
return 0;
return 1;
}
std::vector <int> requiredShoots(const int pointsLeft)
{
std::vector<int> requiredShoots(const int pointsLeft) {}
}
int main()
{
print("Enter points left: ");
std::string pointsLeft;
do{
getline(std::cin, pointsLeft);
}while(!validInput(pointsLeft));
int pointsLeftInt = std::stoi(pointsLeft);
requiredShoots(pointsLeftInt);
return 0;
int main() {
print("Enter points left: ");
std::string pointsLeft;
do {
getline(std::cin, pointsLeft);
} while (!validInput(pointsLeft));
int pointsLeftInt = std::stoi(pointsLeft);
requiredShoots(pointsLeftInt);
return 0;
}
#endif

68
CPP/miscelanious/findIntegerPercentageValue/main.cpp
View File

@ -1,60 +1,50 @@
#include <iostream>
#include <cmath>
#include <iostream>
const int PERCENTAGE = 44;
const float PERCENTAGE_DENOMINATOR = 100;
const int NUMBERS_TO_CHECK = 200;
const bool DEBUG = 0;
bool isInteger(const float number)
{
return number == std::floor(number);
}
bool isInteger(const float number) { return number == std::floor(number); }
void printIsInteger(const int i, const int inputPercentage,
const float calculatedPercentage)
{
std::cout << i << "*" << inputPercentage << "% is an integer number: "
<< i*calculatedPercentage << std::endl;
const float calculatedPercentage) {
std::cout << i << "*" << inputPercentage
<< "% is an integer number: " << i * calculatedPercentage
<< std::endl;
}
void printDebug(const int i, const float calculatedPercentage)
{
std::cout << "i = " << i << std::endl;
std::cout << i*calculatedPercentage << std::endl;
void printDebug(const int i, const float calculatedPercentage) {
std::cout << "i = " << i << std::endl;
std::cout << i * calculatedPercentage << std::endl;
}
void isIntegerLoop( const bool debugOn = DEBUG,
const int maxNumber = NUMBERS_TO_CHECK,
const int inputPercentage = PERCENTAGE )
{
float actualPercentage = inputPercentage / PERCENTAGE_DENOMINATOR;
for(int i = 1; i <= maxNumber; i++)
{
if(isInteger(i*actualPercentage))
{
printIsInteger(i, inputPercentage, actualPercentage);
}
else if(debugOn) printDebug(i, actualPercentage);
}
void isIntegerLoop(const bool debugOn = DEBUG,
const int maxNumber = NUMBERS_TO_CHECK,
const int inputPercentage = PERCENTAGE) {
float actualPercentage = inputPercentage / PERCENTAGE_DENOMINATOR;
for (int i = 1; i <= maxNumber; i++) {
if (isInteger(i * actualPercentage)) {
printIsInteger(i, inputPercentage, actualPercentage);
} else if (debugOn)
printDebug(i, actualPercentage);
}
}
void printStartingMessage(const int maxNumber = NUMBERS_TO_CHECK,
const int inputPercentage = PERCENTAGE)
{
std::cout << "For max number = " << maxNumber
<< "; and a percentage: " << inputPercentage
<< "; Found following integer numbers: " << std::endl;
const int inputPercentage = PERCENTAGE) {
std::cout << "For max number = " << maxNumber
<< "; and a percentage: " << inputPercentage
<< "; Found following integer numbers: " << std::endl;
}
void mainFunctions()
{
printStartingMessage();
isIntegerLoop();
void mainFunctions() {
printStartingMessage();
isIntegerLoop();
}
int main()
{
mainFunctions();
return 0;
int main() {
mainFunctions();
return 0;
}

180
CPP/miscelanious/howManyValidISBNNumbersAreThere/11.cpp
View File

@ -1,133 +1,103 @@
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#ifndef CHECK_ISBN_CPP
#define CHECK_ISBN_CPP
const bool DEBUG = 0;
const int ISBN_LENGTH = 10;
const int CHECK_NUMBER = 11;
const unsigned long long int HIGHEST_ISBN = 9999999999;
void printVector(std::vector <int> v)
{
for(unsigned int i = 0; i < v.size(); i++)
{
std::cout << v[i] << "; ";
}
void printVector(std::vector<int> v) {
for (unsigned int i = 0; i < v.size(); i++) {
std::cout << v[i] << "; ";
}
}
void print(const std::string printMe)
{
std::cout << printMe << std::endl;
void print(const std::string printMe) { std::cout << printMe << std::endl; }
void e() { print("PRINT"); }
bool checkInput(const std::string input) {
if (input.length() != ISBN_LENGTH) {
print("Your number is too short/too long");
return 0;
}
for (int i = 0; i <= ISBN_LENGTH - 1; i++) {
if (input.at(i) < '0' || input.at(i) > '9') {
print("Your number consists of illegal characters");
return 0;
}
}
return 1;
}
void e()
{
print("PRINT");
std::vector<int> stringToIntVector(const std::string input) {
std::vector<int> vector;
for (int i = input.length() - 1; i >= 0; i--) {
vector.push_back(input.at(i) - '0');
}
return vector;
}
bool checkInput(const std::string input)
{
if(input.length() != ISBN_LENGTH)
{
print("Your number is too short/too long");
return 0;
}
for(int i = 0; i <= ISBN_LENGTH - 1; i++)
{
if(input.at(i) < '0' || input.at(i) > '9')
{
print("Your number consists of illegal characters");
return 0;
}
}
return 1;
std::vector<int> userISBN() {
std::string input;
do {
std::cout << "Enter the ISBN number (10 digits): ";
getline(std::cin, input);
} while (!checkInput(input));
return stringToIntVector(input);
}
std::vector <int> stringToIntVector(const std::string input)
{
std::vector <int> vector;
for(int i = input.length() - 1; i >= 0; i--)
{
vector.push_back(input.at(i) - '0');
}
return vector;
bool checkISBN(const std::vector<int> isbn) {
int sum = 0, t = 0;
for (int i = 0; i < ISBN_LENGTH; i++) {
t += isbn[i];
sum += t;
}
/*if(DEBUG)
{
if(!(sum % CHECK_NUMBER)) print("^^^ VALID NUMBER ^^^");
} */
return !(sum % CHECK_NUMBER);
}
std::vector <int> userISBN()
{
std::string input;
do{
std::cout << "Enter the ISBN number (10 digits): ";
getline(std::cin, input);
}while(!checkInput(input));
return stringToIntVector(input);
std::vector<int> intToVector(unsigned long long int number) {
std::vector<int> numbers;
while (number > 0) {
numbers.push_back(number % 10);
number /= 10;
}
std::reverse(numbers.begin(), numbers.end());
return numbers;
}
bool checkISBN(const std::vector <int> isbn)
{
int sum = 0, t = 0;
for(int i = 0; i < ISBN_LENGTH; i++)
{
t += isbn[i];
sum += t;
}
/*if(DEBUG)
{
if(!(sum % CHECK_NUMBER)) print("^^^ VALID NUMBER ^^^");
} */
return !(sum % CHECK_NUMBER);
int checkAll() {
int sum = 0;
std::ofstream file;
file.open("ISBN.txt");
for (unsigned long long int i = HIGHEST_ISBN; i >= 1; i--) {
// if(DEBUG) std::cout << i << std::endl;
if (checkISBN(intToVector(i))) {
++sum;
file << std::to_string(i) << "\n";
}
}
file << "There are " << sum << " valid ISBN numbers\n";
file.close();
return sum;
}
std::vector <int> intToVector(unsigned long long int number)
{
std::vector <int> numbers;
while(number > 0)
{
numbers.push_back(number % 10);
number /= 10;
}
std::reverse(numbers.begin(), numbers.end());
return numbers;
}
int checkAll()
{
int sum = 0;
std::ofstream file;
file.open("ISBN.txt");
for(unsigned long long int i = HIGHEST_ISBN; i >= 1; i--)
{
//if(DEBUG) std::cout << i << std::endl;
if( checkISBN(intToVector(i)) )
{
++sum;
file << std::to_string(i) << "\n";
}
}
file << "There are " << sum << " valid ISBN numbers\n";
file.close();
return sum;
}
int main()
{
checkAll();
return 0;
int main() {
checkAll();
return 0;
}
#endif

69
CPP/miscelanious/howOftenDoesCharOccur.cpp
View File

@ -1,48 +1,39 @@
#include <iostream>
#include <vector>
struct charOccurence
{
char c;
int occurrence;
struct charOccurence {
char c;
int occurrence;
};
void printCharOccurenceVector(const std::vector <charOccurence> v)
{
std::cout << "[";
for(unsigned int i = 0; i < v.size(); i++)
{
std::cout << "(\"" << v.at(i).c << "\", " << v.at(i).occurrence << ")" << (i + 1 == v.size() ? "" : ", ");
}
std::cout << "]" << std::endl;
void printCharOccurenceVector(const std::vector<charOccurence> v) {
std::cout << "[";
for (unsigned int i = 0; i < v.size(); i++) {
std::cout << "(\"" << v.at(i).c << "\", " << v.at(i).occurrence << ")"
<< (i + 1 == v.size() ? "" : ", ");
}
std::cout << "]" << std::endl;
}
int main() {
std::vector<charOccurence> list;
std::string userInput = "aaaabbbcca";
charOccurence newCharOccurence;
newCharOccurence.c = userInput.at(0);
newCharOccurence.occurrence = 1;
for (unsigned int i = 1, j = 1; i < userInput.length(); i++) {
char newCharacter = userInput.at(i);
if (newCharacter != newCharOccurence.c) {
list.push_back(newCharOccurence);
j = 1;
newCharOccurence.c = newCharacter;
newCharOccurence.occurrence = j;
int main()
{
std::vector <charOccurence> list;
std::string userInput = "aaaabbbcca";
charOccurence newCharOccurence;
newCharOccurence.c = userInput.at(0);
newCharOccurence.occurrence = 1;
for(unsigned int i = 1, j = 1; i < userInput.length(); i++)
{
char newCharacter = userInput.at(i);
if(newCharacter != newCharOccurence.c)
{
list.push_back(newCharOccurence);
j = 1;
newCharOccurence.c = newCharacter;
newCharOccurence.occurrence = j;
}else
{
newCharOccurence.occurrence++;
}
}
list.push_back(newCharOccurence);
printCharOccurenceVector(list);
return 0;
} else {
newCharOccurence.occurrence++;
}
}
list.push_back(newCharOccurence);
printCharOccurenceVector(list);
return 0;
}

224
CPP/miscelanious/markovChainGenerator/basic.cpp
View File

@ -1,10 +1,10 @@
#ifndef BASIC_CPP
#define BASIC_CPP
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
void print(const std::string s) { std::cout << s << std::endl; }
@ -14,164 +14,136 @@ void e() { print("Poor man breakboint"); }
bool charIsNumber(const char c) { return c >= '0' && c <= '9'; }
void printStringNewLine(const std::string s)
{
std::cout << "string: " << std::endl;
std::cout << "\"" << s << "\"" << std::endl;
void printStringNewLine(const std::string s) {
std::cout << "string: " << std::endl;
std::cout << "\"" << s << "\"" << std::endl;
}
void printStringContainsNotNumbers(const std::string s, const int position)
{
printStringNewLine(s);
std::cout << "contains character different than number at position: " << position
<< "; this character is: " << s.at(position) << std::endl;
void printStringContainsNotNumbers(const std::string s, const int position) {
printStringNewLine(s);
std::cout << "contains character different than number at position: "
<< position << "; this character is: " << s.at(position)
<< std::endl;
}
void printStringContainsNumbers(const std::string s, const int position)
{
printStringNewLine(s);
std::cout << "contains number at postion: " << position
<< "; this number is: " << s.at(position) << std::endl;
void printStringContainsNumbers(const std::string s, const int position) {
printStringNewLine(s);
std::cout << "contains number at postion: " << position
<< "; this number is: " << s.at(position) << std::endl;
}
void printNumberTooLow(const int number, const int min)
{
std::cout << "number: " << number
<< " is too low. Minimal number is: " << min << std::endl;
void printNumberTooLow(const int number, const int min) {
std::cout << "number: " << number << " is too low. Minimal number is: " << min
<< std::endl;
}
void printNumberTooHigh(const int number, const int max)
{
std::cout << "number: " << number
<< " is too high. Maximal number is: " << max << std::endl;
void printNumberTooHigh(const int number, const int max) {
std::cout << "number: " << number
<< " is too high. Maximal number is: " << max << std::endl;
}
void printNotValidStringLength(const std::string s, const int desiredLength)
{
printStringNewLine(s);
std::cout << "is too short/too long, it is: "
<< s.length() << " characters long but should be: " << desiredLength
<< " characters long " << std::endl;
void printNotValidStringLength(const std::string s, const int desiredLength) {
printStringNewLine(s);
std::cout << "is too short/too long, it is: " << s.length()
<< " characters long but should be: " << desiredLength
<< " characters long " << std::endl;
}
void printInvalidCharacter(const char c, const char desiredCharacter)
{
std::cout << "[ " << c << " ] Is invalid character, expected: [ "
<< desiredCharacter << " ]" << std::endl;
void printInvalidCharacter(const char c, const char desiredCharacter) {
std::cout << "[ " << c << " ] Is invalid character, expected: [ "
<< desiredCharacter << " ]" << std::endl;
}
void printContainsIllegalCharacter( const std::string s,
const char illegalCharacter )
{
printStringNewLine(s);
std::cout << " consists of illegal sign: ["
<< illegalCharacter << "]!" << std::endl;
void printContainsIllegalCharacter(const std::string s,
const char illegalCharacter) {
printStringNewLine(s);
std::cout << " consists of illegal sign: [" << illegalCharacter << "]!"
<< std::endl;
}
bool numberTooLow(const int number, const int min)
{
if(number < min)
{
printNumberTooLow(number, min);
return 1;
}
return 0;
bool numberTooLow(const int number, const int min) {
if (number < min) {
printNumberTooLow(number, min);
return 1;
}
return 0;
}
bool numberTooHigh(const int number, const int max)
{
if(number > max)
{
printNumberTooHigh(number, max);
return 1;
}
return 0;
bool numberTooHigh(const int number, const int max) {
if (number > max) {
printNumberTooHigh(number, max);
return 1;
}
return 0;
}
bool containsIllegalCharacter(const std::string s, const char illegalCharacter)
{
if( s.find(illegalCharacter) != std::string::npos)
{
printContainsIllegalCharacter(s, illegalCharacter);
return 1;
}
return 0;
bool containsIllegalCharacter(const std::string s,
const char illegalCharacter) {
if (s.find(illegalCharacter) != std::string::npos) {
printContainsIllegalCharacter(s, illegalCharacter);
return 1;
}
return 0;
}
void printStringVector(const std::vector <std::string> vector)
{
for(unsigned int i = 0; i < vector.size(); i++) print(vector.at(i));
void printStringVector(const std::vector<std::string> vector) {
for (unsigned int i = 0; i < vector.size(); i++)
print(vector.at(i));
}
bool stringContainsNotNumbers(const std::string s)
{
for(unsigned int i = 0; i < s.length(); i++)
{
if(!charIsNumber(s.at(i)))
{
printStringContainsNotNumbers(s, i);
return 1;
}
}
return 0;
bool stringContainsNotNumbers(const std::string s) {
for (unsigned int i = 0; i < s.length(); i++) {
if (!charIsNumber(s.at(i))) {
printStringContainsNotNumbers(s, i);
return 1;
}
}
return 0;
}
bool stringContainsNumbers(const std::string s)
{
for(unsigned int i = 0; i < s.length(); i++)
{
if(charIsNumber(s.at(i)))
{
printStringContainsNumbers(s, i);
return 1;
}
}
return 0;
bool stringContainsNumbers(const std::string s) {
for (unsigned int i = 0; i < s.length(); i++) {
if (charIsNumber(s.at(i))) {
printStringContainsNumbers(s, i);
return 1;
}
}
return 0;
}
bool validStringLength(const std::string s, const int desiredLength)
{
int stringLength = s.length();
if(stringLength != desiredLength)
{
printNotValidStringLength(s, desiredLength);
return 0;
}
return 1;
bool validStringLength(const std::string s, const int desiredLength) {
int stringLength = s.length();
if (stringLength != desiredLength) {
printNotValidStringLength(s, desiredLength);
return 0;
}
return 1;
}
bool validCharacter(const char inputC, const char desiredC)
{
if(inputC != desiredC)
{
printInvalidCharacter(inputC, desiredC);
return 0;
}
return 1;
bool validCharacter(const char inputC, const char desiredC) {
if (inputC != desiredC) {
printInvalidCharacter(inputC, desiredC);
return 0;
}
return 1;
}
void vectorToFile(const std::vector <std::string> strings, std::ofstream &file)
{
for(unsigned int i = 0; i < strings.size(); i++)
{
file << strings.at(i) << std::endl;
}
void vectorToFile(const std::vector<std::string> strings, std::ofstream &file) {
for (unsigned int i = 0; i < strings.size(); i++) {
file << strings.at(i) << std::endl;
}
}
std::vector <std::string> fileToVector(std::ifstream &file,
std::vector <std::string> strings)
{
std::string line;
if(file.is_open())
{
while(getline(file, line))
{
strings.push_back(line);
}
file.close();
}
return strings;
std::vector<std::string> fileToVector(std::ifstream &file,
std::vector<std::string> strings) {
std::string line;
if (file.is_open()) {
while (getline(file, line)) {
strings.push_back(line);
}
file.close();
}
return strings;
}
#endif

194
CPP/miscelanious/markovChainGenerator/main.cpp
View File

@ -1,138 +1,124 @@
#ifndef MAIN_CPP
#define MAIN_CPP
#include <string>
#include <iostream>
#include <vector>
#include "basic.cpp"
#include <iostream>
#include <string>
#include <vector>
struct wordOccurences
{
std::string word;
int occurences;
struct wordOccurences {
std::string word;
int occurences;
}
struct previousWords
{
std::string word;
std::vector <wordOccurences> previousWords;
struct previousWords {
std::string word;
std::vector<wordOccurences> previousWords;
};
struct wordProbabiliy
{
std::string previousWord;
std::string nextWord;
float probability;
struct wordProbabiliy {
std::string previousWord;
std::string nextWord;
float probability;
}
bool validInput(const std::string userInput)
{
if(stringContainsNumbers(userInput)) return 0;
return 1;
if (stringContainsNumbers(userInput))
return 0;
return 1;
}
std::vector <std::string> divideIntoWords(const std::string userInput)
{
std::vector <std::string> words;
int inputLength = userInput.length();
int wordLength = 0;
for(int i = 0; i < inputLength; i++)
{
if(userInput.at(i) == ' ')
{
words.push_back(userInput.substr(i - wordLength, wordLength));
wordLength = 0;
}else wordLength++;
std::vector<std::string> divideIntoWords(const std::string userInput) {
std::vector<std::string> words;
int inputLength = userInput.length();
int wordLength = 0;
for (int i = 0; i < inputLength; i++) {
if (userInput.at(i) == ' ') {
words.push_back(userInput.substr(i - wordLength, wordLength));
wordLength = 0;
} else
wordLength++;
if(i + 1 == inputLength)
{
words.push_back(userInput.substr(i - wordLength + 1, wordLength + 1));
wordLength = 0;
}
}
return words;
if (i + 1 == inputLength) {
words.push_back(userInput.substr(i - wordLength + 1, wordLength + 1));
wordLength = 0;
}
}
return words;
}
int wordRepeats(const std::vector <previousWords> wordsList, const std::string word)
{
int wordsSize = wordsList.size();
for(int i = 0; i < wordsSize; i++)
{
if(wordsList.at(i).word == word) return i;
}
return -1;
int wordRepeats(const std::vector<previousWords> wordsList,
const std::string word) {
int wordsSize = wordsList.size();
for (int i = 0; i < wordsSize; i++) {
if (wordsList.at(i).word == word)
return i;
}
return -1;
}
bool alreadyExists(const std::vector <previousWords> wordsList, const std::string s)
{
for(unsigned int i = 0; i < wordsList.size(); i++)
{
if(s == wordsList.previousWOrds
}
bool alreadyExists(const std::vector<previousWords> wordsList,
const std::string s) {
for (unsigned int i = 0; i < wordsList.size(); i++) {
if(s == wordsList.previousWOrds
}
}
std::vector <previousWords> getWordsAndTheirPrevious(const std::vector <std::string> words)
{
std::vector <previousWords> wordsList;
int wordsSize = words.size();
for(int i = 1; i < wordsSize; i++)
{
previousWords temp;
temp.word = words.at(i);
wordOccurences tempTwo;
tempTwo.word = words.at(i - 1));
tempTwo.occurences = 1;
temp.previousWords.push_back(tempTwo);
int position = wordRepeats(wordsList, temp.word);
if(position == -1)
{
wordsList.push_back(temp);
}else
{
std::vector<previousWords>
getWordsAndTheirPrevious(const std::vector<std::string> words) {
std::vector<previousWords> wordsList;
int wordsSize = words.size();
for (int i = 1; i < wordsSize; i++) {
previousWords temp;
temp.word = words.at(i);
wordOccurences tempTwo;
tempTwo.word = words.at(i - 1));
tempTwo.occurences = 1;
temp.previousWords.push_back(tempTwo);
int position = wordRepeats(wordsList, temp.word);
if (position == -1) {
wordsList.push_back(temp);
} else {
wordsList.at(position).previousWords.push_back(temp.previousWords.at(0));
}
}
return wordsList;
wordsList.at(position).previousWords.push_back(
temp.previousWords.at(0));
}
}
return wordsList;
}
void printPreviousWord(const previousWords word)
{
std::cout << "The word is \"" << word.word << "\" Words before it are: " << std::endl;
for(unsigned int i = 0; i < word.previousWords.size(); i++)
{
print(word.previousWords.at(i));
}
void printPreviousWord(const previousWords word) {
std::cout << "The word is \"" << word.word
<< "\" Words before it are: " << std::endl;
for (unsigned int i = 0; i < word.previousWords.size(); i++) {
print(word.previousWords.at(i));
}
}
void printPreviousWordsVector(const std::vector <previousWords> v)
{
for(unsigned int i = 0; i < v.size(); i++)
{
printPreviousWord(v.at(i));
}
void printPreviousWordsVector(const std::vector<previousWords> v) {
for (unsigned int i = 0; i < v.size(); i++) {
printPreviousWord(v.at(i));
}
}
std::vector <wordProbability> getWordProbability(const std::vector <previousWords> wordsList)
{
std::vector <wordProbability> probalityVector;
for(unsigned int i = 0; i - 1 < wordsList.size(); i++)
{
pro
}
std::vector<wordProbability>
getWordProbability(const std::vector<previousWords> wordsList) {
std::vector<wordProbability> probalityVector;
for (unsigned int i = 0; i - 1 < wordsList.size(); i++) {
pro
}
}
int main()
{
std::string userInput;
do{
getline(std::cin, userInput);
}while(!validInput(userInput));
std::vector <std::string> words = divideIntoWords(userInput);
std::vector <previousWords> prev = getWordsAndTheirPrevious(words);
printPreviousWordsVector(prev);
return 0;
int main() {
std::string userInput;
do {
getline(std::cin, userInput);
} while (!validInput(userInput));
std::vector<std::string> words = divideIntoWords(userInput);
std::vector<previousWords> prev = getWordsAndTheirPrevious(words);
printPreviousWordsVector(prev);
return 0;
}
#endif

40
CPP/miscelanious/mutiplicationWithoutStar/multiplication.cpp
View File

@ -1,27 +1,23 @@
#include <iostream>
int multiplication(int a, int b)
{
int answer = 0;
for(int i = 0; i < a; i++)
{
answer += b;
}
if(answer != a*b)
{
std::cout << "There is a mistake in your code!" << std::endl;
return -1;
} else return answer;
int multiplication(int a, int b) {
int answer = 0;
for (int i = 0; i < a; i++) {
answer += b;
}
if (answer != a * b) {
std::cout << "There is a mistake in your code!" << std::endl;
return -1;
} else
return answer;
}
int main()
{
int a,b;
std::cout << "Enter number a" << std::endl;
std::cin >> a;
std::cout << "Enter number b" << std::endl;
std::cin >> b;
std::cout << multiplication(a, b) << std::endl;
return 0;
int main() {
int a, b;
std::cout << "Enter number a" << std::endl;
std::cin >> a;
std::cout << "Enter number b" << std::endl;
std::cin >> b;
std::cout << multiplication(a, b) << std::endl;
return 0;
}

165
CPP/miscelanious/quickchallenges.cpp
View File

@ -1,96 +1,99 @@
#include <iostream>
#include <vector>
int sumStartEnd(int start, int end)
{
int sum = 0;
for(int i = start; i <= end; i++)
{
sum += i;
}
return sum;
int sumStartEnd(int start, int end) {
int sum = 0;
for (int i = start; i <= end; i++) {
sum += i;
}
return sum;
}
int main()
{
std::cout << "Krzysztof" << std::endl;
for(int i = 700; i >= 200; i -= 13) std::cout << i << std::endl;
std::vector <int> array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// if SECOND means 0, 1, TWO
std::cout << array[2] << std::endl;
// if SECOND means 1, TWO
std::cout << array[1] << std::endl;
std::cout << sumStartEnd(0, 1000);
int main() {
std::cout << "Krzysztof" << std::endl;
for (int i = 700; i >= 200; i -= 13)
std::cout << i << std::endl;
std::vector<int> array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// if SECOND means 0, 1, TWO
std::cout << array[2] << std::endl;
// if SECOND means 1, TWO
std::cout << array[1] << std::endl;
std::cout << sumStartEnd(0, 1000);
std::string userName;
std::cout << std::endl;
getline(std::cin, userName);
if(userName == "Jack") std::cout << "Hi Jack!" << std::endl;
else std::cout << "Hello, " << userName << std::endl;
std::string userName;
std::cout << std::endl;
getline(std::cin, userName);
if (userName == "Jack")
std::cout << "Hi Jack!" << std::endl;
else
std::cout << "Hello, " << userName << std::endl;
for(int i = 0; i <= 100; i++)
{
if(i % 2 == 0) std::cout << i << " is an even number" << std::endl;
else std::cout << i << " is an odd number" << std::endl;
}
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0)
std::cout << i << " is an even number" << std::endl;
else
std::cout << i << " is an odd number" << std::endl;
}
bool flag = 1;
for(int i = 0; i <= 100; i++)
{
if(flag) std::cout << i << " is an even number" << std::endl;
else std::cout << i << " is an odd number" << std::endl;
flag = -flag;
}
bool flag = 1;
for (int i = 0; i <= 100; i++) {
if (flag)
std::cout << i << " is an even number" << std::endl;
else
std::cout << i << " is an odd number" << std::endl;
flag = -flag;
}
for(int i = 0; i <= 100; i += 2) std::cout << i << " is an even number " << std::endl;
for(int i = 1; i <= 99; i += 2) std::cout << i << " is an odd number " << std::endl;
for (int i = 0; i <= 100; i += 2)
std::cout << i << " is an even number " << std::endl;
for (int i = 1; i <= 99; i += 2)
std::cout << i << " is an odd number " << std::endl;
for(int i = 1, j = 1; j <= 12; i++)
{
std::cout << i * j << " ";
for (int i = 1, j = 1; j <= 12; i++) {
std::cout << i * j << " ";
if(i == 12)
{
i = 1;
j++;
std::cout << std::endl;
}
}
if (i == 12) {
i = 1;
j++;
std::cout << std::endl;
}
}
std::cout << std::endl;
std::string sentence;
getline(std::cin, sentence);
std::vector <std::string> words;
std::string temp;
for(unsigned int i = 0; i < sentence.length(); i++)
{
if(sentence.at(i) == ' ' || i + 1 == sentence.length())
{
if(i + 1 == sentence.length()) temp.push_back(sentence.at(i));
words.push_back(temp);
temp = "";
}else temp.push_back(sentence.at(i));
}
for(unsigned int i = 0; i < words.size(); i++)
{
std::cout << words[i] << std::endl;
}
int score;
char project;
std::vector <char> GRADES = {'F', 'C', 'B', 'A'};
std::cin >> score;
std::cout << std::endl;
std::cin >> project;
std::cout << std::endl;
bool doneProject = 0;
if(project == 'Y') doneProject = 1;
if(score < 50) std::cout << GRADES[0 + doneProject];
else if(score < 70) std::cout << GRADES[1 + doneProject];
else if(score < 90) std::cout << GRADES[2 + doneProject];
else std::cout << GRADES[3];
std::cout << std::endl;
std::string sentence;
getline(std::cin, sentence);
std::vector<std::string> words;
std::string temp;
for (unsigned int i = 0; i < sentence.length(); i++) {
if (sentence.at(i) == ' ' || i + 1 == sentence.length()) {
if (i + 1 == sentence.length())
temp.push_back(sentence.at(i));
words.push_back(temp);
temp = "";
} else
temp.push_back(sentence.at(i));
}
for (unsigned int i = 0; i < words.size(); i++) {
std::cout << words[i] << std::endl;
}
int score;
char project;
std::vector<char> GRADES = {'F', 'C', 'B', 'A'};
std::cin >> score;
std::cout << std::endl;
std::cin >> project;
std::cout << std::endl;
bool doneProject = 0;
if (project == 'Y')
doneProject = 1;
if (score < 50)
std::cout << GRADES[0 + doneProject];
else if (score < 70)
std::cout << GRADES[1 + doneProject];
else if (score < 90)
std::cout << GRADES[2 + doneProject];
else
std::cout << GRADES[3];
}

10
CPP/miscelanious/randomDevice/main.cpp
View File

@ -1,10 +1,10 @@
#include <random>
#include <iostream>
#include <random>
int main() {
std::random_device rd;
std::uniform_real_distribution<double> dist(1.0, 10.0);
std::random_device rd;
std::uniform_real_distribution<double> dist(1.0, 10.0);
for (int i=0; i<16; ++i)
std::cout << dist(rd) << "\n";
for (int i = 0; i < 16; ++i)
std::cout << dist(rd) << "\n";
}

34
CPP/miscelanious/reverseString.cpp
View File

@ -1,22 +1,20 @@
#include <algorithm>
#include <iostream>
#include <string>
#include <algorithm>
int main()
{
std::string userString;
getline(std::cin, userString);
int sLength = userString.length();
std::string tempString = userString;
for(int i = 0; i < sLength/2; i++)
{
char temp = tempString[sLength - 1 - i];
tempString[sLength - 1 - i] = tempString[i];
tempString[i] = temp;
}
reverse(userString.begin(), userString.end());
bool correct = tempString == userString;
std::cout << correct << std::endl;
std::cout << tempString << std::endl;
return 0;
int main() {
std::string userString;
getline(std::cin, userString);
int sLength = userString.length();
std::string tempString = userString;
for (int i = 0; i < sLength / 2; i++) {
char temp = tempString[sLength - 1 - i];
tempString[sLength - 1 - i] = tempString[i];
tempString[i] = temp;
}
reverse(userString.begin(), userString.end());
bool correct = tempString == userString;
std::cout << correct << std::endl;
std::cout << tempString << std::endl;
return 0;
}

61
CPP/miscelanious/solveQuadraticEquation.cpp
View File

@ -1,48 +1,39 @@
#include <iostream>
#include <string>
#include <math.h>
#include <string>
const std::string ENTER = "Enter quadratic equation constants: ";
const std::string WHAT_TO_INPUT = "a, b, c as in: ax^2 + bx + c = 0";
const std::string START = ENTER + WHAT_TO_INPUT;
const std::string START = ENTER + WHAT_TO_INPUT;
void print(const std::string s) { std::cout << s << std::endl; }
float getDelta(float a, float b, float c)
{
return b*b - 4*a*c;
float getDelta(float a, float b, float c) { return b * b - 4 * a * c; }
float calculateFirstTerm(float a, float b, float delta) {
return (-b - sqrt(delta)) / (2 * a);
}
float calculateFirstTerm(float a, float b, float delta)
{
return (-b - sqrt(delta))/(2*a);
float calculateSecondTerm(float a, float b, float delta) {
return (-b + sqrt(delta)) / (2 * a);
}
float calculateSecondTerm(float a, float b, float delta)
{
return (-b + sqrt(delta))/(2*a);
}
int main()
{
print(START);
float a, b, c;
std::cin >> a;
std::cin >> b;
std::cin >> c;
float delta = getDelta(a, b, c);
if(delta < 0)
{
print("delta smaller than 0");
return -1;
}
float x_1 = calculateFirstTerm(a, b, delta);
float x_2 = calculateSecondTerm(a, b, delta);
print("Solutions:");
std::cout << "x_1 = " << x_1 << std::endl;
std::cout << "x_2 = " << x_2 << std::endl;
return 0;
int main() {
print(START);
float a, b, c;
std::cin >> a;
std::cin >> b;
std::cin >> c;
float delta = getDelta(a, b, c);
if (delta < 0) {
print("delta smaller than 0");
return -1;
}
float x_1 = calculateFirstTerm(a, b, delta);
float x_2 = calculateSecondTerm(a, b, delta);
print("Solutions:");
std::cout << "x_1 = " << x_1 << std::endl;
std::cout << "x_2 = " << x_2 << std::endl;
return 0;
}

216
CPP/miscelanious/tictactoe/tictactoe.cpp
View File

@ -1,111 +1,123 @@
#include <iostream>
#include <vector>
void printField(std::vector<unsigned int> &field)
{
std::cout << std::endl;
for(int i = 0; i < 9; i++)
{
if(i % 3 == 0) std::cout << std::endl;
if(field[i] == 0) std::cout << "-";
else if(field[i] == 1) std::cout << "X";
else if(field[i] == 2) std::cout << "O";
}
std::cout << std::endl;
void printField(std::vector<unsigned int> &field) {
std::cout << std::endl;
for (int i = 0; i < 9; i++) {
if (i % 3 == 0)
std::cout << std::endl;
if (field[i] == 0)
std::cout << "-";
else if (field[i] == 1)
std::cout << "X";
else if (field[i] == 2)
std::cout << "O";
}
std::cout << std::endl;
}
unsigned int chooseField(unsigned int playerNumber, std::vector<unsigned int> &field)
{
unsigned int chosenField;
do
{
std::cout << "player " << playerNumber << " choose a field:" << std::endl;
std::cin >> chosenField;
}while(field[chosenField] != 0);
return chosenField;
unsigned int chooseField(unsigned int playerNumber,
std::vector<unsigned int> &field) {
unsigned int chosenField;
do {
std::cout << "player " << playerNumber << " choose a field:" << std::endl;
std::cin >> chosenField;
} while (field[chosenField] != 0);
return chosenField;
}
bool vertical(unsigned int playerNumber, std::vector<unsigned int> &field)
{
if((field[0] == playerNumber && field[1] == playerNumber && field[2] == playerNumber)
|| (field[3] == playerNumber && field[4] == playerNumber && field[5] == playerNumber)
|| (field[6] == playerNumber && field[7] == playerNumber && field[8] == playerNumber))
{
return 1;
}else return 0;
}
bool horizontal(unsigned int playerNumber, std::vector<unsigned int> &field)
{
if((field[0] == playerNumber && field[3] == playerNumber && field[6] == playerNumber)
|| (field[1] == playerNumber && field[4] == playerNumber && field[7] == playerNumber)
|| (field[2] == playerNumber && field[5] == playerNumber && field[8] == playerNumber))
{
return 1;
}else return 0;
}
bool across(unsigned int playerNumber, std::vector<unsigned int> &field)
{
if((field[0] == playerNumber && field[4] == playerNumber && field[8] == playerNumber)
|| (field[2] == playerNumber && field[4] == playerNumber && field[6] == playerNumber))
{
return 1;
}else return 0;
}
bool checkPlayerWin(unsigned int playerNumber, std::vector<unsigned int> &field)
{
if(vertical(playerNumber, field)) return 1;
if(horizontal(playerNumber, field)) return 1;
if(across(playerNumber, field)) return 1;
else return 0;
}
unsigned int checkIfWin(std::vector<unsigned int> &field)
{
if(checkPlayerWin(1, field)) return 1;
else if(checkPlayerWin(2, field)) return 2;
else return 0;
}
bool checkIfFilled(std::vector<unsigned int> &field)
{
bool filled = 1;
for(int i = 0; i < 9; i++)
{
if(field[i] == 0)
{
filled = 0;
return filled;
}
}
return filled;
}
bool turn(unsigned int playerNumber, std::vector<unsigned int> &field, bool *filled, unsigned int *whoWon)
{
field[chooseField(playerNumber, field)] = playerNumber;
printField(field);
*whoWon = checkIfWin(field);
*filled = checkIfFilled(field);
if(*whoWon != 0 || *filled != 0) return 1;
else return 0;
}
int main()
{
std::vector<unsigned int> field = {0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned int whoWon = 0;
bool filled = 0;
while(whoWon == 0 || filled == 0)
{
if(turn(1, field, &filled, &whoWon)) break;
if(turn(2, field, &filled, &whoWon)) break;
}
if(!filled) std::cout << "Player " << whoWon << " Won!" << std::endl;
else std::cout << "DRAW!" << std::endl;
bool vertical(unsigned int playerNumber, std::vector<unsigned int> &field) {
if ((field[0] == playerNumber && field[1] == playerNumber &&
field[2] == playerNumber) ||
(field[3] == playerNumber && field[4] == playerNumber &&
field[5] == playerNumber) ||
(field[6] == playerNumber && field[7] == playerNumber &&
field[8] == playerNumber)) {
return 1;
} else
return 0;
}
bool horizontal(unsigned int playerNumber, std::vector<unsigned int> &field) {
if ((field[0] == playerNumber && field[3] == playerNumber &&
field[6] == playerNumber) ||
(field[1] == playerNumber && field[4] == playerNumber &&
field[7] == playerNumber) ||
(field[2] == playerNumber && field[5] == playerNumber &&
field[8] == playerNumber)) {
return 1;
} else
return 0;
}
bool across(unsigned int playerNumber, std::vector<unsigned int> &field) {
if ((field[0] == playerNumber && field[4] == playerNumber &&
field[8] == playerNumber) ||
(field[2] == playerNumber && field[4] == playerNumber &&
field[6] == playerNumber)) {
return 1;
} else
return 0;
}
bool checkPlayerWin(unsigned int playerNumber,
std::vector<unsigned int> &field) {
if (vertical(playerNumber, field))
return 1;
if (horizontal(playerNumber, field))
return 1;
if (across(playerNumber, field))
return 1;
else
return 0;
}
unsigned int checkIfWin(std::vector<unsigned int> &field) {
if (checkPlayerWin(1, field))
return 1;
else if (checkPlayerWin(2, field))
return 2;
else
return 0;
}
bool checkIfFilled(std::vector<unsigned int> &field) {
bool filled = 1;
for (int i = 0; i < 9; i++) {
if (field[i] == 0) {
filled = 0;
return filled;
}
}
return filled;
}
bool turn(unsigned int playerNumber, std::vector<unsigned int> &field,
bool *filled, unsigned int *whoWon) {
field[chooseField(playerNumber, field)] = playerNumber;
printField(field);
*whoWon = checkIfWin(field);
*filled = checkIfFilled(field);
if (*whoWon != 0 || *filled != 0)
return 1;
else
return 0;
}
int main() {
std::vector<unsigned int> field = {0, 0, 0, 0, 0, 0, 0, 0, 0};
unsigned int whoWon = 0;
bool filled = 0;
while (whoWon == 0 || filled == 0) {
if (turn(1, field, &filled, &whoWon))
break;
if (turn(2, field, &filled, &whoWon))
break;
}
if (!filled)
std::cout << "Player " << whoWon << " Won!" << std::endl;
else
std::cout << "DRAW!" << std::endl;
return 0;
}

142
CPP/miscelanious/tierListConverter/tierListConverter.cpp
View File

@ -2,88 +2,74 @@
#include <string>
#include <vector>
const std::vector <std::string> TIERS = {"Abhorrent", "Bad", "Mid", "Good", "Top", "God Tier"};
const std::vector<std::string> TIERS = {"Abhorrent", "Bad", "Mid",
"Good", "Top", "God Tier"};
const float TIER_BASE = TIERS.size();
void print(std::string const s)
{
std::cout << s << std::endl;
void print(std::string const s) { std::cout << s << std::endl; }
bool errorUserInput(std::string userInput) {
if (userInput.find("/") == std::string::npos) {
print("No '/' was found!");
return 1;
}
size_t positionOfSlash = userInput.find("/");
std::string nominatorS = userInput.substr(0, positionOfSlash);
try {
float nominator = stof(nominatorS);
} catch (std::invalid_argument) {
print("No number was found before the slash!");
return 1;
}
std::string denominatorS =
userInput.substr(positionOfSlash + 1, userInput.length() - 1);
try {
float denominator = stof(denominatorS);
if (denominator == 0) {
print("You cannot divide by 0!");
return 1;
}
} catch (std::invalid_argument) {
print("No number was found after the slash!");
return 1;
}
return 0;
}
bool errorUserInput(std::string userInput)
{
if(userInput.find("/") == std::string::npos)
{
print("No '/' was found!");
return 1;
}
size_t positionOfSlash = userInput.find("/");
std::string nominatorS = userInput.substr(0, positionOfSlash);
try
{
float nominator = stof(nominatorS);
}catch ( std::invalid_argument )
{
print("No number was found before the slash!");
return 1;
}
std::string denominatorS = userInput.substr(positionOfSlash + 1, userInput.length() - 1);
try
{
float denominator = stof(denominatorS);
if(denominator == 0)
{
print("You cannot divide by 0!");
return 1;
}
}catch ( std::invalid_argument )
{
print("No number was found after the slash!");
return 1;
}
return 0;
std::string convertToTier(float nominator, float denominator) {
float fraction = nominator / denominator;
int tierIndex;
for (int i = TIER_BASE; i > 0; i--) {
if (fraction >= (i / TIER_BASE)) {
tierIndex = i - 1;
break;
}
}
if (tierIndex == 0 & fraction > (1.1 / 10.0))
return TIERS[1];
return TIERS[tierIndex];
}
std::string convertToTier(float nominator, float denominator)
{
float fraction = nominator / denominator;
int tierIndex;
for(int i = TIER_BASE; i > 0; i--)
{
if(fraction >= ( i / TIER_BASE))
{
tierIndex = i - 1;
break;
}
}
if(tierIndex == 0 & fraction > (1.1/10.0)) return TIERS[1];
return TIERS[tierIndex];
}
int main()
{
std::string userScore;
do
{
print("Enter your score in a format: numberOne/numberTwo");
getline(std::cin, userScore);
}while(errorUserInput(userScore));
size_t positionOfSlash = userScore.find("/");
std::string nominatorS = userScore.substr(0, positionOfSlash);
float nominator = stof(nominatorS);
std::string denominatorS = userScore.substr(positionOfSlash + 1, userScore.length() - 1);
float denominator = stof(denominatorS);
print(convertToTier(nominator, denominator));
return 0;
int main() {
std::string userScore;
do {
print("Enter your score in a format: numberOne/numberTwo");
getline(std::cin, userScore);
} while (errorUserInput(userScore));
size_t positionOfSlash = userScore.find("/");
std::string nominatorS = userScore.substr(0, positionOfSlash);
float nominator = stof(nominatorS);
std::string denominatorS =
userScore.substr(positionOfSlash + 1, userScore.length() - 1);
float denominator = stof(denominatorS);
print(convertToTier(nominator, denominator));
return 0;
}

14
CPP/miscelanious/xGoesTo0/xgoes.cpp
View File

@ -1,11 +1,9 @@
#include <stdio.h>
int main()
{
int x = 10;
while (x-- > 0)
{
printf("%d;", x);
}
return 0;
int main() {
int x = 10;
while (x-- > 0) {
printf("%d;", x);
}
return 0;
}

25
CPP/miscelanious/yousuckatcards/Bernouli/bernouli.cpp
View File

@ -2,21 +2,22 @@
#include <iostream>
#include <random>
int main()
{
const int nrolls=10000;
int main() {
const int nrolls = 10000;
std::random_device rd;
std::mt19937 gen(rd());
std::bernoulli_distribution distribution(0.5);
std::random_device rd;
std::mt19937 gen(rd());
std::bernoulli_distribution distribution(0.5);
int count=0; // count number of trues
int count = 0; // count number of trues
for (int i=0; i<nrolls; ++i) if (distribution(gen)) ++count;
for (int i = 0; i < nrolls; ++i)
if (distribution(gen))
++count;
std::cout << "bernoulli_distribution (0.5) x 10000:" << std::endl;
std::cout << "true: " << count << std::endl;
std::cout << "false: " << nrolls-count << std::endl;
std::cout << "bernoulli_distribution (0.5) x 10000:" << std::endl;
std::cout << "true: " << count << std::endl;
std::cout << "false: " << nrolls - count << std::endl;
return 0;
return 0;
}

15
CPP/miscelanious/yousuckatcards/Bernouli/test.cpp
View File

@ -1,13 +1,14 @@
#include <random>
#include <iostream>
#include <random>
int main() {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<> dis(0, 1);
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<> dis(0, 1);
for(int i = 0; i < 10; i++) {
for (int i = 0; i < 10; i++) {
std::cout << dis(gen) << std::endl;
}return 0;
std::cout << dis(gen) << std::endl;
}
return 0;
}

217
CPP/miscelanious/yousuckatcards/yousuckatcards.cpp
View File

@ -8,120 +8,117 @@ const bool BOT_WON = 0;
const bool PLAYER_WON = 1;
const int NOBODY_WON = 2;
void print(std::string const s)
{
std::cout << s << std::endl;
void print(std::string const s) { std::cout << s << std::endl; }
bool validSequence(std::string const s) {
if (s.size() != SEQUENCE_LENGTH) {
print("Sequence too long");
return false;
}
if ((s[0] != 'B' && s[0] != 'R') || (s[1] != 'B' && s[1] != 'R') ||
(s[2] != 'B' && s[2] != 'R')) {
print("Sequence consists of illegal signs!");
return false;
}
return true;
}
bool validSequence(std::string const s)
{
if(s.size() != SEQUENCE_LENGTH)
{
print("Sequence too long");
return false;
}
if( (s[0] != 'B' && s[0] != 'R') ||
(s[1] != 'B' && s[1] != 'R') ||
(s[2] != 'B' && s[2] != 'R'))
{
print("Sequence consists of illegal signs!");
return false;
}
return true;
std::string playerChoice() {
std::string playerSequence;
do {
std::cin >> playerSequence;
} while (!validSequence(playerSequence));
return playerSequence;
}
std::string playerChoice()
{
std::string botChoice(std::string const playerSequence) {
std::string botSequence;
if (playerSequence[1] == 'B')
botSequence.push_back('R');
else
botSequence.push_back('B');
botSequence.push_back(playerSequence[0]);
botSequence.push_back(playerSequence[2]);
return botSequence;
}
int compareGeneratedAndPlayers(std::string playerSequence,
std::string botSequence,
std::string generatedSequence) {
int generatedSequenceLength = generatedSequence.length();
std::string sequenceToCompare = generatedSequence.substr(
generatedSequenceLength - SEQUENCE_LENGTH, generatedSequenceLength);
if (sequenceToCompare.compare(playerSequence) == 0)
return PLAYER_WON;
if (sequenceToCompare.compare(botSequence) == 0)
return BOT_WON;
else
return NOBODY_WON;
}
bool game(std::string playerSequence, std::string botSequence) {
std::string generatedSequence;
std::random_device rd;
std::mt19937 gen(rd());
std::bernoulli_distribution distribution(0.5);
for (int i = 0; i < SEQUENCE_LENGTH; i++) {
if (distribution(gen))
generatedSequence.push_back('R');
else
generatedSequence.push_back('B');
}
while (compareGeneratedAndPlayers(playerSequence, botSequence,
generatedSequence) == NOBODY_WON) {
if (distribution(gen))
generatedSequence.push_back('R');
else
generatedSequence.push_back('B');
}
print(generatedSequence);
if (compareGeneratedAndPlayers(playerSequence, botSequence,
generatedSequence) == PLAYER_WON)
return PLAYER_WON;
else
return BOT_WON;
}
void score(int playerWins, int botWins) {
std::cout << "Player won: " << playerWins << " times!" << std::endl;
std::cout << "Bot won: " << botWins << " times!" << std::endl;
}
int main() {
int playerWins = 0;
int botWins = 0;
do {
print("Do you want to play the game? 1 - yes, 0 - no");
bool continue_ = 1;
std::string playerInput;
std::cin >> playerInput;
if (playerInput[0] == '1')
continue_ = 1;
else
continue_ = 0;
if (!continue_)
break;
std::string playerSequence;
do
{
std::cin >> playerSequence;
print("Write three colors sequence created from 52 cards from the deck (26 "
"Black, 26 Red), write B for Black and R for Red");
playerSequence = playerChoice();
std::string botSequence = botChoice(playerSequence);
print("Bot has chosen this sequence:");
print(botSequence);
if (game(playerSequence, botSequence)) {
print("You won!");
playerWins++;
score(playerWins, botWins);
} else {
print("Bot won!");
botWins++;
score(playerWins, botWins);
}
while(!validSequence(playerSequence));
return playerSequence;
}
std::string botChoice(std::string const playerSequence)
{
std::string botSequence;
if(playerSequence[1] == 'B') botSequence.push_back('R');
else botSequence.push_back('B');
botSequence.push_back(playerSequence[0]);
botSequence.push_back(playerSequence[2]);
return botSequence;
}
int compareGeneratedAndPlayers(std::string playerSequence, std::string botSequence, std::string generatedSequence)
{
int generatedSequenceLength = generatedSequence.length();
std::string sequenceToCompare = generatedSequence.substr(generatedSequenceLength - SEQUENCE_LENGTH, generatedSequenceLength);
if(sequenceToCompare.compare(playerSequence) == 0) return PLAYER_WON;
if(sequenceToCompare.compare(botSequence) == 0) return BOT_WON;
else return NOBODY_WON;
}
bool game(std::string playerSequence, std::string botSequence)
{
std::string generatedSequence;
std::random_device rd;
std::mt19937 gen(rd());
std::bernoulli_distribution distribution(0.5);
for(int i = 0; i < SEQUENCE_LENGTH; i++)
{
if(distribution(gen)) generatedSequence.push_back('R');
else generatedSequence.push_back('B');
}
while(compareGeneratedAndPlayers(playerSequence, botSequence, generatedSequence) == NOBODY_WON)
{
if(distribution(gen)) generatedSequence.push_back('R');
else generatedSequence.push_back('B');
}
print(generatedSequence);
if(compareGeneratedAndPlayers(playerSequence, botSequence, generatedSequence) == PLAYER_WON) return PLAYER_WON;
else return BOT_WON;
}
void score(int playerWins, int botWins)
{
std::cout << "Player won: " << playerWins << " times!" << std::endl;
std::cout << "Bot won: " << botWins << " times!" << std::endl;
}
int main()
{
int playerWins = 0;
int botWins = 0;
do
{
print("Do you want to play the game? 1 - yes, 0 - no");
bool continue_ = 1;
std::string playerInput;
std::cin >> playerInput;
if(playerInput[0] == '1') continue_ = 1;
else continue_ = 0;
if(!continue_) break;
std::string playerSequence;
print("Write three colors sequence created from 52 cards from the deck (26 Black, 26 Red), write B for Black and R for Red");
playerSequence = playerChoice();
std::string botSequence = botChoice(playerSequence);
print("Bot has chosen this sequence:");
print(botSequence);
if(game(playerSequence, botSequence))
{
print("You won!");
playerWins++;
score(playerWins, botWins);
}
else
{
print("Bot won!");
botWins++;
score(playerWins, botWins);
}
}while(1);
return 1;
} while (1);
return 1;
}

9
CPP/tests/howCppHandlesDivision.cpp
View File

@ -1,8 +1,7 @@
#include <iostream>
int main()
{
float X = 1/2;
std::cout << X << std::endl;
return 0;
int main() {
float X = 1 / 2;
std::cout << X << std::endl;
return 0;
}

4
TS/battery-status/src/useBattery.ts
View File

@ -83,8 +83,8 @@ export function useBattery() {
}
setLoading(false)
} catch (e: any) {
setError(e?.message ?? 'Failed to read battery status')
} catch (e: unknown) {
setError(e instanceof Error ? e.message : 'Failed to read battery status')
setLoading(false)
}
}

51
TS/champions_leauge_scores/server/src/server.ts
View File

@ -10,7 +10,7 @@ const API_BASE = 'https://api.football-data.org/v4';
const API_TOKEN = process.env.FOOTBALL_DATA_API_KEY;
if (!API_TOKEN) {
// eslint-disable-next-line no-console
console.warn('[server] FOOTBALL_DATA_API_KEY is not set. Live data will not work until you set it.');
}
@ -32,34 +32,40 @@ app.use((req, res, next) => {
const clip = (s: string) => (s && s.length > MAX_LOG_BODY ? `${s.slice(0, MAX_LOG_BODY)}…(+${s.length - MAX_LOG_BODY})` : s);
// Attach id so downstream handlers could use it if needed
// eslint-disable-next-line @typescript-eslint/no-explicit-any
(res as any).locals = { ...(res as any).locals, requestId: id };
// Patch res.json and res.send to capture response payload
const originalJson = res.json.bind(res);
const originalSend = res.send.bind(res);
(res as any).json = (body: any) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
(res as any).json = (body: unknown) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
try { (res as any).locals.bodyForLog = body; } catch { /* ignore */ }
return originalJson(body);
};
(res as any).send = (body: any) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
(res as any).send = (body: unknown) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
try { (res as any).locals.bodyForLog = body; } catch { /* ignore */ }
return originalSend(body as any);
return originalSend(body);
};
// eslint-disable-next-line no-console
console.log(`[#${id}] -> ${req.method} ${req.originalUrl}` + (Object.keys(req.query || {}).length ? ` query=${JSON.stringify(req.query)}` : ''));
res.on('finish', () => {
const durMs = Number(process.hrtime.bigint() - start) / 1_000_000;
let bodyPreview = '';
try {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const body = (res as any).locals?.bodyForLog;
if (body !== undefined) {
const str = typeof body === 'string' ? body : JSON.stringify(body);
bodyPreview = ` body=${clip(str)}`;
}
} catch { /* ignore */ }
// eslint-disable-next-line no-console
console.log(`[#${id}] <- ${req.method} ${req.originalUrl} ${res.statusCode} ${durMs.toFixed(1)}ms${bodyPreview}`);
});
@ -69,13 +75,14 @@ app.use((req, res, next) => {
// Axios interceptors to log outgoing requests and incoming responses
axios.interceptors.request.use(
(config) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
(config as any).metadata = { start: Date.now() };
// eslint-disable-next-line no-console
console.log(`[axios ->] ${String(config.method || 'GET').toUpperCase()} ${config.url}`);
return config;
},
(error) => {
// eslint-disable-next-line no-console
console.warn('[axios req error]', error?.message || error);
return Promise.reject(error);
}
@ -83,6 +90,7 @@ axios.interceptors.request.use(
axios.interceptors.response.use(
(response) => {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const started = (response.config as any).metadata?.start || Date.now();
const dur = Date.now() - started;
let dataStr = '';
@ -92,12 +100,13 @@ axios.interceptors.response.use(
const size = dataStr?.length || 0;
const MAX_LOG_BODY = 2000;
const clip = (s: string) => (s && s.length > MAX_LOG_BODY ? `${s.slice(0, MAX_LOG_BODY)}…(+${s.length - MAX_LOG_BODY})` : s);
// eslint-disable-next-line no-console
console.log(`[axios <-] ${response.status} ${String(response.config.method || 'GET').toUpperCase()} ${response.config.url} ${dur}ms ~${size}B data=${clip(dataStr)}`);
return response;
},
(error) => {
const cfg = error?.config || {};
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const started = (cfg as any).metadata?.start || Date.now();
const dur = Date.now() - started;
const status = error?.response?.status;
@ -108,7 +117,7 @@ axios.interceptors.response.use(
} catch { /* ignore */ }
const MAX_LOG_BODY = 2000;
const clip = (s: string) => (s && s.length > MAX_LOG_BODY ? `${s.slice(0, MAX_LOG_BODY)}…(+${s.length - MAX_LOG_BODY})` : s);
// eslint-disable-next-line no-console
console.warn(`[axios ! ] ${status ?? 'ERR'} ${String(cfg.method || 'GET').toUpperCase()} ${cfg.url} ${dur}ms data=${dataStr ? clip(dataStr) : (error?.message || 'error')}`);
return Promise.reject(error);
}
@ -122,7 +131,8 @@ function buildHeaders() {
} as Record<string, string>;
}
function normalizeMatch(m: any) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function normalizeMatch(m: Record<string, any>) {
return {
id: m.id,
utcDate: m.utcDate,
@ -135,7 +145,8 @@ function normalizeMatch(m: any) {
score: m.score,
competition: m.competition?.name || 'UEFA Champions League',
venue: m.venue,
referees: m.referees?.map((r: any) => r.name).filter(Boolean) || [],
// eslint-disable-next-line @typescript-eslint/no-explicit-any
referees: m.referees?.map((r: Record<string, any>) => r.name).filter(Boolean) || [],
};
}
@ -160,9 +171,10 @@ app.get('/api/live', async (_req: Request, res: Response) => {
const { data } = await axios.get(url, { headers: buildHeaders(), params: { status: 'LIVE' } });
const matches = (data.matches || []).map(normalizeMatch);
res.json({ count: matches.length, matches, fetchedAt: new Date().toISOString() });
} catch (err: any) {
const status = err?.response?.status || 500;
res.status(status).json({ error: 'Failed to fetch live matches', details: err?.response?.data || err?.message });
} catch (err: unknown) {
const axErr = err as { response?: { status?: number; data?: unknown }; message?: string };
const status = axErr?.response?.status || 500;
res.status(status).json({ error: 'Failed to fetch live matches', details: axErr?.response?.data || axErr?.message });
}
});
@ -191,13 +203,14 @@ app.get('/api/matches', async (req: Request, res: Response) => {
});
const matches = (data.matches || []).map(normalizeMatch);
res.json({ count: matches.length, matches, fetchedAt: new Date().toISOString() });
} catch (err: any) {
const status = err?.response?.status || 500;
res.status(status).json({ error: 'Failed to fetch matches', details: err?.response?.data || err?.message });
} catch (err: unknown) {
const axErr = err as { response?: { status?: number; data?: unknown }; message?: string };
const status = axErr?.response?.status || 500;
res.status(status).json({ error: 'Failed to fetch matches', details: axErr?.response?.data || axErr?.message });
}
});
app.listen(PORT, () => {
// eslint-disable-next-line no-console
console.log(`[server] Listening on http://localhost:${PORT}`);
});

24
TS/champions_leauge_scores/src/App.tsx
View File

@ -27,7 +27,7 @@ type ApiResponse = {
fetchedAt: string;
};
function useFetchOnce<T>(fn: () => Promise<T>) {
function _useFetchOnce<T>(fn: () => Promise<T>) {
const [data, setData] = useState<T | null>(null);
const [error, setError] = useState<string | null>(null);
const [loading, setLoading] = useState<boolean>(true);
@ -41,8 +41,8 @@ function useFetchOnce<T>(fn: () => Promise<T>) {
setData(result);
setError(null);
}
} catch (e: any) {
if (mounted) setError(e?.message || 'Failed to fetch');
} catch (e: unknown) {
if (mounted) setError(e instanceof Error ? e.message : 'Failed to fetch');
} finally {
if (mounted) setLoading(false);
}
@ -57,14 +57,13 @@ async function fetchJson<T>(url: string, init?: RequestInit): Promise<T> {
const res = await fetch(url, { cache: 'no-store', ...init });
if (!res.ok) {
const text = await res.text();
let body: any = null;
let body: unknown = null;
try { body = text ? JSON.parse(text) : null; } catch { /* noop */ }
const err: any = new Error(`HTTP ${res.status}`);
err.status = res.status;
err.body = body;
const err: { message: string; status: number; body: unknown; waitSec?: number } = { message: `HTTP ${res.status}`, status: res.status, body };
// Try to derive wait seconds for 429 from body.details.message like: "You reached your request limit. Wait 56 seconds."
if (res.status === 429) {
const msg: string | undefined = body?.details?.message || body?.message || body?.error;
const details = body as Record<string, unknown> | null;
const msg: string | undefined = (details?.message as string) || (details?.error as string) || (details?.details as Record<string, unknown>)?.message as string | undefined;
const m = msg ? msg.match(/(\d+)\s*seconds?/) : null;
if (m) err.waitSec = Number(m[1]);
}
@ -143,18 +142,19 @@ function useBackoffUntilSuccess<T>(fn: () => Promise<T>, opts?: { baseDelaySec?:
clearTimers();
setData(result);
setError(null);
} catch (e: any) {
} catch (e: unknown) {
if (!mounted) return;
const httpErr = e as { status?: number; waitSec?: number; message?: string };
// 429: backoff and retry
if (e?.status === 429) {
const suggested = Number(e?.waitSec) || delayRef.current || base;
if (httpErr?.status === 429) {
const suggested = Number(httpErr?.waitSec) || delayRef.current || base;
const next = Math.min(max, Math.max(base, suggested));
delayRef.current = Math.min(max, Math.ceil(next * factor));
setError(`Rate limited. Retrying in ${next}s...`);
scheduleRetry(next);
return;
}
setError(e?.message || 'Failed to fetch');
setError(httpErr?.message || 'Failed to fetch');
} finally {
inFlightRef.current = false;
if (mounted) setLoading(false);

2
TS/two-inputs/src/app/app.component.ts
View File

@ -125,7 +125,7 @@ export class AppComponent {
// Iterate through possible values of n1, which must be multiples of x, at least y, and not more than z
for (let n1 = y; n1 <= ml - y && n1 <= z; n1 += x) {
let n2 = ml - n1;
const n2 = ml - n1;
// Ensure n2 is also a multiple of x, n2 >= y, and n2 <= z
if (n2 % x === 0 && n2 >= y && n2 <= z) {
results.push([n1, n2]);

46
articles/server_c.c
View File

@ -123,11 +123,28 @@ static size_t json_escaped_len(const char* s) {
}
static inline char* json_append_escaped(char* w, char c) {
if (c == '"' || c == '\\') { *w++ = '\\'; *w++ = c; return w; }
if (c == '\n') { *w++ = '\\'; *w++ = 'n'; return w; }
if (c == '\r') { *w++ = '\\'; *w++ = 'r'; return w; }
if (c == '\t') { *w++ = '\\'; *w++ = 't'; return w; }
*w++ = c; return w;
if (c == '"' || c == '\\') {
*w++ = '\\';
*w++ = c;
return w;
}
if (c == '\n') {
*w++ = '\\';
*w++ = 'n';
return w;
}
if (c == '\r') {
*w++ = '\\';
*w++ = 'r';
return w;
}
if (c == '\t') {
*w++ = '\\';
*w++ = 't';
return w;
}
*w++ = c;
return w;
}
static void json_escape_into(char* out, const char* s) {
@ -164,12 +181,23 @@ static inline char json_unescape_char(char c) {
}
static void parse_json_string_core(const char* v, char* out, size_t* w, const char** after_end) {
bool esc = false; const char* p = v;
bool esc = false;
const char* p = v;
for (; *p; ++p) {
char c = *p;
if (esc) { out[(*w)++] = json_unescape_char(c); esc = false; continue; }
if (c == '\\') { esc = true; continue; }
if (c == '"') { *after_end = p + 1; break; }
if (esc) {
out[(*w)++] = json_unescape_char(c);
esc = false;
continue;
}
if (c == '\\') {
esc = true;
continue;
}
if (c == '"') {
*after_end = p + 1;
break;
}
out[(*w)++] = c;
}
if (!*after_end) *after_end = p;

29
eslint.config.mjs Normal file
View File

@ -0,0 +1,29 @@
// @ts-check
import eslint from "@eslint/js";
import tseslint from "typescript-eslint";
export default tseslint.config(
eslint.configs.recommended,
...tseslint.configs.recommended,
{
files: ["TS/**/*.{ts,tsx}"],
},
{
rules: {
"@typescript-eslint/no-unused-vars": [
"error",
{ argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
],
},
},
{
ignores: [
"**/node_modules/**",
"**/dist/**",
"**/build/**",
"**/*.d.ts",
"**/*.config.ts",
"**/*.config.js",
],
},
);

1473
package-lock.json generated Normal file
View File

File diff suppressed because it is too large Load Diff

8
package.json Normal file
View File

@ -0,0 +1,8 @@
{
"devDependencies": {
"@eslint/js": "^9.39.2",
"@types/node": "^25.3.0",
"eslint": "^9.39.2",
"typescript-eslint": "^8.56.0"
}
}

21
setup.sh
View File

@ -11,4 +11,23 @@ printf 'Configuring git hooks path...\n'
git config core.hooksPath linux_configuration/.githooks
printf ' ✓ core.hooksPath set to linux_configuration/.githooks\n'
printf 'Setup complete.\n'
# Check for C/C++ and shell lint tools (used by pre-commit hooks)
MISSING=()
for cmd in clang-format cppcheck flawfinder shellcheck node npx; do
command -v "$cmd" >/dev/null 2>&1 || MISSING+=("$cmd")
done
if [[ ${#MISSING[@]} -gt 0 ]]; then
printf '\n⚠ Missing tools for pre-commit hooks: %s\n' "${MISSING[*]}"
if command -v pacman >/dev/null 2>&1; then
printf ' Install with: sudo pacman -S --needed %s\n' "${MISSING[*]}"
elif command -v apt-get >/dev/null 2>&1; then
printf ' Install with: sudo apt-get install %s\n' "${MISSING[*]}"
else
printf ' Please install: %s\n' "${MISSING[*]}"
fi
else
printf ' ✓ All lint tools available\n'
fi
printf '\nSetup complete.\n'