js_exercises

"use strict";
//----#1
//Треугольник. Напишите цикл,  выводит такой треугольник:
//#
//##
//###
//####
//#####
//######
//#######
//
// variant 1
(function () {
    var element,
        line,
        str = '# ',
        container = document.getElementById('container');

    function createElement() {
        element = document.createElement('span');
        line = document.createElement("div");

        element.textContent = str;
        line.appendChild(element);
        container.appendChild(line);
    }

    for (var i = 0; i < 7; i++) {
        createElement();
        str += ' #'
    }
})();
// variant 2
(function () {
    var line,
        el = '<span>#</span>',
        container = document.getElementById('container');

    var createElement = function () {
        line = document.createElement("div");
        line.innerHTML = el;
        container.appendChild(line);
    };

    for (var i = 0; i < 7; i++) {
        createElement();
        el += '<span>#</span>';
    }
})();
//
//
//----#2
//FizzBuzz. Напишите программу, которая выводит через console.log все числа от 1 до 100, с двумя исключениями.
// Для чисел, нацело делящихся на 3, она должна выводить ‘Fizz’, а для чисел, делящихся на 5 (но не на 3) – ‘Buzz’.
// Когда сумеете – исправьте её так, чтобы она выводила «FizzBuzz» для всех чисел, которые делятся и на 3 и на 5.
(function () {
    for (var i = 1; i < 16; i++) {
        var three = i % 3,
            five = i % 5;
        document.write(i + ' ');
        if (five === 0 && three === 0) {
            document.write('fizzbuzz ' + '<br>');
        }
        else if (three === 0) {
            document.write('fizz ');
        }
        else if (five === 0 && three > 0) {
            document.write('buzz ');
        }

        //variant 2
        //условие ? значение1 : значение2
        //(five === 0 && three === 0) ? console.log('fizzbuzz') :
        //(three === 0) ? console.log('fizz') :
        //(five === 0 && three > 0) ? console.log('buzz') : "sfse";
    }
})();
//
//
//----#3
//Шахматная доска. Напишите программу, создающую строку, содержащую решётку 8х8, в которой линии разделяются
// символами новой строки. На каждой позиции либо пробел, либо #. В результате должна получиться шахматная доска.
//# # # #
// # # # #
//# # # # #
// # # # #
//# # # # #
// # # # # #
//# # # # #

(function () {
    for (var i = 1; i < 9; i++) {
        var even = i % 2;
        if (even === 0) {
            document.write(' <hr>');
        }
        for (var j = 1; j < 5; j++) {
            document.write('# ')
        }
    }
})();
//
//----#4
//Минимум. Напишите функцию min, принимающую два аргумента, и возвращающую минимальный из них.
// console.log(min(0, 10));  // → 0
// console.log(min(0, -10)); // → -10
(function () {
    function min() {
        var arr = [];
        for (var i = 0; i < arguments.length; i++) {
            arr.push(arguments[i]);
        }
        //console.log("Min: " + Math.min.apply(null, arr));
        //console.log("Max: " + Math.max.apply(null, arr));
    }

    min(0, -1, -10, 21, 123);
})();


//
//----#5
//Рекурсия. Ноль чётный. Единица нечётная. У любого числа N чётность такая же, как у N-2.
// Напишите рекурсивную функцию isEven согласно этим правилам. Она должна принимать число
// и возвращать булевское значение. Потестируйте её на 50 и 75. Попробуйте задать ей -1.
// Почему она ведёт себя таким образом? Можно ли её как-то исправить?

(function () {
    function isEven(num) {
        if (num == 0) return true;
        if (num == 1) return false;
        return isEven(num - 2 * (num > 0 ? 1 : -1));
    }

    //console.log(isEven(50)); // ? true
    //console.log(isEven(75)); // ? false
    //console.log(isEven(-1)); // ? false
})();
//
//
//----#6
//Считаем бобы. Символ номер N строки можно получить, добавив к ней .charAt(N) ( “строчка”.charAt(5) ) – схожим образом
//с получением длины строки при помощи .length. Возвращаемое значение будет строковым, состоящим из одного
//символа (к примеру, “к”). У первого символа строки позиция 0, что означает, что у последнего символа позиция
//будет string.length – 1. Другими словами, у строки из двух символов длина 2, а позиции её символов будут 0 и 1.
//Напишите функцию countBs, которая принимает строку в качестве аргумента, и возвращает количество символов “B”,
//содержащихся в строке. Затем напишите функцию countChar, которая работает примерно как countBs, только принимает
//второй параметр — символ, который мы будем искать в строке (вместо того, чтобы просто считать количество символов “B”).
//Для этого переделайте функцию countBs.

(function () {
    function countBs(str, target) {
        var position = 0,
            counter = 0;
        while (true) {
            var foundPosition = str.indexOf(target, position);
            if (foundPosition == -1) break;
            //console.log(foundPosition);
            position = foundPosition + 1;
            counter++;
        }
        //console.log("Number of characters " + target + ": " + counter);
    }

    countBs('dabstepbbsds', 'b');
})();

//----#7
//Напишите функцию range, принимающую два аргумента, начало и конец диапазона, и возвращающую массив,
//который содержит все числа из него, включая начальное и конечное. Затем напишите функцию sum,
//принимающую массив чисел и возвращающую их сумму. Запустите указанную выше инструкцию и убедитесь,
//что она возвращает 55. В качестве бонуса дополните функцию range, чтобы она могла принимать необязательный
//третий аргумент – шаг для построения массива. Если он не задан, шаг равен единице.
//Вызов функции range(1, 10, 2) должен будет вернуть [1, 3, 5, 7, 9].
//Убедитесь, что она работает с отрицательным шагом так, что вызов range(5, 2, -1) возвращает [5, 4, 3, 2].

(function () {

    function range(start, end, step) {
        var i = start,
            arr = [];
        if (!step) {
            step = 1
        }
        if (step < 0) {
            start = end;
            end = i;
        }
        for (; i >= start && i <= end; i += step) {
            arr.push(i);
        }
        return arr;
    }

    function sum1(arr) {
        var counter = arr[0];
        for (var i = arr[0]; i < arr.length; i++) {
            counter += arr[i];
        }
        return counter
    }

    function sum2(arr) {
        var res = arr.reduce(function (sum, current) {
            return sum + current;
        }, 0);
        return res
    }

    //console.log("Sum of Array elements v1: " + sum1(range(1, 10)));  // → 55
    //console.log("Sum of Array elements v2: " + sum2(range(1, 10))); // → 55
    //console.log("Array of negative sequence: [" + range(5, 2, -1) + "]"); // → [5, 4, 3, 2]
})();

//----#8
//Обращаем массив вспять. Напишите две функции, reverseArray и reverseArrayInPlace.
//Первая получает массив как аргумент и выдаёт новый массив, с обратным порядком элементов.
//Вторая работает как оригинальный метод reverse – она меняет порядок элементов на обратный в том массиве,
//который был ей передан в качестве аргумента. Не используйте стандартный метод reverse.

(function () {
    //version 1
    function reverseArray(arr) {
        return arr.reverse();
    }

    //console.log("Revers Array: [" + reverseArray(["A", "B", "C"]) + "]"); // → ["C", "B", "A"];
    //
    //version 2
    // ?????????????????????????????????????????????????????????????????????????????????????????????????????????????
    // ?????????????????????????????????????????????????????????????????????????????????????????????????????????????
    // ?????????????????????????????????????????????????????????????????????????????????????????????????????????????
    // ?????????????????????????????????????????????????????????????????????????????????????????????????????????????
    // ?????????????????????????????????????????????????????????????????????????????????????????????????????????????
    // ?????????????????????????????????????????????????????????????????????????????????????????????????????????????
    //var arrayValue2 = [1, 2, 3, 4, 5];
    //
    //function reverseArrayInPlace(arr) {
    //    for (var i = arr.length; i--;) {
    //        arr.push(arr[i]);
    //    }
    //    return arr;
    //}
    //console.log(reverseArrayInPlace(arrayValue2)); // → [5, 4, 3, 2, 1]

    //
    //version 3
    var arrayValue = [1, 2, 3, 4, 5];
    Array.prototype.reversed = function () {
        var arr = [];
        for (var i = this.length; i--;) {
            arr.push(this[i]);
        }
        return arr;
    };

    //console.log(arrayValue.reversed());
})();


//----#9
//Список.Объекты могут быть использованы для построения различных структур данных. Часто встречающаяся структура – список
//(не путайте с массивом). Список – связанный набор объектов, где первый объект содержит ссылку на второй, второй – на
//третий, и т.п.
//Списки удобны тем, что они могут делиться частью своей структуры. Например, можно сделать два списка,
//{value: 0, rest: list} и {value: -1, rest: list}, где list – это ссылка на ранее объявленную переменную.
//Это два независимых списка, при этом у них есть общая структура list, которая включает три последних элемента
//каждого из них. Кроме того, оригинальный список также сохраняет свои свойства как отдельный список из трёх элементов.
//Напишите функцию arrayToList, которая строит такую структуру, получая в качестве аргумента [1, 2, 3],
//а также функцию listToArray, которая создаёт массив из списка. Также напишите вспомогательную функцию prepend,
//которая получает элемент и создаёт новый список, где этот элемент добавлен спереди к первоначальному списку,
//и функцию nth, которая в качестве аргументов принимает список и число, а возвращает элемент на заданной позиции
//в списке, или же undefined в случае отсутствия такого элемента. Если ваша версия nth не рекурсивна, тогда напишите её
//рекурсивную версию.

(function () {
    var list = {
        value: 1,
        rest: {
            value: 2,
            rest: {
                value: 3,
                rest: null
            }
        }
    };

    function arrayToList(arr) {
        var getValue = arr.shift();
        if (getValue === undefined) {
            return null
        }
        return {
            value: getValue,
            rest: arrayToList(arr)
        }

    }

    //function listToArray(obj) {
    //    var arr = [],
    //        counter = 0;
    //
    //    for (var key in obj) {
    //        counter++;
    //
    //        arr.push(obj[key]);
    //
    //        if (obj[key] === Object) {
    //            listToArray(obj);
    //        }
    //    }
    //
    //    console.log(counter);
    //    return arr
    //}

    //function prepend() {
    //
    //}
    //
    //function nth() {
    //
    //}

    console.log(arrayToList([10, 20, 30]));
// → {value: 10, rest: {value: 20, rest: null}}
//    console.log(listToArray(arrayToList([10, 20, 30])));
// → [10, 20, 30]
//    console.log(prepend(10, prepend(20, null)));
// → {value: 10, rest: {value: 20, rest: null}}
//    console.log(nth(arrayToList([10, 20, 30]), 1));
// → 20
})();

test