https://github.com/s0urcedev/additionalfunctions
Additional functions
https://github.com/s0urcedev/additionalfunctions
algorithms cpp csharp education fundamentals go golang javascript js olympiad python python3
Last synced: about 1 year ago
JSON representation
Additional functions
- Host: GitHub
- URL: https://github.com/s0urcedev/additionalfunctions
- Owner: s0urcedev
- Created: 2022-02-09T10:24:40.000Z (over 4 years ago)
- Default Branch: main
- Last Pushed: 2025-02-08T23:01:26.000Z (over 1 year ago)
- Last Synced: 2025-04-12T19:17:18.004Z (about 1 year ago)
- Topics: algorithms, cpp, csharp, education, fundamentals, go, golang, javascript, js, olympiad, python, python3
- Language: C#
- Homepage: https://additional-functions.s0urce.dev
- Size: 563 KB
- Stars: 2
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# AdditionalFunctions
## Page / Сторінка / Страница
[github.com/s0urcedev/AdditionalFunctions](https://github.com/s0urcedev/AdditionalFunctions)
[s0urcedev.github.io/AdditionalFunctions](https://s0urcedev.github.io/AdditionalFunctions/)
## Packages / Пакети / Пакеты
### Links / Посилання / Ссылки
`Python`: [pypi.org/project/additional-functions](https://pypi.org/project/additional-functions/)
`JavaScript`: [npmjs.com/package/additional-functions](https://www.npmjs.com/package/additional-functions)
### Installing / Встановлення / Установка
`Python`:
```
$ pip install additional_functions
```
`JavaScript`:
```
$ npm install additional-functions
```
### Importing / Підключення / Подключение
`Python`:
```python
import additional_functions as main
from additional_functions import sortings
from additional_functions import factorials
from additional_functions import combinatorics
from additional_functions import roman_arabic_numerals
from additional_functions import arithmetic
from additional_functions.progressions import ArithmeticProgression
from additional_functions.progressions import GeometricProgression
from additional_functions.progressions import HarmonicProgression
from additional_functions.linked_list import LinkedList
from additional_functions.binary_search_tree import Tree
from additional_functions.hash_table import HashTable
from additional_functions import subarrays
```
`JavaScript`:
```js
let main = require('additional_functions');
let sortings = require('additional_functions/sortings');
let factorials = require('additional_functions/factorials');
let combinatorics = require('additional_functions/combinatorics');
let romanArabicNumerals = require('additional_functions/roman-arabic-numerals');
let arithmetic = require('additional_functions/arithmetic');
let ArithmeticProgression = require('additional-functions/progressions').ArithmeticProgression;
let GeometricProgression = require('additional-functions/progressions').GeometricProgression;
let HarmonicProgression = require('additional-functions/progressions').HarmonicProgression;
let LinkedList = require('additional-functions/linked-list').LinkedList;
let Tree = require('additional-functions/binary-search-tree').Tree;
let HashTable = require('additional-functions/hash-table').HashTable;
let subarrays = require('additional_functions/subarrays');
```
## Introduction / Вступ / Вступление
***English:*** I have some experience in programming olympics. I think that it could help other people with preparing to competitions and get some working algorithms. There you will find algorithms on Python, JavaScript, Go, C++ and C#, but you also can easily rewrite then on your language. I'ill give link to all ideas and text descriptions of algorithms. I believe that this repo could help you :)
***Українська:*** У мене є деякий досвід в олімпіадах з програмування. Я вважаю, що він може допомогти іншим людям підготуватися до змагань та отримати деякі робочі алгоритми. Тут ти знайдеш алгоритми на Python, JavaScript, Go, C++ та C#, але ти завжди можешь з легкістю переписати їх на свою мову. Я додам посилання на усі ідеї та текстові описи алгоритмів. Я вірю, що цей репозиторій допоможе тобі :)
***Русский:*** У меня есть некоторый опыт в олимпиадах по программированию. Я считаю, что он моджет помочь другим людям подготовится к соревнованиям и получить некоторые рабочие алгоритмы. Тут ты найдёшь алгоритмы на Python, JavaScript, Go, C++ и C#, но ты всегда можешь с лёгкостью переписать их на свой язык. Я добавлю ссылки на все идеи и текстовые описания алгоритмов. Я верю что этот репозиторий поможет тебе :)
## Sorting / Сортування / Сотрировка
### Packages / Пакети / Пакеты
`Python`:
```python
sortings.bubble(a)
sortings.selection(a)
sortings.insertion(a)
sortings.merge(a)
sortings.quick(a)
```
`JavaScript`:
```js
sortings.bubble(a);
sortings.selection(a);
sortings.insertion(a);
sortings.merge(a);
sortings.quick(a);
```
***English:*** Continuing topix about array I'll tell you about sortring arrays. For better understanding I recomend you to read about [algorythm's time complexity](https://en.wikipedia.org/wiki/Time_complexity). In this part you could know most ways how you can sort your array. Understand pluses and minuses of all algorythms and get cases when and where you might use them.
***Українська:*** Продовженням теми про масиви я розповім тобі про сортування масивів. Для більш гарного розуміння я рекомендую тобі почитати про [часову складність алгоритму](https://uk.wikipedia.org/wiki/Часова_складність). У цій частині ти зможеш дізнатися про більшість способів, як ти можешь відсортувати твій масив. Зрозуміти плюси на мінуси усіх алгоритмів та отримати ситуаціх коли ти маешь їх використовувати.
***Русский:*** Продолжением темы про массивы я расскажу тебя про сортировку массивов. Для лучшего понимания я рекомендую тебе почитать про [временную сложность алгоритма](https://ru.wikipedia.org/wiki/Временная_сложность_алгоритма). В этой части ты сможеш узнать про большинство способов, как ты можешь отсортировать твой массив. Понять плюсы и минусы всех алгоритмов и получить ситуации когда ты должен их использовать.
### Bubble sort / Бульбашкове сортування / Пузырьковая сортировка
**Time complexity / Часова складність / Временная сложность :** *O(n2)*.
**Pluses / Плюси / Плюсы :** *Easy and short / Простий та короткий / Простой и которкий*
**Minuses / Мінуси / Минусы :** *Slow / Повільний / Медленний*
***Wikipedia:*** *[Bubble sort](https://en.wikipedia.org/wiki/Bubble_sort)*
***Вікіпедія:*** *[Бульбашкове сортування](https://uk.wikipedia.org/wiki/Сортування_бульбашкою)*
***Википедия:*** *[Пузырьковая сортировка](https://ru.wikipedia.org/wiki/Сортировка_пузырьком)*
`Python`:
```python
k = 0
while k < len(a) - 1:
k = 0
for j in range(0, len(a)-1):
if a[j] > a[j + 1]:
a[j], a[j + 1] = a[j + 1], a[j]
else:
k += 1
```
***File:*** *[bubble-sort.py](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/bubble-sort.py)*
`JavaScript`:
```js
let k = 0;
while(k < a.length - 1){
k = 0;
for(let j = 0; j < a.length - 1; j ++){
if(a[j] > a[j + 1]){
a[j] = a[j] + a[j + 1];
a[j+1] = a[j] - a[j + 1];
a[j] = a[j] - a[j + 1];
}
else{
k ++;
}
}
}
```
***File:*** *[bubble-sort.js](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/bubble-sort.js)*
`Go`:
```go
k := 0
for k < len(a)-1 {
k = 0
for j := 0; j < len(a)-1; j++ {
if a[j] > a[j+1] {
a[j], a[j+1] = a[j+1], a[j]
} else {
k++
}
}
}
```
***File:*** *[bubble-sort.go](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/bubble-sort.go)*
`C++`:
```cpp
int k = 0;
while(k < len - 1){
k = 0;
for(int j = 0; j < len - 1; j ++){
if(a[j] > a[j + 1]){
a[j] = a[j] + a[j + 1];
a[j + 1] = a[j] - a[j + 1];
a[j] = a[j] - a[j + 1];
}
else{
k ++;
}
}
}
```
***File:*** *[bubble-sort.cpp](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/bubble-sort.cpp)*
`C#`:
```cs
int k = 0;
while(k < a.Length - 1)
{
k = 0;
for(int j = 0; j < a.Length - 1; j ++)
{
if(a[j] > a[j + 1])
{
a[j] = a[j] + a[j + 1];
a[j + 1] = a[j] - a[j + 1];
a[j] = a[j] - a[j + 1];
}
else
{
k ++;
}
}
}
```
***File:*** *[bubble-sort.cs](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/bubble-sort.cs)*
### Selection sort / Сортування вибором / Сортировка выбором
**Time complexity / Часова складність / Временная сложность :** *O(n2)*.
**Pluses / Плюси / Плюсы :** *Easy and short / Простий та короткий / Простой и которкий*
**Minuses / Мінуси / Минусы :** *Slow / Повільний / Медленний*
***Wikipedia:*** *[Selection sort](https://en.wikipedia.org/wiki/Selection_sort)*
***Вікіпедія:*** *[Сортування вибором](https://uk.wikipedia.org/wiki/Сортування_вибором)*
***Википедия:*** *[Сортировка выбором](https://ru.wikipedia.org/wiki/Сортировка_выбором)*
`Python`:
```python
for i in range(0, len(a) - 1):
imin = i
for j in range(i + 1, len(a)):
if a[j] < a[imin]:
imin = j
if imin != i:
a[i], a[imin] = a[imin], a[i]
```
***File:*** *[selection-sort.py](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/selection-sort.py)*
`JavaScript`:
```js
for(let i = 0; i < a.length - 1; i ++){
let imin = i;
for(let j = i + 1; j < a.length; j ++){
if(a[j] < a[imin]){
imin = j;
}
}
if(imin != i){
a[i] = a[i] + a[imin];
a[imin] = a[i] - a[imin];
a[i] = a[i] - a[imin];
}
}
```
***File:*** *[selection-sort.js](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/selection-sort.js)*
`Go`:
```go
for i := 0; i < len(a)-1; i++ {
imin := i
for j := i + 1; j < len(a); j++ {
if a[j] < a[imin] {
imin = j
}
}
if imin != i {
a[i], a[imin] = a[imin], a[i]
}
}
```
***File:*** *[selection-sort.go](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/selection-sort.go)*
`C++`:
```cpp
for(int i = 0; i < len - 1; i ++){
int imin = i;
for(int j = i + 1; j < len; j ++){
if(a[j] < a[imin]){
imin = j;
}
}
if(imin != i){
a[i] = a[i] + a[imin];
a[imin] = a[i] - a[imin];
a[i] = a[i] - a[imin];
}
}
```
***File:*** *[selection-sort.cpp](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/selection-sort.cpp)*
`C#`:
```cs
for(int i = 0; i < a.Length; i ++)
{
int imin = i;
for(int j = i + 1; j < a.Length; j ++)
{
if(a[j] < a[imin])
{
imin = j;
}
}
if(imin != i)
{
a[i] = a[i] + a[imin];
a[imin] = a[i] - a[imin];
a[i] = a[i] - a[imin];
}
}
```
***File:*** *[selection-sort.cs](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/selection-sort.cs)*
### Insertion sort / Сортування включенням / Сортировка вставками
**Time complexity / Часова складність / Временная сложность :** *O(n2)*.
**Pluses / Плюси / Плюсы :** *Easy and short / Простий та короткий / Простой и которкий*
**Minuses / Мінуси / Минусы :** *Slow / Повільний / Медленний*
***Wikipedia:*** *[Insertion_Sort](https://en.wikipedia.org/wiki/Insertion_sort)*
***Вікіпедія:*** *[Сортування включенням](https://uk.wikipedia.org/wiki/Сортування_включенням)*
***Википедия:*** *[Сортировка вставками](https://ru.wikipedia.org/wiki/Сортировка_вставками)*
`Python`:
```python
for j in range(1, len(a)):
key = a[j]
i = j - 1
while i >= 0 and a[i] > key:
a[i + 1] = a[i]
i -= 1
a[i + 1] = key
```
***File:*** *[insertion-sort.py](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/insertion-sort.py)*
`JavaScript`:
```js
for(let j = 1; j < a.length; j ++){
key = a[j];
i = j - 1;
while(i >= 0 && a[i] > key){
a[i + 1] = a[i];
i --;
}
a[i + 1] = key;
}
```
***File:*** *[insertion-sort.js](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/insertion-sort.js)*
`Go`:
```go
for j := 1; j < len(a); j++ {
key := a[j]
i := j - 1
for i >= 0 && a[i] > key {
a[i+1] = a[i]
i--
}
a[i+1] = key
}
```
***File:*** *[insertion-sort.go](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/insertion-sort.go)*
`C++`:
```cpp
for(int j = 1; j < len; j ++){
int key = a[j];
int i = j - 1;
while (i >= 0 && a[i] > key){
a[i + 1] = a[i];
i --;
}
a[i + 1] = key;
}
```
***File:*** *[insertion-sort.cpp](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/insertion-sort.cpp)*
`C#`:
```cs
for(int j = 0; j < a.Length; j ++)
{
int key = a[j];
int i = j - 1;
while (i >= 0 && a[i] > key)
{
a[i + 1] = a[i];
i --;
}
a[i + 1] = key;
}
```
***File:*** *[insertion-sort.cs](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/insertion-sort.cs)*
### Quick sort / Швидке сортування / Быстрая сортировка
**Time complexity / Часова складність / Временная сложность :** *O(n log n)*.
**Pluses / Плюси / Плюсы :** *Fast and not long / Швидка та не довга / Быстрая и не длинная*
**Minuses / Мінуси / Минусы :** *Unfixed time comlexity (the worst case is O(n2)) / Нефіксована часова скалдність (найгірший випадок O(n2)) / Нефиксированая временная сложность (наихудший случай O(n2))*
***Wikipedia:*** *[Quick_Sort](https://en.wikipedia.org/wiki/Quicksort)*
***Вікіпедія:*** *[Швидке сортування](https://uk.wikipedia.org/wiki/Швидке_сортування)*
***Википедия:*** *[Быстрая сортировка](https://ru.wikipedia.org/wiki/Быстрая_сортировка)*
`Python`:
```python
def sort(array, b, e):
l = b
r = e
p = array[int((l + r) / 2)]
while l <= r:
while array[l] < p:
l += 1
while array[r] > p:
r -= 1
if l <= r:
if l < r:
array[l], array[r] = array[r], array[l]
l += 1
r -= 1
if b < r:
sort(array, b, r)
if e > l:
sort(array, l, e)
sort(a, 0, len(a) - 1)
```
***File:*** *[quick-sort.py](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/quick-sort.py)*
`JavaScript`:
```js
function sort(array, m){
let mass = [];
for(let i = 0; i < m; i ++){
mass.push(array[i]);
}
if(m <= 1){
array[0] = mass[0];
}
else{
let l = [];
let r = [];
for(let i = 0; i < m; i ++){
if(i < Math.floor(m / 2)){
l.push(mass[i]);
}
else{
r.push(mass[i]);
}
}
sort(l, l.length);
sort(r, r.length);
let h = 0;
let f = 0;
let c = [];
while(h < l.length && f < r.length){
if(l[h] < r[f]){
c.push(l[h]);
h += 1;
}
else{
c.push(r[f]);
f += 1;
}
}
while(h < l.length){
c.push(l[h]);
h += 1;
}
while(f < r.length){
c.push(r[f]);
f += 1;
}
for(let i = 0; i < m; i++){
array[i] = c[i];
}
}
}
sort(a, 0, a.length - 1);
```
***File:*** *[quick-sort.js](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/quick-sort.js)*
`Go`:
```go
func Sort(array []int, b int, e int) {
l := b
r := e
p := array[int((l+r)/2)]
for l <= r {
for array[l] < p {
l++
}
for array[r] > p {
r--
}
if l <= r {
if l < r {
array[l], array[r] = array[r], array[l]
}
}
l++
r--
}
if b < r {
Sort(array, b, r)
}
if e > l {
Sort(array, l, e)
}
}
Sort(a, 0, len(a)-1)
```
***File:*** *[quick-sort.go](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/quick-sort.go)*
`C++`:
```cpp
void sort(int *array, int b, int e){
int l = b;
int r = e;
int p = array[(l + r) / 2];
while(l <= r){
while(array[l] < p){
l ++;
}
while(array[r] > p){
r --;
}
if(l <= r){
if(l < r){
array[l] = array[l] + array[r];
array[r] = array[l] - array[r];
array[l] = array[l] - array[r];
}
l ++;
r --;
}
}
if(b < r){
sort(array, b, r);
}
if(e > l){
sort(array, l, e);
}
}
sort(a, 0, len - 1);
```
***File:*** *[quick-sort.cpp](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/quick-sort.cpp)*
`C#`:
```cs
void Sort(ref int[] array, int b, int e)
{
int l = b;
int r = e;
int p = array[(l + r) / 2];
while(l <= r)
{
while(array[l] < p)
{
l ++;
}
while(array[r] > p)
{
r --;
}
if(l <= r)
{
if(l < r)
{
array[l] = array[l] + array[r];
array[r] = array[l] - array[r];
array[l] = array[l] - array[r];
}
l ++;
r --;
}
}
if(b < r)
{
Sort(ref array, b, r);
}
if(e > l)
{
Sort(ref array, l, e);
}
}
Sort(ref a, 0, a.Length - 1);
```
***File:*** *[quick-sort.cs](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/quick-sort.cs)*
### Merge sort / Сортування злиттям / Сортировка слиянием
**Time complexity / Часова складність / Временная сложность :** *O(n log n)*.
**Pluses / Плюси / Плюсы :** *Fast and stable / Швидка та стабільна / Быстрая и стабильная*
**Minuses / Мінуси / Минусы :** *Difficult in coding and needs additional memory / Важка в програмуванні та потрибує додаткової пам'яті / Сложная в прогаммировании и требует дополнительной памяти*
***Wikipedia:*** *[Merge sort](https://en.wikipedia.org/wiki/Merge_sort)*
***Вікіпедія:*** *[Сортування злиттям](https://uk.wikipedia.org/wiki/Сортування_злиттям)*
***Википедия:*** *[Сортировка слиянием](https://ru.wikipedia.org/wiki/Сортировка_слиянием)*
`Python`:
```python
def sort(array, m):
mass = []
for i in range(0, m):
mass.append(array[i])
if m <= 1:
array[0] = mass[0]
else:
l = []
r = []
for i in range(0, m):
if i < int(m / 2):
l.append(mass[i])
else:
r.append(mass[i])
sort(l, len(l))
sort(r, len(r))
h = 0
f = 0
c = []
while h < len(l) and f < len(r):
if l[h] < r[f]:
c.append(l[h])
h += 1
else:
c.append(r[f])
f += 1
while h < len(l):
c.append(l[h])
h += 1
while f < len(r):
c.append(r[f])
f += 1
for i in range(0, m):
array[i] = c[i]
sort(a, len(a))
```
***File:*** *[merge-sort.py](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/merge-sort.py)*
`JavaScript`:
```js
function sort(array, m){
let mass = [];
for(let i = 0; i < m; i ++){
mass.push(array[i]);
}
if(m <= 1){
array[0] = mass[0];
}
else{
let l = [];
let r = [];
for(let i = 0; i < m; i ++){
if(i < Math.floor(m/2)){
l.push(mass[i]);
}
else{
r.push(mass[i]);
}
}
sort(l, l.length);
sort(r, r.length);
let h = 0;
let f = 0;
let c = [];
while(h < l.length && f < r.length){
if(l[h] < r[f]){
c.push(l[h]);
h += 1;
}
else{
c.push(r[f]);
f += 1;
}
}
while(h < l.length){
c.push(l[h]);
h += 1;
}
while(f < r.length){
c.push(r[f]);
f += 1;
}
for(let i = 0; i < m; i++){
array[i] = c[i];
}
}
}
sort(a, a.length);
```
***File:*** *[merge-sort.js](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/merge-sort.js)*
`Go`:
```go
func Sort(array []int, m int) {
mass := []int{}
for i := 0; i < m; i++ {
mass = append(mass, array[i])
}
if m <= 1 {
array[0] = mass[0]
} else {
var l []int
var r []int
for i := 0; i < m; i++ {
if i < m/2 {
l = append(l, mass[i])
} else {
r = append(r, mass[i])
}
}
Sort(l, m/2)
Sort(r, m-(m/2))
h := 0
f := 0
var c []int
for h < m/2 && f < m-(m/2) {
if l[h] < r[f] {
c = append(c, l[h])
h++
} else {
c = append(c, r[f])
f++
}
}
for h < m/2 {
c = append(c, l[h])
h++
}
for f < m-(m/2) {
c = append(c, r[f])
f++
}
for i := 0; i < m; i++ {
array[i] = c[i]
}
}
}
Sort(a, len(a))
```
***File:*** *[merge-sort.go](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/merge-sort.go)*
`C++`:
```cpp
void sort(int *array, int m){
int mass[m];
for(int i = 0; i < m; i ++){
mass[i] = array[i];
}
if(m <= 1){
array[0] = mass[0];
}
else{
int L[m / 2], R[m - (m / 2)];
for(int i = 0; i < m; i ++){
if(i < m / 2) L[i] = mass[i];
else R[i - (m / 2)] = mass[i];
}
sort(L, m / 2);
sort(R, m - (m / 2));
int h = 0, f = 0, k = 0;
int C[m];
while(h < m / 2 && f < m - (m / 2)){
if(L[h] < R[f]){
C[k] = L[h];
h ++;
}
else{
C[k] = R[f];
f ++;
}
k ++;
}
while(h < m / 2){
C[k] = L[h];
h ++;
k ++;
}
while(f < m - (m / 2)){
C[k] = R[f];
f ++;
k ++;
}
for(int i = 0; i < m; i ++){
array[i] = C[i];
}
}
}
sort(a, len);
```
***File:*** *[merge-sort.cpp](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/merge-sort.cpp)*
`C#`:
```cs
void Sort(ref int[] array, int m)
{
int[] mass = new int[m];
for(int i = 0; i < m; i ++)
{
mass[i] = array[i];
}
if(m <= 1)
{
array[0] = mass[0];
}
else
{
int[] L = new int[m / 2];
int[] R = new int[m - (m / 2)];
for(int i = 0; i < m; i ++)
{
if(i < m / 2) L[i] = mass[i];
else R[i - (m / 2)] = mass[i];
}
Sort(ref L, m / 2);
Sort(ref R, m - (m / 2));
int h = 0, f = 0, k = 0;
int[] C = new int[m];
while(h < m / 2 && f < m - (m / 2))
{
if(L[h] < R[f]){
C[k] = L[h];
h ++;
}
else{
C[k] = R[f];
f ++;
}
k ++;
}
while(h < m / 2)
{
C[k] = L[h];
h ++;
k ++;
}
while(f < m - (m / 2))
{
C[k] = R[f];
f ++;
k ++;
}
for(int i = 0; i < m; i ++)
{
array[i] = C[i];
}
}
}
Sort(ref a, a.Length);
```
***File:*** *[merge-sort.cs](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/merge-sort.cs)*
### Heap sort / Пірамідальне сортування / Пирамидальная сортировка
**Time complexity / Часова складність / Временная сложность :** *O(n log n)*.
**Pluses / Плюси / Плюсы :** *Fast, stable and don't need additional memory / Швидка, стабільна та не потребує додаткової пам'яті / Быстрая, стабильная и не требует дополнительной памяти*
**Minuses / Мінуси / Минусы :** *Difficult in coding / Важка в програмуванні / Сложная в прогаммировании*
***Wikipedia:*** *[Heap sort](https://en.wikipedia.org/wiki/Heapsort)*
***Вікіпедія:*** *[Пірамідальне сортування](https://uk.wikipedia.org/wiki/Пірамідальне_сортування)*
***Википедия:*** *[Пирамидальная сортировка](https://ru.wikipedia.org/wiki/Пирамидальная_сортировка)*
`Python`:
```python
def heapify(array, n, i):
largest = i
l = 2 * i + 1
r = 2 * i + 2
if l < n and array[i] < array[l]:
largest = l
if r < n and array[largest] < array[r]:
largest = r
if largest != i:
array[i], array[largest] = array[largest], array[i]
heapify(array, n, largest)
def sort(array):
for i in range(len(array) // 2, -1, -1):
heapify(array, len(array), i)
for j in range(len(array) - 1, 0, -1):
array[j], array[0] = array[0], array[j]
heapify(array, j, 0)
sort(a)
```
***File:*** *[heap-sort.py](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/heap-sort.py)*
`JavaScript`:
```js
function heapify(array, n, i){
let largest = i;
let l = 2 * i + 1;
let r = 2 * i + 2;
if(l < n && array[i] < array[l]){
largest = l;
}
if(r < n && array[largest] < array[r]){
largest = r;
}
if(largest != i){
array[i] = array[i] + array[largest];
array[largest] = array[i] - array[largest];
array[i] = array[i] - array[largest];
heapify(array, n, largest);
}
}
function sort(array){
for(let i = Math.floor(array.length / 2); i > -1; i --){
heapify(array, array.length, i);
}
for(let j = array.length - 1; j > 0; j --){
array[j] = array[j] + array[0];
array[0] = array[j] - array[0];
array[j] = array[j] - array[0];
heapify(array, j, 0);
}
}
sort(a);
```
***File:*** *[heap-sort.js](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/heap-sort.js)*
`Go`:
```go
func Heapify(array []int, n int, i int) {
largest := i
l := 2*i + 1
r := 2*i + 2
if l < n && array[i] < array[l] {
largest = l
}
if r < n && array[largest] < array[r] {
largest = r
}
if largest != i {
array[i], array[largest] = array[largest], array[i]
Heapify(array, n, largest)
}
}
func Sort(array []int) {
for i := int(math.Floor(float64(len(array) / 2))); i > -1; i-- {
Heapify(array, len(array), i)
}
for j := len(array) - 1; j > 0; j-- {
array[j], array[0] = array[0], array[j]
Heapify(array, j, 0)
}
}
Sort(a)
```
***File:*** *[heap-sort.go](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/heap-sort.go)*
`C++`:
```cpp
void heapify(int *array, int n, int i){
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if(l < n && array[i] < array[l]){
largest = l;
}
if(r < n && array[largest] < array[r]){
largest = r;
}
if(largest != i){
array[i] = array[i] + array[largest];
array[largest] = array[i] - array[largest];
array[i] = array[i] - array[largest];
heapify(array, n, largest);
}
}
void sort(int *array, int len){
for(int i = len / 2; i > -1; i --){
heapify(array, len, i);
}
for(int j = len - 1; j > 0; j --){
array[j] = array[j] + array[0];
array[0] = array[j] - array[0];
array[j] = array[j] - array[0];
heapify(array, j, 0);
}
}
sort(a, len);
```
***File:*** *[heap-sort.cpp](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/heap-sort.cpp)*
`C#`:
```cs
void Heapify(ref int[] array, int n, int i)
{
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if(l < n && array[i] < array[l])
{
largest = l;
}
if(r < n && array[largest] < array[r])
{
largest = r;
}
if(largest != i)
{
array[i] = array[i] + array[largest];
array[largest] = array[i] - array[largest];
array[i] = array[i] - array[largest];
Heapify(ref array, n, largest);
}
}
void Sort(ref int[] array)
{
for(int i = array.Length / 2; i > -1; i --)
{
Heapify(ref array, array.Length, i);
}
for(int j = array.Length - 1; j > 0; j --)
{
array[j] = array[j] + array[0];
array[0] = array[j] - array[0];
array[j] = array[j] - array[0];
Heapify(ref array, j, 0);
}
}
Sort(ref a);
```
***File:*** *[heap-sort.cs](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Sort/heap-sort.cs)*
## GCD | LCM / НСД | НСК / НОД | НОК
### Packages / Пакети / Пакеты
`Python`:
```python
main.gcd(a, b)
main.lcm(a, b)
```
`JavaScript`:
```js
main.gcd(a, b);
main.lcm(a, b);
```
### GCD / НСД / НОД
***Wikipedia:*** *[GCD](https://en.wikipedia.org/wiki/Greatest_common_divisor)*
***Вікіпедія:*** *[НСД](https://uk.wikipedia.org/wiki/Найбільший_спільний_дільник)*
***Википедия:*** *[НОД](https://ru.wikipedia.org/wiki/Наибольший_общий_делитель)*
`Python`:
```python
def gcd(a, b):
while a != 0 and b != 0:
if a > b:
a = a % b
else:
b = b % a
return a + b
```
`JavaScript`:
```js
function gcd(a, b){
while(a != 0 && b != 0){
if(a > b){
a = a % b;
}
else{
b = b % a;
}
}
return a + b;
}
```
`Go`:
```go
func GCD(a int, b int) int {
for a != 0 && b != 0 {
if a > b {
a = a % b
} else {
b = b % a
}
}
return a + b
}
```
`C++`:
```cpp
int gcd(int a, int b){
while(a != 0 && b != 0){
if(a > b){
a = a % b;
}
else{
b = b % a;
}
}
return a + b;
}
```
`C#`:
```cs
int GCD(int a, int b)
{
while(a != 0 && b != 0)
{
if(a > b)
{
a = a % b;
}
else
{
b = b % a;
}
}
return a + b;
}
```
### LCM / НСК / НОК
***Wikipedia:*** *[LCM](https://en.wikipedia.org/wiki/Least_common_multiple)*
***Вікіпедія:*** *[НСК](https://uk.wikipedia.org/wiki/Найменше_спільне_кратне)*
***Википедия:*** *[НОК](https://ru.wikipedia.org/wiki/Наименьшее_общее_кратное)*
`Python`:
```python
def gcd(a, b):
while a != 0 and b != 0:
if a > b:
a = a % b
else:
b = b % a
return a + b
def lcm(a, b):
return int((a * b) / gcd(a, b))
```
`JavaScript`:
```js
function gcd(a, b){
while(a != 0 && b != 0){
if(a > b){
a = a % b;
}
else{
b = b % a;
}
}
return a + b;
}
function lcm(a, b){
return Math.floor((a * b) / gcd(a, b));
}
```
`Go`:
```go
func GCD(a int, b int) int {
for a != 0 && b != 0 {
if a > b {
a = a % b
} else {
b = b % a
}
}
return a + b
}
func LCM(a int, b int) int {
return int((a * b) / GCD(a, b))
}
```
`C++`:
```cpp
int gcd(int a, int b){
while(a != 0 && b != 0){
if(a > b){
a = a % b;
}
else{
b = b % a;
}
}
return a + b;
}
int lcm(int a, int b){
return (a * b) / gcd(a, b);
}
```
`C#`:
```cs
int GCD(int a, int b)
{
while(a != 0 && b != 0)
{
if(a > b)
{
a = a % b;
}
else
{
b = b % a;
}
}
return a + b;
}
int LCM(int a, int b)
{
return (a * b) / GCD(a, b);
}
```
## Primes / Прості числа / Простые числа
### Packages / Пакети / Пакеты
`Python`:
```python
main.iprime(n)
main.n_primes(n)
main.prime_factors(n)
```
`JavaScript`:
```js
main.iprime(n);
main.nPrimes(n);
main.primeFactors(n);
```
### Is prime? / Чи просте число? / Простое ли число?
`Python`:
```python
def isprime(n):
result = []
d = 2
while d * d <= n:
if n % d == 0:
result.append(d)
n //= d
else:
d += 1
if n > 1:
result.append(n)
if len(result) > 1: return False
else: return True
```
`JavaScript`:
```js
function isPrime(n){
let result = [];
let d = 2;
while(d * d <= n){
if(n % d == 0){
result.push(d);
n = Math.floor(n / d);
}
else{
d ++;
}
}
if(n > 1){
result.push(n);
}
if(result.length > 1) return false;
else return true;
}
```
`Go`:
```go
func IsPrime(n int) bool {
result := []int{}
d := 2
for d*d <= n {
if n%d == 0 {
result = append(result, d)
n = int(n / d)
} else {
d++
}
}
if n > 1 {
result = append(result, n)
}
if len(result) > 1 {
return false
} else {
return true
}
}
```
`C++`:
```cpp
bool isprime(int n){
vector result;
int d = 2;
while(d * d <= n){
if(n % d == 0){
result.push_back(d);
n = n / d;
}
else{
d ++;
}
}
if(n > 1){
result.push_back(n);
}
if(result.size() > 1) return false;
else return true;
}
```
`C#`:
```cs
bool IsPrime(int n)
{
List result = new List(){};
int d = 2;
while(d * d <= n)
{
if(n % d == 0)
{
result.Add(d);
n = n / d;
}
else
{
d ++;
}
}
if(n > 1)
{
result.Add(n);
}
if(result.Count() > 1) return false;
else return true;
}
```
### Finding n prime numbers / Пошук n простих чисел / Поиск n простых чисел
`Python`:
```python
def n_primes(n):
result = []
i = 0
m = 1
while i < n:
m += 1
k = True
for j in result:
if m % j == 0:
k = False
break
if k:
result.append(m)
i += 1
return result
```
`JavaScript`:
```js
function nPrimes(n){
let result = [];
let i = 0;
let m = 1;
let k;
while(i < n){
m ++;
k = true;
for(j of result){
if(m % j == 0){
k = false;
break;
}
}
if(k){
result.push(m);
i ++;
}
}
return result;
}
```
`Go`:
```go
func NPrimes(n int) []int {
result := []int{}
i := 0
m := 1
var k bool
for i <= n {
m++
k = true
for _, j := range result {
if m%j == 0 {
k = false
break
}
}
if k {
result = append(result, m)
i++
}
}
return result
}
```
`C++`:
```cpp
vector n_primes(int a){
vector result;
int i = 0;
int m = 1;
bool k;
while(i < n){
m ++;
k = true;
for(auto j: result){
if(m % j == 0){
k = false;
break;
}
}
if(k){
result.push_back(m);
i ++;
}
}
return result;
}
```
`C#`:
```cs
List NPrimes(int n)
{
List result = new List(){};
int i = 0;
int m = 1;
bool k;
while(i < n)
{
m ++;
k = true;
foreach(int j in result)
{
if(m % j == 0){
k = false;
break;
}
}
if(k)
{
result.Add(m);
i ++;
}
}
return result;
}
```
### Finding prime factors of a number / Пошук простих множників числа / Поиск простых множителей числа
`Python`:
```python
def prime_factors(a):
result = []
d = 2
while d * d <= a:
if a % d == 0:
result.append(d)
a //= d
else:
d += 1
if a > 1:
result.append(a)
return result
```
`JavaScript`:
```js
function primeFactors(a){
let result = [];
let d = 2;
while(d * d <= a){
if(a % d == 0){
result.push(d);
a = Math.floor(a / d);
}
else{
d ++;
}
}
if(a > 1){
result.push(a);
}
return result;
}
```
`Go`:
```go
func PrimeFactors(a int) []int {
result := []int{}
d := 2
for d*d <= a {
if a%d == 0 {
result = append(result, d)
a = int(a / d)
} else {
d++
}
}
if a > 1 {
result = append(result, a)
}
return result
}
```
`C++`:
```cpp
vector prime_factors(int a){
vector result;
int d = 2;
while(d * d <= a){
if(a % d == 0){
result.push_back(d);
a = a / d;
}
else{
d ++;
}
}
if(a > 1){
result.push_back(a);
}
return result;
}
```
`C#`:
```cs
List PrimeFactors(int a)
{
List result = new List(){};
int d = 2;
while(d * d <= a)
{
if(a % d == 0)
{
result.Add(d);
a = a / d;
}
else
{
d ++;
}
}
if(a > 1)
{
result.Add(a);
}
return result;
}
```
## Fibonacci number / Послідовність Фібоначчі / Числа Фибоначчи
### Packages / Пакети / Пакеты
`Python`:
```python
main.fibo(n)
```
`JavaScript`:
```js
main.fibo(n);
```
***Wikipedia:*** *[Fibonacci number](https://en.wikipedia.org/wiki/Fibonacci_number)*
***Вікіпедія:*** *[Послідовність Фібоначчі](https://uk.wikipedia.org/wiki/Послідовність_Фібоначчі)*
***Википедия:*** *[Числа Фибоначчи](https://ru.wikipedia.org/wiki/Числа_Фибоначчи)*
`Python`:
```python
def fibo(n):
if n <= 1:
return n
else:
return fibo(n - 1) + fibo(n - 2)
```
`JavaScript`:
```js
function fibo(n){
if(n <= 1){
return n;
}
else{
return fibo(n - 1) + fibo(n - 2);
}
}
```
`Go`:
```go
func Fibo(n int) int {
if n <= 1 {
return n
} else {
return Fibo(n-1) + Fibo(n-2)
}
}
```
`C++`:
```cpp
int fibo(int n){
if(n <= 1){
return n;
}
else{
return fibo(n - 1) + fibo(n - 2);
}
}
```
`C#`:
```cs
int Fibo(int n)
{
if(n <= 1)
{
return n;
}
else
{
return Fibo(n - 1) + Fibo(n - 2);
}
}
```
## Factorials / Факторіали / Факториалы
### Packages / Пакети / Пакеты
`Python`:
```python
factorials.factorial(n)
factorials.double_factorial(n)
factorials.subfactorial(n)
factorials.primorial(n)
factorials.p_primorial(n)
factorials.superfactorial(n)
factorials.superduperfactorial(n)
```
`JavaScript`:
```js
factorials.factorial(n);
factorials.doubleFactorial(n);
factorials.subfactorial(n);
factorials.primorial(n);
factorials.pPrimorial(n);
factorials.superfactorial(n);
factorials.superduperfactorial(n);
```
### Counting factorial / Підрахунок факторіалу / Вычисление факториала
***Wikipedia:*** *[Factorial](https://en.wikipedia.org/wiki/Factorial)*
***Вікіпедія:*** *[Факторіал](https://uk.wikipedia.org/wiki/Факторіал)*
***Википедия:*** *[Факториал](https://ru.wikipedia.org/wiki/Факториал)*
`Python`:
```python
def factorial(n):
result = 1
for m in range(1, n + 1):
result *= m;
return result
```
`Or`:
```python
def factorial(n):
if n == 0: return 1
else: return n * factorial(n - 1)
```
`JavaScript`:
```js
function factorial(n){
let result = 1;
for(let m = 1; m <= n; m ++){
result *= m;
}
return result;
}
```
`Or`:
```js
function factorial(n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
```
`Go`:
```go
func Factorial(n int) int {
result := 1
for m := 1; m <= n; m++ {
result *= m
}
return result
}
```
`Or`:
```go
func Factorial(n int) int {
if n == 0 {
return 1
} else {
return n * Factorial(n-1)
}
}
```
`C++`:
```cpp
int factorial(int n){
int result = 1;
for(int m = 1; m <= n; m ++){
result *= m;
}
return result;
}
```
`Or`:
```cpp
int factorial(int n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
```
`C#`:
```cs
int Factorial(int n)
{
int result = 1;
for(int m = 1; m <= n; m ++)
{
result *= m;
}
return result;
}
```
`Or`:
```cs
int Factorial(int n)
{
if(n == 0) return 1;
else return n * Factorial(n - 1);
}
```
### Counting double factorial / Підрахунок подвійного факторіалу / Вычисление двойного факториала
`Python`:
```python
def double_factorial(n):
if n <= 0: return 1
else: return n * double_factorial(n - 2)
```
`JavaScript`:
```js
function doubleFactorial(n){
if(n <= 0) return 1;
else return n * doubleFactorial(n - 2);
}
```
`Go`:
```go
func DoubleFactorial(n int) int {
if n <= 0 {
return 1
} else {
return n * DoubleFactorial(n-2)
}
}
```
`C++`:
```cpp
int double_factorial(int n){
if(n <= 0) return 1;
else return n * double_factorial(n - 2);
}
```
`C#`:
```cs
int DoubleFactorial(int n)
{
if(n <= 0) return 1;
else return n * DoubleFactorial(n - 2);
}
```
### Counting subfactorial / Підрахунок субфакторіалу / Вычисление субфакториала
***Wikipedia:*** *[Subfactorial](https://en.wiktionary.org/wiki/subfactorial)*
***Вікіпедія:*** *[Субфакторіал](https://uk.wikipedia.org/wiki/Субфакторіал)*
***Википедия:*** *[Субфакториал](https://ru.wikipedia.org/wiki/Субфакториал)*
`Python`:
```python
def factorial(n):
if n == 0: return 1
else: return n * factorial(n - 1)
def subfactorial(n):
result = 1
k = True
for m in range(1, n + 1):
if k:
result -= 1 / factorial(m)
k = False
else:
result += 1 / factorial(m)
k = True
return round(result * factorial(n))
```
`Or`:
```python
def factorial(n):
if n == 0: return 1
else: return n * factorial(n-1)
def subfactorial(n):
return round(factorial(n) / 2.718)
```
`JavaScript`:
```js
function factorial(n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
function subfactorial(n){
let result = 1;
let k = true;
for(let m = 1; m <= n; m ++){
if(k){
result -= 1 / factorial(m);
k = false;
}
else{
result += 1 / factorial(m);
k = true;
}
}
return Math.round(result * factorial(n));
}
```
`Or`:
```js
function factorial(n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
function subfactorial(n){
return Math.round(factorial(n) / 2.718);
}
```
`Go`:
```go
import "math"
func Factorial(n int) int {
if n == 0 {
return 1
} else {
return n * Factorial(n-1)
}
}
func Subfactorial(n int) int {
result := 1.0
k := true
for m := 1; m <= n; m++ {
if k {
result -= 1.0 / float64(Factorial(m))
k = false
} else {
result += 1.0 / float64(Factorial(m))
k = true
}
}
return int(math.Round(result * float64(Factorial(n))))
}
```
`Or`:
```go
import "math"
func Factorial(n int) int {
if n == 0 {
return 1
} else {
return n * Factorial(n-1)
}
}
func Subfactorial(n int) int {
return int(math.Round(float64(Factorial(n)) / 2.718))
}
```
`C++`:
```cpp
int factorial(int n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
int subfactorial(int n){
double result = 1;
bool k = true;
for(int m = 1; m <= n; m ++){
if(k){
result -= 1.0 / factorial(m);
k = false;
}
else{
result += 1.0 / factorial(m);
k = true;
}
}
return result * factorial(n);
}
```
`Or`:
```cpp
#include
int factorial(int n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
int subfactorial(int n){
return round(factorial(n) / 2.718);
}
```
`C#`:
```cs
int Factorial(int n)
{
if(n == 0) return 1;
else return n * Factorial(n - 1);
}
int SubFactorial(int n)
{
double result = 1;
bool k = true;
for(int m = 1; m <= n; m ++)
{
if(k)
{
result -= 1.0 / Factorial(m);
k = false;
}
else
{
result += 1.0 / Factorial(m);
k = true;
}
}
return result * Factorial(n);
}
```
`Or`:
```cs
int Factorial(int n)
{
if(n == 0) return 1;
else return n * Factorial(n - 1);
}
int SubFactorial(int n)
{
return Math.Round(Factorial(n) / 2.718);
}
```
### Counting primorial / Підрахунок пріморіалу / Вычисление примориала
***Wikipedia:*** *[Primorial](https://en.wikipedia.org/wiki/Primorial)*
***Вікіпедія:*** *[Прайморіал](https://uk.wikipedia.org/wiki/Прайморіал)*
***Википедия:*** *[Праймориал](https://ru.wikipedia.org/wiki/Праймориал)*
`Python`:
```python
def isprime(n):
result = []
d = 2
while d * d <= n:
if n % d == 0:
result.append(d)
n //= d
else:
d += 1
if n > 1:
result.append(n)
if len(result) > 1: return False
else: return True
def p(n):
result = []
i = 0
m = 1
while i < n:
m += 1
k = True
for j in result:
if m % j == 0:
k = False
break
if k:
result.append(m)
i += 1
return result[-1]
#primorial less than n
#пріморіал меньше n
#примориал меньше n
def primorial(n):
if n == 1: return 1
elif isprime(n): return n * primorial(n - 1)
else: return primorial(n - 1)
#primorial for first n primes
#пріморіал для перших n простих
#примориал первых n простых
def p_primorial(n):
return primorial(p(n))
```
`JavaScript`:
```js
function isprime(n){
let result = [];
let d = 2;
while(d * d <= n){
if(n % d == 0){
result.push(d);
n = Math.floor(n / d);
}
else{
d ++;
}
}
if(n > 1){
result.push(n);
}
if(result.length > 1) return false;
else return true;
}
function p(n){
let result = [];
let i = 0;
let m = 1;
let k;
while(i < n){
m ++;
k = true;
for(j of result){
if(m % j == 0){
k = false;
break;
}
}
if(k){
result.push(m);
i ++;
}
}
return result[result.length - 1];
}
//primorial less than n
//пріморіал меньше n
//примориал меньше n
function primorial(n){
if(n == 1) return 1;
else if(isprime(n)) return n * primorial(n - 1);
else return primorial(n - 1);
}
//primorial for first n primes
//пріморіал для перших n простих
//примориал первых n простых
function pPrimorial(n){
return primorial(p(n));
}
```
`Go`:
```go
func IsPrime(n int) bool {
result := []int{}
d := 2
for d*d <= n {
if n%d == 0 {
result = append(result, d)
n = int(n / d)
} else {
d++
}
}
if n > 1 {
result = append(result, n)
}
if len(result) > 1 {
return false
} else {
return true
}
}
func P(n int) int {
result := []int{}
i := 0
m := 1
var k bool
for i < n {
m++
k = true
for _, j := range result {
if m%j == 0 {
k = false
break
}
}
if k {
result = append(result, m)
i++
}
}
return result[len(result)-1]
}
//primorial less than n
//пріморіал меньше n
//примориал меньше n
func Primorial(n int) int {
if n == 1 {
return 1
} else if IsPrime(n) {
return n * Primorial(n-1)
} else {
return Primorial(n - 1)
}
}
//primorial for first n primes
//пріморіал для перших n простих
//примориал первых n простых
func PPrimorial(n int) int {
return Primorial(P(n))
}
```
`C++`:
```cpp
bool isprime(int n){
vector result;
int d = 2;
while(d * d <= n){
if(n % d == 0){
result.push_back(d);
n = n / d;
}
else{
d ++;
}
}
if(n > 1){
result.push_back(n);
}
if(result.size() > 1) return false;
else return true;
}
int p(int n){
vector result;
int i = 0;
int m = 1;
bool k;
while(i < n){
m ++;
k = true;
for(auto j: result){
if(m % j == 0){
k = false;
break;
}
}
if(k){
result.push_back(m);
i ++;
}
}
return result[result.size() - 1];
}
//primorial less than n
//пріморіал меньше n
//примориал меньше n
int primorial(int n){
if(n == 1) return 1;
else if(isprime(n)) return n * primorial(n - 1);
else return primorial(n - 1);
}
//primorial for first n primes
//пріморіал для перших n простих
//примориал первых n простых
int p_primorial(int n){
return primorial(p(n));
}
```
`C#`:
```cs
bool IsPrime(int n)
{
List result = new List(){};
int d = 2;
while(d * d <= n)
{
if(n % d == 0)
{
result.Add(d);
n = n / d;
}
else
{
d ++;
}
}
if(n > 1)
{
result.Add(n);
}
if(result.Count() > 1) return false;
else return true;
}
int P(int n)
{
List result = new List(){};
int i = 0;
int m = 1;
bool k;
while(i < n)
{
m ++;
k = true;
for(auto j: result)
{
if(m % j == 0)
{
k = false;
break;
}
}
if(k)
{
result.Add(m);
i ++;
}
}
return result[^1];
}
//primorial less than n
//пріморіал меньше n
//примориал меньше n
int Primorial(int n)
{
if(n == 1) return 1;
else if(IsPrime(n)) return n * Primorial(n - 1);
else return Primorial(n - 1);
}
//primorial for first n primes
//пріморіал для перших n простих
//примориал первых n простых
int PPrimorial(int n)
{
return Primorial(P(n));
}
```
### Counting superfactorial / Підрахунок суперфакторіалу / Вычисление суперфакториала
`Python`:
```python
def factorial(n):
if n == 0: return 1
else: return n * factorial(n - 1)
def superfactorial(n):
if n == 0: return 1
else: return factorial(n) * superfactorial(n - 1)
```
`JavaScript`:
```js
function factorial(n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
function superfactorial(n){
if(n == 0) return 1;
else return factorial(n) * superfactorial(n - 1);
}
```
`Go`:
```go
func Factorial(n int) int {
if n == 0 {
return 1
} else {
return n * Factorial(n-1)
}
}
func SuperFactorial(n int) int {
if n == 0 {
return 1
} else {
return Factorial(n) * SuperFactorial(n-1)
}
}
```
`C++`:
```cpp
int factorial(int n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
int superfactorial(int n){
if(n == 0) return 1;
else return factorial(n) * superfactorial(n - 1);
}
```
`C#`:
```cs
int Factorial(int n)
{
if(n == 0) return 1;
else return n * Factorial(n - 1);
}
int SuperFactorial(int n)
{
if(n == 0) return 1;
else return Factorial(n) * SuperFactorial(n - 1);
}
```
### Counting superduperfactorial / Підрахунок гіперфакторіалу / Вычисление гиперфакториала
`Python`:
```python
def factorial(n):
if n == 0: return 1
else: return n * factorial(n - 1)
def superfactorial(n):
if n == 0: return 1
else: return factorial(n) * superfactorial(n - 1)
def superduperfactorial(n):
if n == 0: return 1
else: return superfactorial(n) * superduperfactorial(n - 1)
```
`JavaScript`:
```js
function factorial(n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
function superfactorial(n){
if(n == 0) return 1;
else return factorial(n) * superfactorial(n - 1);
}
function superduperfactorial(n){
if(n == 0) return 1;
else return superfactorial(n) * superduperfactorial(n - 1);
}
```
`Go`:
```go
func Factorial(n int) int {
if n == 0 {
return 1
} else {
return n * Factorial(n-1)
}
}
func SuperFactorial(n int) int {
if n == 0 {
return 1
} else {
return Factorial(n) * SuperFactorial(n-1)
}
}
func SuperDuperFactorial(n int) int {
if n == 0 {
return 1
} else {
return SuperFactorial(n) * SuperDuperFactorial(n-1)
}
}
```
`C++`:
```cpp
int factorial(int n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
int superfactorial(int n){
if(n == 0) return 1;
else return factorial(n) * superfactorial(n - 1);
}
int superduperfactorial(int n){
if(n == 0) return 1;
else return superfactorial(n) * superduperfactorial(n - 1);
}
```
`C#`:
```cpp
int Factorial(int n)
{
if(n == 0) return 1;
else return n * Factorial(n - 1);
}
int SuperFactorial(int n)
{
if(n == 0) return 1;
else return Factorial(n) * SuperFactorial(n - 1);
}
int SuperDuperFactorial(int n){
if(n == 0) return 1;
else return SuperFactorial(n) * SuperDuperFactorial(n - 1);
}
```
## Combinatorics / Комбінаторика / Комбинаторика
### Packages / Пакети / Пакеты
`Python`:
```python
combinatorics.count_combinations(n, k)
combinatorics.count_permutations(n, k)
combinatorics.generate_combinations(arr, k)
combinatorics.generate_permutations(arr, k)
```
`JavaScript`:
```js
combinatorics.countCombinations(n, k);
combinatorics.countPermutations(n, k);
combinatorics.generateCombinations(arr, k);
combinatorics.generatePermutations(arr, k);
```
***Wikipedia:*** *[Combinatorics](https://en.wikipedia.org/wiki/Combinatorics)*
***Вікіпедія:*** *[Комбінаторика](https://uk.wikipedia.org/wiki/Комбінаторика)*
***Википедия:*** *[Комбинаторика](https://ru.wikipedia.org/wiki/Комбинаторика)*
### Files / Файли / Файлы
***Python:*** *[combinatorics.py](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Combinatorics/combinatorics.py)*
***JavaScript:*** *[combinatorics.js](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Combinatorics/combinatorics.js)*
***Go:*** *[combinatorics.go](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Combinatorics/combinatorics.go)*
***C++:*** *[combinatorics.cpp](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Combinatorics/combinatorics.cpp)*
***C#:*** *[combinatorics.cs](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Combinatorics/combinatorics.cs)*
### Combinations / Комбінації / Сочетания
`Python`:
```python
def factorial(n):
if n == 0: return 1
else: return n * factorial(n - 1)
def count_combinations(n, k):
return factorial(n) / (factorial(k) * factorial(n - k))
def generate_combinations(arr, k = None):
if(k == None):
k = 1
result = []
for i in range(0, count_combinations(len(arr), k)):
local_result = [0]
n = len(arr)
s = 0
for j in range(1,k+1):
t = local_result[j - 1] + 1;
while (t < (n - k + j)) and ((s + count_combinations(n - t, k - j)) <= i):
s += count_combinations(n - t, k - j)
t += 1
local_result.append(t)
for l in range(0, len(local_result)):
local_result[l] = arr[local_result[l] - 1]
result.append(local_result[1:])
return result
```
`JavaScript`:
```js
function factorial(n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
function countCombinations(n, k){
return factorial(n) / (factorial(k) * factorial(n - k));
}
function generateCombinations(arr, k = NaN){
if(isNaN(k)){
k = 1;
}
let result = [];
for(let i = 0; i < countCombinations(arr.length, k); i ++){
let localResult = [0];
let n = arr.length;
let s = 0;
for(let j = 1; j <= k; j ++){
let t = localResult[j - 1] + 1;
while((t < (n - k + j)) && ((s + countCombinations(n - t, k - j)) <= i)){
s += countCombinations(n - t, k - j);
t ++;
}
localResult.push(t);
}
for(l in localResult){
localResult[l] = arr[localResult[l] - 1];
}
result.push(localResult.slice(1, localResult.length));
}
return result;
}
```
`Go`:
```go
func Factorial(n int) int {
if n == 0 {
return 1
} else {
return n * Factorial(n-1)
}
}
func CountCombinations(n int, k int) int {
return Factorial(n) / (Factorial(k) * Factorial(n-k))
}
func GenerateCombinations(arr []int, k int) [][]int {
result := [][]int{}
for i := 0; i < CountCombinations(len(arr), k); i++ {
localResult := []int{0}
n := len(arr)
s := 0
for j := 1; j <= k; j++ {
t := localResult[j-1] + 1
for (t < (n - k + j)) && (s+CountCombinations(n-t, k-j) <= i) {
s += CountCombinations(n-t, k-j)
t++
}
localResult = append(localResult, t)
}
for l := 1; l < len(localResult); l++ {
localResult[l] = arr[localResult[l]-1]
}
result = append(result, localResult[1:])
}
return result
}
```
`C++`:
```cpp
int factorial(int n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
int count_combinations(int n, int k){
return factorial(n) / (factorial(k) * factorial(n - k));
}
vector > generate_combinations(vector arr, int k){
vector > result;
for(int i = 0; i < count_combinations(arr.size(), k); i ++){
vector local_result(1, 0);
int n = arr.size();
int s = 0;
for(int j = 1; j <= k; j++){
int t = local_result[j - 1] + 1;
while((t < (n - k + j)) && ((s + count_combinations(n - t, k - j) <= i))){
s += count_combinations(n - t, k - j);
t ++;
}
local_result.push_back(t);
}
for(int l = 1; l < local_result.size(); l ++){
local_result[l] = arr[local_result[l] - 1];
}
result.push_back(vector (local_result.begin() + 1, local_result.end()));
}
return result;
}
```
`C#`:
```cs
int Factorial(int n)
{
if(n == 0) return 1;
else return n * Factorial(n - 1);
}
int CountCombinations(int n, int k)
{
return Factorial(n) / (Factorial(k) * Factorial(n - k));
}
List> GenerateCombinations(List arr, int k)
{
List> result = new List>(){};
for(int i = 0; i < CountCombinations(arr.Count(), k); i ++)
{
List localResult = new List(1){0};
int n = arr.Count();
int s = 0;
for(int j = 1; j <= k; j ++)
{
int t = localResult[j - 1] + 1;
while((t < (n - k + j)) && ((s + CountCombinations(n - t, k - j)) <= i))
{
s += CountCombinations(n - t, k - j);
t ++;
}
localResult.Add(t);
}
for(int l = 1; l < localResult.Count(); l ++){
localResult[l] = arr[localResult[l] - 1];
}
result.Add(localResult.GetRange(1, localResult.Count() - 1));
}
return result;
}
```
### Permutations / Розміщення / Размещения
`Python`:
```python
def factorial(n):
if n == 0: return 1
else: return n * factorial(n - 1)
def count_combinations(n, k):
return factorial(n) / (factorial(k) * factorial(n - k))
def count_permutations(n, k):
return factorial(n) / factorial(n - k)
def generate_combinations(arr, k = None):
if(k == None):
k = 1
result = []
for i in range(0, count_combinations(len(arr), k)):
local_result = [0]
n = len(arr)
s = 0
for j in range(1,k+1):
t = local_result[j - 1] + 1;
while (t < (n - k + j)) and ((s + count_combinations(n - t, k - j)) <= i):
s += count_combinations(n - t, k - j)
t += 1
local_result.append(t)
for l in range(0, len(local_result)):
local_result[l] = arr[local_result[l] - 1]
result.append(local_result[1:])
return result
def generate_permutations(arr, k = None):
if(k == None):
k = len(arr)
result = []
m = generate_combinations(arr, k)
for arr in m:
local_result = []
for i in range(0, factorial(len(arr))):
ind = i + 1
local_local_result = []
local_local_arr = []
for a in arr:
local_local_arr.append(a)
n = len(local_local_arr)
for j in range(1, n + 1):
f = factorial(n - j)
g = int((ind + f - 1) / f)
local_local_result.append(local_local_arr.pop(g - 1))
ind -= (g - 1) * f
if len(local_local_arr):
local_local_result.append(local_local_arr[0])
local_result.append(local_local_result)
for u in local_result:
result.append(u)
return result
```
`JavaScript`:
```js
function factorial(n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
function countCombinations(n, k){
return factorial(n) / (factorial(k) * factorial(n - k));
}
function countPermutations(n, k){
return factorial(n) / factorial(n - k);
}
function generateCombinations(arr, k = NaN){
if(isNaN(k)){
k = 1;
}
let result = [];
for(let i = 0; i < countCombinations(arr.length, k); i ++){
let localResult = [0];
let n = arr.length;
let s = 0;
for(let j = 1; j <= k; j ++){
let t = localResult[j - 1] + 1;
while((t < (n - k + j)) && ((s + countCombinations(n - t, k - j)) <= i)){
s += countCombinations(n - t, k - j);
t ++;
}
localResult.push(t);
}
for(l in localResult){
localResult[l] = arr[localResult[l] - 1];
}
result.push(localResult.slice(1, localResult.length));
}
return result;
}
function generatePermutations(arr, k = NaN){
if(isNaN(k)){
k = arr.length;
}
let result = [];
let m = generateCombinations(arr, k);
for(arr of m){
let localResult = [];
for(let i = 0; i < factorial(arr.length); i ++){
let ind = i + 1;
let localLocalResult = [];
let localLocalArr = [];
for(a of arr){
localLocalArr.push(a);
}
let n = localLocalArr.length;
for(let j = 1; j <= n; j ++){
let f = factorial(n - j);
let g = Math.floor((ind + f - 1) / f);
localLocalResult.push(localLocalArr.splice(g - 1, 1)[0]);
ind -= (g - 1) * f;
}
if(localLocalArr.length){
localLocalResult.push(localLocalArr[0]);
}
localResult.push(localLocalResult);
}
for(u of localResult){
result.push(u);
}
}
return result;
}
```
`Go`:
```go
func Factorial(n int) int {
if n == 0 {
return 1
} else {
return n * Factorial(n-1)
}
}
func CountCombinations(n int, k int) int {
return Factorial(n) / (Factorial(k) * Factorial(n-k))
}
func CountPermutations(n int, k int) int {
return Factorial(n) / Factorial(n-k)
}
func GenerateCombinations(arr []int, k int) [][]int {
result := [][]int{}
for i := 0; i < CountCombinations(len(arr), k); i++ {
localResult := []int{0}
n := len(arr)
s := 0
for j := 1; j <= k; j++ {
t := localResult[j-1] + 1
for (t < (n - k + j)) && (s+CountCombinations(n-t, k-j) <= i) {
s += CountCombinations(n-t, k-j)
t++
}
localResult = append(localResult, t)
}
for l := 1; l < len(localResult); l++ {
localResult[l] = arr[localResult[l]-1]
}
result = append(result, localResult[1:])
}
return result
}
func GeneratePermutations(arr []int, k int) [][]int {
result := [][]int{}
m := GenerateCombinations(arr, k)
for _, a := range m {
localResult := [][]int{}
for i := 0; i < Factorial(len(a)); i++ {
ind := i + 1
localLocalResult := []int{}
localLocalArr := []int{}
for _, r := range a {
localLocalArr = append(localLocalArr, r)
}
n := len(localLocalArr)
for j := 1; j <= n; j++ {
f := Factorial(n - j)
g := (ind + f - 1) / f
localLocalResult = append(localLocalResult, localLocalArr[g-1])
localLocalArr = append(localLocalArr[:g-1], localLocalArr[g:]...)
ind -= (g - 1) * f
}
if len(localLocalArr) > 0 {
localLocalResult = append(localLocalResult, localLocalArr[0])
}
localResult = append(localResult, localLocalResult)
}
for _, u := range localResult {
result = append(result, u)
}
}
return result
}
```
`C++`:
```cpp
int factorial(int n){
if(n == 0) return 1;
else return n * factorial(n - 1);
}
int count_combinations(int n, int k){
return factorial(n) / (factorial(k) * factorial(n - k));
}
int count_permutations(int n, int k){
return factorial(n) / factorial(n - k);
}
vector > generate_combinations(vector arr, int k){
vector > result;
for(int i = 0; i < count_combinations(arr.size(), k); i ++){
vector local_result(1, 0);
int n = arr.size();
int s = 0;
for(int j = 1; j <= k; j++){
int t = local_result[j - 1] + 1;
while((t < (n - k + j)) && ((s + count_combinations(n - t, k - j) <= i))){
s += count_combinations(n - t, k - j);
t ++;
}
local_result.push_back(t);
}
for(int l = 1; l < local_result.size(); l ++){
local_result[l] = arr[local_result[l] - 1];
}
result.push_back(vector (local_result.begin() + 1, local_result.end()));
}
return result;
}
vector > generate_permutations(vector arr, int k){
vector > result;
vector > m = generate_combinations(arr, k);
for(auto a: m){
vector > local_result;
for(int i = 0; i < factorial(a.size()); i ++){
int ind = i + 1;
vector local_local_result;
vector local_local_arr;
for(auto r: a){
local_local_arr.push_back(r);
}
int n = local_local_arr.size();
for(int j = 1; j <= n; j ++){
int f = factorial(n - j);
int g = (ind + f - 1) / f;
local_local_result.push_back(local_local_arr[g - 1]);
auto iter = local_local_arr.cbegin();
local_local_arr.erase(iter + g - 1);
ind -= (g - 1) * f;
}
if(local_local_arr.size()){
local_local_result.push_back(local_local_arr[0]);
}
local_result.push_back(local_local_result);
}
for(auto u: local_result){
result.push_back(u);
}
}
return result;
}
```
`C#`:
```cs
int Factorial(int n)
{
if(n == 0) return 1;
else return n * Factorial(n - 1);
}
int CountCombinations(int n, int k)
{
return Factorial(n) / (Factorial(k) * Factorial(n - k));
}
int CountPermutations(int n, int k)
{
return Factorial(n) / Factorial(n - k);
}
List> GenerateCombinations(List arr, int k)
{
List> result = new List>(){};
for(int i = 0; i < CountCombinations(arr.Count(), k); i ++)
{
List localResult = new List(1){0};
int n = arr.Count();
int s = 0;
for(int j = 1; j <= k; j ++)
{
int t = localResult[j - 1] + 1;
while((t < (n - k + j)) && ((s + CountCombinations(n - t, k - j)) <= i))
{
s += CountCombinations(n - t, k - j);
t ++;
}
localResult.Add(t);
}
for(int l = 1; l < localResult.Count(); l ++){
localResult[l] = arr[localResult[l] - 1];
}
result.Add(localResult.GetRange(1, localResult.Count() - 1));
}
return result;
}
List> GeneratePermutations(List arr, int k)
{
List> result = new List>(){};
List> m = GenerateCombinations(arr, k);
foreach(List a in m)
{
List> localResult = new List>(){};
for(int i = 0; i < Factorial(a.Count()); i ++)
{
int ind = i + 1;
List localLocalResult = new List (){};
List localLocalArr = new List (){};
foreach(int r in a)
{
localLocalArr.Add(r);
}
int n = localLocalArr.Count();
for(int j = 1; j <= n; j ++)
{
int f = Factorial(n - j);
int g = (ind + f - 1) / f;
localLocalResult.Add(localLocalArr[g - 1]);
localLocalArr.RemoveAt(g - 1);
ind -= (g - 1) * f;
}
if(localLocalArr.Count() > 0)
{
localLocalResult.Add(localLocalArr[0]);
}
localResult.Add(localLocalResult);
}
foreach(List u in localResult)
{
result.Add(u);
}
}
return result;
}
```
## Roman and arabic numerals / Римські та арабські числа / Римские и арабские числа
### Packages / Пакети / Пакеты
`Python`:
```python
roman_arabic_numerals.rom_arab(p)
roman_arabic_numerals.arab_rom(s)
```
`JavaScript`:
```js
romanArabicNumerals.romArab(p);
romanArabicNumerals.arabRom(s);
```
### Files / Файли / Файлы
***Python:*** *[roman-arabic-numerals.py](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Roman%20arabic%20numerals/roman-arabic-numerals.py)*
***JavaScript:*** *[roman-arabic-numerals.js](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Roman%20arabic%20numerals/roman-arabic-numerals.js)*
***Go:*** *[roman-arabic-numerals.go](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Roman%20arabic%20numerals/roman-arabic-numerals.go)*
***C++:*** *[roman-arabic-numerals.cpp](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Roman%20arabic%20numerals/roman-arabic-numerals.cpp)*
***C#:*** *[roman-arabic-numerals.cs](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Roman%20arabic%20numerals/roman-arabic-numerals.cs)*
### Code / Код / Код
`Python`:
```python
def rom_arab(p):
z = 0
try:
p = str(p).lower()
for i in range(0, len(p)):
if p[i] == 'i':
try:
if p[i+1] == 'v' or p[i+1] == 'x':
z -= 1
else:
z += 1
except:
z += 1
elif p[i] == 'v':
z += 5
elif p[i] == 'x':
try:
if p[i+1] == 'c' or p[i+1] == 'l':
z -= 10
else:
z += 10
except:
z += 10
elif p[i] == 'l':
z += 50
elif p[i] == 'c':
try:
if p[i+1] == 'm' or p[i+1] == 'd':
z -= 100
else:
z += 100
except:
z += 100
elif p[i] == 'd':
z += 500
elif p[i] == 'm':
z += 1000
else:
return None
except:
return None
return z
def arab_rom(s):
v = ""
try:
s = int(s)
while s > 0:
if s >= 1000:
s -= 1000
v += "M"
elif s >= 900:
s -= 900
v += "CM"
elif s >= 500:
s -= 500
v += "D"
elif s >= 400:
s -= 400
v += "CD"
elif s >= 100:
s -= 100
v += "C"
elif s >= 90:
s -= 90
v += "XC"
elif s >= 50:
s -= 50
v += "L"
elif s >= 40:
s -= 40
v += "XL"
elif s >= 10:
s -= 10
v += "X"
elif s >= 9:
s -= 9
v += "IX"
elif s >= 5:
s -= 5
v += "V"
elif s >= 4:
s -= 4
v += "IV"
elif s >= 1:
s -= 1
v += "I"
except:
return None
return v
```
`JavaScript`:
```js
function romArab(p){
let z = 0;
try{
p = String(p).toLowerCase();
for(let i = 0; i < p.length; i ++){
if(p[i] == 'i'){
try{
if(p[i+1] == 'v' || p[i+1] == 'x'){
z -= 1;
}
else{
z += 1;
}
}
catch(e){
z += 1;
}
}
else if(p[i] == 'v'){
z += 5;
}
else if(p[i] == 'x'){
try{
if(p[i+1] == 'c' || p[i+1] == 'l'){
z -= 10;
}
else{
z += 10;
}
}
catch(e){
z += 10;
}
}
else if(p[i] == 'l'){
z += 50;
}
else if(p[i] == 'c'){
try{
if(p[i+1] == 'm' || p[i+1] == 'd'){
z -= 100;
}
else{
z += 100;
}
}
catch(e){
z += 100;
}
}
else if(p[i] == 'd'){
z += 500;
}
else if(p[i] == 'm'){
z += 1000;
}
else{
return NaN;
}
}
}
catch(e){
return NaN;
}
return z;
}
function arabRom(s){
let v = "";
try{
s = Number(s);
if(isNaN(s)){
return NaN;
}
while(s > 0){
if(s >= 1000){
s -= 1000;
v += "M";
}
else if(s >= 900){
s -= 900;
v += "CM";
}
else if(s >= 500){
s -= 500;
v += "D";
}
else if(s >= 400){
s -= 400;
v += "CD";
}
else if(s >= 100){
s -= 100;
v += "C";
}
else if(s >= 90){
s -= 90;
v += "XC";
}
else if(s >= 50){
s -= 50;
v += "L";
}
else if(s >= 40){
s -= 40;
v += "XL";
}
else if(s >= 10){
s -= 10;
v += "X";
}
else if(s >= 9){
s -= 9;
v += "IX";
}
else if(s >= 5){
s -= 5;
v += "V";
}
else if(s >= 4){
s -= 4;
v += "IV";
}
else if(s >= 1){
s -= 1;
v += "I";
}
}
}
catch(e){
return NaN;
}
return v;
}
```
`Go`:
```go
func RomArab(p string) int {
z := 0
p = strings.ToLower(p)
for i := 0; i < len(p); i++ {
if p[i] == 'i' {
if p[i+1] == 'v' || p[i+1] == 'x' {
z--
} else {
z++
}
} else if p[i] == 'v' {
z += 5
} else if p[i] == 'x' {
if p[i+1] == 'c' || p[i+1] == 'l' {
z -= 10
} else {
z += 10
}
} else if p[i] == 'l' {
z += 50
} else if p[i] == 'c' {
if p[i+1] == 'm' || p[i+1] == 'd' {
z -= 100
} else {
z += 100
}
} else if p[i] == 'd' {
z += 500
} else if p[i] == 'm' {
z += 1000
} else {
fmt.Println("Uncorrect input")
return 0
}
}
return z
}
func ArabRom(s int) string {
v := ""
for s > 0 {
if s >= 1000 {
s -= 1000
v += "M"
} else if s >= 900 {
s -= 900
v += "CM"
} else if s >= 500 {
s -= 500
v += "D"
} else if s >= 400 {
s -= 400
v += "CD"
} else if s >= 100 {
s -= 100
v += "C"
} else if s >= 90 {
s -= 90
v += "XC"
} else if s >= 50 {
s -= 50
v += "L"
} else if s >= 40 {
s -= 40
v += "XL"
} else if s >= 10 {
s -= 10
v += "X"
} else if s >= 9 {
s -= 9
v += "IX"
} else if s >= 5 {
s -= 5
v += "V"
} else if s >= 4 {
s -= 4
v += "IV"
} else if s >= 1 {
s -= 1
v += "I"
}
}
return v
}
```
`C++`:
```cpp
#include
int rom_arab(string p){
int z = 0;
try{
for(int i = 0; i < p.length(); i ++){
if(tolower(p[i]) == 'i'){
try{
if(tolower(p[i+1]) == 'v' || tolower(p[i+1]) == 'x'){
z -= 1;
}
else{
z += 1;
}
}
catch(...){
z += 1;
}
}
else if(tolower(p[i]) == 'v'){
z += 5;
}
else if(tolower(p[i]) == 'x'){
try{
if(tolower(p[i+1]) == 'c' || tolower(p[i+1]) == 'l'){
z -= 10;
}
else{
z += 10;
}
}
catch(...){
z += 10;
}
}
else if(tolower(p[i]) == 'l'){
z += 50;
}
else if(tolower(p[i]) == 'c'){
try{
if(tolower(p[i+1]) == 'm' || tolower(p[i+1]) == 'd'){
z -= 100;
}
else{
z += 100;
}
}
catch(...){
z += 100;
}
}
else if(tolower(p[i]) == 'd'){
z += 500;
}
else if(tolower(p[i]) == 'm'){
z += 1000;
}
else{
cout << "Uncorrect input" << endl;
return 0;
}
}
}
catch(...){
cout << "Uncorrect input" << endl;
return 0;
}
return z;
}
string arab_rom(int s){
string v = "";
try{
while(s > 0){
if(s >= 1000){
s -= 1000;
v += "M";
}
else if(s >= 900){
s -= 900;
v += "CM";
}
else if(s >= 500){
s -= 500;
v += "D";
}
else if(s >= 400){
s -= 400;
v += "CD";
}
else if(s >= 100){
s -= 100;
v += "C";
}
else if(s >= 90){
s -= 90;
v += "XC";
}
else if(s >= 50){
s -= 50;
v += "L";
}
else if(s >= 40){
s -= 40;
v += "XL";
}
else if(s >= 10){
s -= 10;
v += "X";
}
else if(s >= 9){
s -= 9;
v += "IX";
}
else if(s >= 5){
s -= 5;
v += "V";
}
else if(s >= 4){
s -= 4;
v += "IV";
}
else if(s >= 1){
s -= 1;
v += "I";
}
}
}
catch(...){
cout << "Uncorrect input" << endl;
return "";
}
return v;
}
```
`C#`:
```cs
int RomArab(string p)
{
int z = 0;
try
{
for(int i = 0; i < p.Length; i ++)
{
if(char.ToLower(p[i]) == 'i')
{
try
{
if(char.ToLower(p[i+1]) == 'v' || char.ToLower(p[i+1]) == 'x')
{
z -= 1;
}
else
{
z += 1;
}
}
catch
{
z += 1;
}
}
else if(char.ToLower(p[i]) == 'v')
{
z += 5;
}
else if(char.ToLower(p[i]) == 'x')
{
try
{
if(char.ToLower(p[i+1]) == 'c' || char.ToLower(p[i+1]) == 'l')
{
z -= 10;
}
else
{
z += 10;
}
}
catch
{
z += 10;
}
}
else if(char.ToLower(p[i]) == 'l')
{
z += 50;
}
else if(char.ToLower(p[i]) == 'c')
{
try
{
if(char.ToLower(p[i+1]) == 'm' || char.ToLower(p[i+1]) == 'd')
{
z -= 100;
}
else
{
z += 100;
}
}
catch
{
z += 100;
}
}
else if(char.ToLower(p[i]) == 'd')
{
z += 500;
}
else if(char.ToLower(p[i]) == 'm')
{
z += 1000;
}
else
{
Console.WriteLine("Uncorrect input");
return 0;
}
}
}
catch
{
Console.WriteLine("Uncorrect input");
return 0;
}
return z;
}
string ArabRom(int s)
{
string v = "";
try
{
while(s > 0)
{
if(s >= 1000)
{
s -= 1000;
v += "M";
}
else if(s >= 900)
{
s -= 900;
v += "CM";
}
else if(s >= 500)
{
s -= 500;
v += "D";
}
else if(s >= 400)
{
s -= 400;
v += "CD";
}
else if(s >= 100)
{
s -= 100;
v += "C";
}
else if(s >= 90)
{
s -= 90;
v += "XC";
}
else if(s >= 50)
{
s -= 50;
v += "L";
}
else if(s >= 40)
{
s -= 40;
v += "XL";
}
else if(s >= 10)
{
s -= 10;
v += "X";
}
else if(s >= 9)
{
s -= 9;
v += "IX";
}
else if(s >= 5)
{
s -= 5;
v += "V";
}
else if(s >= 4)
{
s -= 4;
v += "IV";
}
else if(s >= 1)
{
s -= 1;
v += "I";
}
}
}
catch
{
Console.WriteLine("Uncorrect input");
return "";
}
return v;
}
```
## Arithmetic for big numbers / Арифметика для великих чисел / Арифметика для больших чисел
### Packages / Пакети / Пакеты
`Python`:
```python
arithmetic.addition_big_numbers(a, b)
arithmetic.subtraction_big_numbers(a, b)
arithmetic.multiplication_big_numbers(a, b)
```
`JavaScript`:
```js
arithmetic.additionBigNumbers(a, b);
arithmetic.subtractionBigNumbers(a, b);
arithmetic.multiplicationBigNumbers(a, b);
```
### Files / Файли / Файлы
***Python:*** *[arithmetic.py](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Arithmetic/arithmetic.py)*
***JavaScript:*** *[arithmetic.js](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Arithmetic/arithmetic.js)*
***Go:*** *[arithmetic.go](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Arithmetic/arithmetic.go)*
***C++:*** *[arithmetic.cpp](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Arithmetic/arithmetic.cpp)*
***C#:*** *[arithmetic.cs](https://github.com/s0urcedev/AdditionalFunctions/blob/main/Arithmetic/arithmetic.cs)*
### Addition / Додавання / Прибавление
`Python`:
```python
def addition_big_numbers(a, b):
a = str(a)[::-1]
b = str(b)[::-1]
while(len(b) < len(a)):
b += '0'
while(len(a) < len(b)):
a += '0'
result = ''
c = 0
for i in range(0, len(a)):
local_result = int(a[i]) + int(b[i]) + c
c = 0
if local_result > 9:
local_result -= 10
c = 1
result += str(local_result)
if c == 1:
result += '1'
return result[::-1]
```
`JavaScript`:
```js
function additionBigNumbers(a, b){
a = String(a).split("").reverse().join("");
b = String(b).split("").reverse().join("");
while(b.length < a.length){
b += '0';
}
while(a.length < b.length){
a += '0';
}
let result = '';
let c = 0;
for(let i = 0; i < a.length; i ++){
let localResult = Number(a[i]) + Number(b[i]) + c;
c = 0;
if(localResult > 9){
localResult -= 10;
c = 1;
}
result += String(localResult);
}
if(c == 1){
result += '1';
}
return result.split("").reverse().join("");
}
```
`Go`:
```go
func AdditionBigNumbers(a string, b string) string {
for len(b) < len(a) {
b = "0" + b
}
for len(a) < len(b) {
a = "0" + a
}
result := ""
c := 0
for i := len(a) - 1; i >= 0; i-- {
localResult := int(a[i]-48) + int(b[i]-48) + c
c = 0
if localResult > 9 {
localResult -= 10
c = 1
}
result += strconv.Itoa(localResult)
}
if c == 1 {
result += "1"
}
fresult := ""
for _, s := range result {
fresult = string(s) + fresult
}
return fresult
}
```
`C++`:
```cpp
#include
string addition_big_numbers(string a, string b){
while(b.length() < a.length()){
b = "0" + b;
}
while(a.length() < b.length()){
a = "0" + a;
}
string result = "";
int c = 0;
for(int i = a.length() - 1; i >= 0; i --){
int local_result = (a[i] - 48) + (b[i] - 48) + c;
c = 0;
if(local_result > 9){
local_result -= 10;
c = 1;
}
result += to_string(local_result);
}
if(c == 1){
result += "1";
}
string fresult = "";
for(auto s: result){
fresult = s + fresult;
}
return fresult;
}
```
`C#`:
```cs
string AdditionBigNumbers(string a, string b)
{
while(b.Length < a.Length)
{
b = "0" + b;
}
while(a.Length < b.Length)
{
a = "0" + a;
}
string result = "";
int c = 0;
for(int i = a.Length - 1; i >= 0; i --)
{
int localResult = (a[i] - 48) + (b[i] - 48) + c;
c = 0;
if(localResult > 9)
{
localResult -= 10;
c = 1;
}
result += localResult.ToString();
}
if(c == 1){
result += "1";
}
string fresult = "";
foreach(char s in result)
{
fresult = s + fresult;
}
return fresult;
}
```
### Subtraction / Віднімання / Вычетание
`Python`:
```python
def subtraction_big_numbers(a, b):
k = False
if int(a) > int(b):
a = str(a)[::-1]
b = str(b)[::-1]
else:
k = True
swap = str(a)[::-1]
a = str(b)[::-1]
b = swap
while(len(b) < len(a)):
b += '0'
while(len(a) < len(b)):
a += '0'
result = ''
c = 0
for i in range(0, len(a)):
local_result = int(a[i]) - int(b[i]) - c
c = 0
if local_result < 0:
local_result += 10
c = 1
result += str(local_result)
if k:
result += '-'
while result[-1] == '0':
result = result[:-1]
return result[::-1]
```
`JavaScript`:
```js
function subtractionBigNumbers(a, b){
let k = false;
if(Number(a) > Number(b)){
a = String(a).split("").reverse().join("");
b = String(b).split("").reverse().join("");
}
else{
k = true;
swap = String(a).split("").reverse().join("");
a = String(b).split("").reverse().join("");
b = swap;
}
while(b.length < a.length){
b += '0';
}
while(a.length < b.length){
a += '0';
}
let result = '';
let c = 0;
for(let i = 0; i < a.length; i ++){
let localResult = Number(a[i]) - Number(b[i]) - c;
c = 0;
if(localResult < 0){
localResult += 10;
c = 1;
}
result += String(localResult);
}
if(k){
result += '-'
}
while(result[result.length - 1] == '0'){
result = result.slice(0, result.length - 1);
}
return result.split("").reverse().join("");
}
```
`Go`:
```go
func SubtractionBigNumbers(a string, b string) string {
k := false
if len(a) < len(b) {
a, b = b, a
k = true
}
ai, _ := strconv.Atoi(a)
bi, _ := strconv.Atoi(b)
if ai < bi {
a, b = b, a
k = true
}
for len(b) < len(a) {
b = "0" + b
}
for len(a) < len(b) {
a = "0" + a
}
result := ""
c := 0
for i := len(a) - 1; i >= 0; i-- {
localResult := int(a[i]-48) - int(b[i]-48) - c
c = 0
if localResult < 0 {
localResult += 10
c = 1
}
result += strconv.Itoa(localResult)
}
if c == 1 {
result += "1"
}
for result[len(result)-1] == '0' {
result = result[:len(result)-1]
}
fresult := ""
for _, s := range result {
fresult = string(s) + fresult
}
if k {
fresult = "-" + fresult
}
return fresult
}
```
`C++`:
```cpp
#include
#include
string subtraction_big_numbers(string a, string b){
stringstream ssa;
ssa << a;
long long n = 0;
ssa >> n;
stringstream ssb;
ssb << b;
long long m = 0;
ssb >> m;
bool k = false;
if(n < m){
k = true;
string swap = a;
a = b;
b = swap;
}
while(b.length() < a.length()){
b = "0" + b;
}
while(a.length() < b.length()){
a = "0" + a;
}
string result = "";
int c = 0;
for(int i = a.length() - 1; i >= 0; i --){
int local_result = (a[i] - 48) - (b[i] - 48) - c;
c = 0;
if(local_result < 0){
local_result += 10;
c = 1;
}
result += to_string(local_result);
}
if(c == 1){
result += "1";
}
while(result[result.length() - 1] == '0'){
result = result.substr(0, result.length() - 1);
}
string fresult = "";
for(auto s: result){
fresult = s + fresult;
}
if(k){
fresult = '-' + fresult;
}
return fresult;
}
```
`C#`:
```cs
string SubtractionBigNumbers(string a, string b)
{
bool k = false;
if(Convert.ToInt32(a) < Convert.ToInt32(b))
{
string swap = a;
a = b;
b = swap;
k = true;
}
while(b.Length < a.Length)
{
b = "0" + b;
}
while(a.Length < b.Length)
{
a = "0" + a;
}
string result = "";
int c = 0;
for(int i = a.Length - 1; i >= 0; i --)
{
int localResult = (a[i] - 48) - (b[i] - 48) - c;
c = 0;
if(localResult < 0)
{
localResult += 10;
c = 1;
}
result += localResult.ToString();
}
if(c == 1)
{
result += "1";
}
while(result[result.Length - 1] == '0')
{
result = result.Substring(0, result.Length - 1);
}
string fresult = "";
foreach(char s in result)
{
fresult = s + fresult;
}
if(k)
{
fresult = '-' + fresult;
}
return fresult;
}
```
### Multipl