Skip to content

Add files via upload #46

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Add files via upload #46

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
168 changes: 168 additions & 0 deletions core.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,168 @@
//Напишите функцию, которая проверяет, является ли число целым используя побитовые операторы
function isInteger(n) {
return ~~n == n;
}

//Напишите функцию, которая возвращает массив четных чисел от 2 до 20 включительно
function even() {
const array = [];
for (let i = 2; i < 21; i += 2) {
array.push(i);
}
//console.log(array);
return array;
}

//Напишите функцию, считающую сумму чисел до заданного используя цикл
function sumTo(n) {
let ans = 0;
for (let i = 1; i <= n; ++i) {
ans += i;
}
return ans;
}

//Напишите функцию, считающую сумму чисел до заданного используя рекурсию
function recSumTo(n) {
if (n == 0) {
return 0;
} else {
return recSumTo(n - 1) + n;
}
}

//Напишите функцию, считающую факториал заданного числа
function factorial(n) {
let ans = 1;
for (let i = 2; i <= n; ++i) {
ans *= i;
}
return ans;
}

//Напишите функцию, которая определяет, является ли число двойкой, возведенной в степень
function isBinary(n) {
return n && (n & (n - 1)) === 0;
}

//Напишите функцию, которая находит N-е число Фибоначчи
function fibonacci(n) {
if (n == 1 || n == 2) {
return 1;
} else {
let a = 1;
let b = 1;
let ans = 0;
for (let i = 3; i <= n; ++i) {
ans = a + b;
a = b;
b = ans;
}
return ans;
}
}

/** Напишите функцию, которая принимает начальное значение и функцию операции
* и возвращает функцию - выполняющую эту операцию.
* Если функция операции (operatorFn) не задана - по умолчанию всегда
* возвращается начальное значение (initialValue)
* @param initialValue
* @param operatorFn - (storedValue, newValue) => {operation}
* @example
* const sumFn = getOperationFn(10, (a,b) => a + b);
* console.log(sumFn(5)) - 15
* console.log(sumFn(3)) - 18
*/
function getOperationFn(initialValue, operatorFn) {
let storedValue = initialValue;
if (!operatorFn) {
return () => {
return initialValue;
};
} else {
return (newValue) => {
return (storedValue = operatorFn(storedValue, newValue));
};
}
}

/**
* Напишите функцию создания генератора арифметической последовательности.
* При ее вызове, она возвращает новую функцию генератор - generator().
* Каждый вызов функции генератора возвращает следующий элемент последовательности.
* Если начальное значение не передано то оно равно 0.
* Если шаг не угазан, то по дефолту он равен 1.
* Генераторов можно создать сколько угодно - они все независимые.
*
* @param {number} start - число с которого начинается последовательность
* @param {number} step - число шаг полседовательности
* @example
* const generator = sequence(5, 2);
* console.log(generator()); // 5
* console.log(generator()); // 7
* console.log(generator()); // 9
*/
function sequence(start, step) {
start = start ?? 0;
step = step ?? 1;
let storedValue = start - step;
return () => {
return (storedValue += step);
};
}

/**
* Напишите функцию deepEqual, которая принимает два значения
* и возвращает true только в том случае, если они имеют одинаковое значение
* или являются объектами с одинаковыми свойствами,
* значения которых также равны при сравнении с рекурсивным вызовом deepEqual.
* Учитывать специфичные объекты(такие как Date, RegExp итп) не обязательно
*
* @param {object} firstObject - первый объект
* @param {object} secondObject - второй оббъект
* @returns {boolean} - true если объекты равны(по сожержанию) иначе false
* @example
* deepEqual({arr: [22, 33], text: 'text'}, {arr: [22, 33], text: 'text'}) // true
* deepEqual({arr: [22, 33], text: 'text'}, {arr: [22, 3], text: 'text2'}) // false
*/
function deepEqual(firstObject, secondObject) {
if (firstObject === secondObject) {
return true;
}
if (
firstObject === null ||
typeof firstObject != 'object' ||
secondObject === null ||
typeof secondObject != 'object'
) {
return false;
}

let propsFirstObject = 0,
propsSecondObject = 0;
for (let prop in firstObject) {
propsFirstObject += 1;
}
for (let prop in secondObject) {
propsSecondObject += 1;
if (
!(prop in firstObject) ||
!deepEqual(firstObject[prop], secondObject[prop])
) {
return false;
}
}
return propsFirstObject === propsSecondObject;
}
module.exports = {
isInteger,
even,
sumTo,
recSumTo,
factorial,
isBinary,
fibonacci,
getOperationFn,
sequence,
deepEqual,
};
157 changes: 157 additions & 0 deletions core.spec.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,157 @@
const assert = require('assert'),
core = require('./core');

describe('Задания core js', () => {
describe('#isInteger', () => {
it('Возвращает true на целое число', () => {
assert.equal(core.isInteger(3), true);
});

it('Возвращает false на нецелое число', () => {
assert.equal(core.isInteger(1.2), false);
});
});

describe('#even', () => {
it('Возвращает корректный массив', () => {
assert.deepStrictEqual(
core.even(),
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
);
});
});

describe('#sumTo', () => {
it('Возвращает сумму чисел до n', () => {
assert.equal(core.sumTo(4), 10, 'С маленьким числом');
assert.equal(core.sumTo(100), 5050, 'С большим числом');
});
});

describe('#recSumTo', () => {
it('Возвращает сумму чисел до n', () => {
assert.equal(core.recSumTo(4), 10, 'С маленьким числом');
assert.equal(core.recSumTo(100), 5050, 'С большим числом');
});
});

describe('#factorial', () => {
it('Возвращает факториал n', () => {
assert.equal(core.factorial(5), 120);
assert.equal(core.factorial(4), 24);
});
});

describe('#isBinary', () => {
it('Возвращает true при передаче степени двойки', () => {
assert.equal(core.isBinary(1), true);
assert.equal(core.isBinary(2), true);
assert.equal(core.isBinary(2048), true);
});

it('Возвращает false при передаче не степени двойки', () => {
assert.equal(core.isBinary(0), false);
assert.equal(core.isBinary(12), false);
assert.equal(core.isBinary(1023), false);
});
});

describe('#fibonacci', () => {
it('Возвращает n-ое число Фибоначчи корректно', () => {
assert.equal(core.fibonacci(1), 1);
assert.equal(core.fibonacci(2), 1);
assert.equal(core.fibonacci(7), 13);
assert.equal(core.fibonacci(10), 55);
});
});

describe('#getOperationFn', () => {
it('Возвращает функцию', () => {
const sumFn = core.getOperationFn(-1, (a, b) => a + b);
assert.ok(typeof sumFn === 'function');
});

it('Сохраняет внутреннее значение и применяет операцию', () => {
const multFn = core.getOperationFn(-1, (a, b) => a * b);
assert.strictEqual(multFn(-1), 1);
assert.strictEqual(multFn(4), 4);
assert.strictEqual(multFn(2), 8);
});

it('По умолчанию всегда возвращает начальное значение, если нет operatorFn', () => {
const staticFn = core.getOperationFn(-1);
assert.strictEqual(staticFn(-1), -1);
assert.strictEqual(staticFn(7), -1);
assert.strictEqual(staticFn(0), -1);
});
});

describe('#sequence', () => {
it('Возвращает функцию с шагом 1 и началом 0, если не переданы значения', () => {
const generator = core.sequence();
assert.equal(generator(), 0);
assert.equal(generator(), 1);
assert.equal(generator(), 2);
});

it('Функция-генератор корректно генерирует значения начиная со start с шагом step', () => {
const generator1 = core.sequence(10, 3);
const generator2 = core.sequence(8, 2);
assert.equal(generator1(), 10);
assert.equal(generator1(), 13);
assert.equal(generator2(), 8);
assert.equal(generator1(), 16);
assert.equal(generator2(), 10);
});
});

describe('#deepEqual', () => {
it('Возвращает true если объекты равны', () => {
assert.equal(
core.deepEqual(
{text: 'some text', count: 3, arr: [11, 22]},
{text: 'some text', count: 3, arr: [11, 22]}
),
true
);
assert.equal(
core.deepEqual(
{obj: {count: 12}, value: null, flag: true},
{obj: {count: 12}, value: null, flag: true}
),
true
);
assert.equal(
core.deepEqual(
{obj: {arr: ['a', 'b']}, value: undefined},
{obj: {arr: ['a', 'b']}, value: undefined}
),
true
);
});

it('Возвращает false если объекты не равны', () => {
assert.equal(
core.deepEqual(
{text: 'some text', count: 3, arr: [11, 22]},
{text: 'some text1', count: 4, arr: [11, 22]}
),
false
);
assert.equal(
core.deepEqual(
{obj: {count: 12}, value: null, flag: true},
{obj: {count: 22}, value: null, flag: false}
),
false
);
assert.equal(
core.deepEqual(
{obj: {arr: ['a', 'b']}, value: undefined},
{obj: {arr: ['a', 'b']}, value: null}
),
false
);
});
});
});