Refactor tape equiibrium solution

TapeEqulibrium/index.js

@@ -1,31 +1,3 @@
-// A non-empty array A consisting of N integers is given. Array A represents numbers on a tape. Any integer P, such that 0 < P < N, splits this tape into two non-empty parts: A[0], A[1], ..., A[P − 1] and A[P], A[P + 1], ..., A[N − 1]. The difference between the two parts is the value of: |(A[0] + A[1] + ... + A[P − 1]) − (A[P] + A[P + 1] + ... + A[N − 1])| In other words, it is the absolute difference between the sum of the rst part and the sum of the second part. For example, consider array A such that:
-// Solution
-// Programming language used: JavaScript
-// Total time used: 5 minutes
-// Effective time used: 5 minutes
-// Notes: not dened yet
-// Task timeline
-// 
-// 
-// 
-// Check out Codility training tasks
-// Anonymous
-// Test Score
-// 100 out of 100 points 100%
-// Tasks in Test
-// Time Spent Task Score
-// TapeEquilibrium Submitted in: JavaScript
-// 5 min 100%
-// Task Score Correctness Performance
-// EASY
-// 1. TapeEquilibrium Minimize the value | (A[0] + ... + A[P-1]) (A[P] + ... + A[N-1])|.
-// 100% 100% 100%
-// A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 4 A[4] = 3 We can split this tape in four places:
-// P = 1, difference = |3 − 10| = 7 P = 2, difference = |4 − 9| = 5 P = 3, difference = |6 − 7| = 1 P = 4, difference = |10 − 3| = 7
-// Write a function:
-// function solution(A);
-// that, given a non-empty array A of N integers, returns the minimal difference that can be achieved. For example, given: A[0] = 3 A[1] = 1 A[2] = 2 A[3] = 4 A[4] = 3 the function should return 1, as explained above. Write an ecient algorithm for the following assumptions:
-// N is an integer within the range [2..100,000]; each element of array A is an integer within the range [−1,000..1,000].
 
 function solution(A) {
  let sumRight = A.reduce((agg, curr, index) => agg + curr, 0)
@@ -42,3 +14,5 @@ function solution(A) {
  return min;
 }
 
+module.exports = solution;
+

TapeEqulibrium/jest.config.js

@@ -0,0 +1,180 @@
+// For a detailed explanation regarding each configuration property, visit:
+// https://jestjs.io/docs/en/configuration.html
+
+module.exports = {
+ // All imported modules in your tests should be mocked automatically
+ // automock: false,
+
+ // Stop running tests after the first failure
+ // bail: false,
+
+ // Respect "browser" field in package.json when resolving modules
+ // browser: false,
+
+ // The directory where Jest should store its cached dependency information
+ // cacheDirectory: "C:\\Users\\MAZINO~1.UKA\\AppData\\Local\\Temp\\jest",
+
+ // Automatically clear mock calls and instances between every test
+ clearMocks: true,
+
+ // Indicates whether the coverage information should be collected while executing the test
+ // collectCoverage: false,
+
+ // An array of glob patterns indicating a set of files for which coverage information should be collected
+ // collectCoverageFrom: null,
+
+ // The directory where Jest should output its coverage files
+ coverageDirectory: "coverage",
+
+ // An array of regexp pattern strings used to skip coverage collection
+ // coveragePathIgnorePatterns: [
+ // "\\\\node_modules\\\\"
+ // ],
+
+ // A list of reporter names that Jest uses when writing coverage reports
+ // coverageReporters: [
+ // "json",
+ // "text",
+ // "lcov",
+ // "clover"
+ // ],
+
+ // An object that configures minimum threshold enforcement for coverage results
+ // coverageThreshold: null,
+
+ // Make calling deprecated APIs throw helpful error messages
+ // errorOnDeprecated: false,
+
+ // Force coverage collection from ignored files usin a array of glob patterns
+ // forceCoverageMatch: [],
+
+ // A path to a module which exports an async function that is triggered once before all test suites
+ // globalSetup: null,
+
+ // A path to a module which exports an async function that is triggered once after all test suites
+ // globalTeardown: null,
+
+ // A set of global variables that need to be available in all test environments
+ // globals: {},
+
+ // An array of directory names to be searched recursively up from the requiring module's location
+ // moduleDirectories: [
+ // "node_modules"
+ // ],
+
+ // An array of file extensions your modules use
+ // moduleFileExtensions: [
+ // "js",
+ // "json",
+ // "jsx",
+ // "node"
+ // ],
+
+ // A map from regular expressions to module names that allow to stub out resources with a single module
+ // moduleNameMapper: {},
+
+ // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+ // modulePathIgnorePatterns: [],
+
+ // Activates notifications for test results
+ // notify: false,
+
+ // An enum that specifies notification mode. Requires { notify: true }
+ // notifyMode: "always",
+
+ // A preset that is used as a base for Jest's configuration
+ // preset: null,
+
+ // Run tests from one or more projects
+ // projects: null,
+
+ // Use this configuration option to add custom reporters to Jest
+ // reporters: undefined,
+
+ // Automatically reset mock state between every test
+ // resetMocks: false,
+
+ // Reset the module registry before running each individual test
+ // resetModules: false,
+
+ // A path to a custom resolver
+ // resolver: null,
+
+ // Automatically restore mock state between every test
+ // restoreMocks: false,
+
+ // The root directory that Jest should scan for tests and modules within
+ // rootDir: null,
+
+ // A list of paths to directories that Jest should use to search for files in
+ // roots: [
+ // "<rootDir>"
+ // ],
+
+ // Allows you to use a custom runner instead of Jest's default test runner
+ // runner: "jest-runner",
+
+ // The paths to modules that run some code to configure or set up the testing environment before each test
+ // setupFiles: [],
+
+ // The path to a module that runs some code to configure or set up the testing framework before each test
+ // setupTestFrameworkScriptFile: null,
+
+ // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+ // snapshotSerializers: [],
+
+ // The test environment that will be used for testing
+ testEnvironment: "node",
+
+ // Options that will be passed to the testEnvironment
+ // testEnvironmentOptions: {},
+
+ // Adds a location field to test results
+ // testLocationInResults: false,
+
+ // The glob patterns Jest uses to detect test files
+ // testMatch: [
+ // "**/__tests__/**/*.js?(x)",
+ // "**/?(*.)+(spec|test).js?(x)"
+ // ],
+
+ // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+ // testPathIgnorePatterns: [
+ // "\\\\node_modules\\\\"
+ // ],
+
+ // The regexp pattern Jest uses to detect test files
+ // testRegex: "",
+
+ // This option allows the use of a custom results processor
+ // testResultsProcessor: null,
+
+ // This option allows use of a custom test runner
+ // testRunner: "jasmine2",
+
+ // This option sets the URL for the jsdom environment. It is reflected in properties such as location.href
+ // testURL: "http://localhost",
+
+ // Setting this value to "fake" allows the use of fake timers for functions such as "setTimeout"
+ // timers: "real",
+
+ // A map from regular expressions to paths to transformers
+ // transform: null,
+
+ // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+ // transformIgnorePatterns: [
+ // "\\\\node_modules\\\\"
+ // ],
+
+ // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+ // unmockedModulePathPatterns: undefined,
+
+ // Indicates whether each individual test should be reported during the run
+ // verbose: null,
+
+ // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+ // watchPathIgnorePatterns: [],
+
+ // Whether to use watchman for file crawling
+ // watchman: true,
+};

TapeEqulibrium/package.json

@@ -0,0 +1,12 @@
+{
+ "name": "TapeEqulibrium",
+ "version": "1.0.0",
+ "description": "A non-empty array A consisting of N integers is given. Array A represents numbers on a tape.",
+ "main": "index.js",
+ "scripts": {
+ "test": "jest"
+ },
+ "keywords": [],
+ "author": "",
+ "license": "ISC"
+}

TapeEqulibrium/readme.md

@@ -0,0 +1,48 @@
+A non-empty array A consisting of N integers is given. Array A represents numbers on a tape.
+
+Any integer P, such that 0 < P < N, splits this tape into two non-empty parts:
+
+ A[0], A[1], ..., A[P − 1] and A[P], A[P + 1], ..., A[N − 1].
+
+The difference between the two parts is the value of:
+
+ |(A[0] + A[1] + ... + A[P − 1]) − (A[P] + A[P + 1] + ... + A[N − 1])|
+
+In other words, it is the absolute difference between the sum of the first part and the sum of the second part.
+
+For example, consider array A such that:
+
+ A[0] = 3
+ A[1] = 1
+ A[2] = 2
+ A[3] = 4
+ A[4] = 3
+
+We can split this tape in four places:
+
+ P = 1, difference = |3 − 10| = 7
+ P = 2, difference = |4 − 9| = 5
+ P = 3, difference = |6 − 7| = 1
+ P = 4, difference = |10 − 3| = 7
+
+Write a function:
+
+class Solution { public int solution(int[] A); }
+
+that, given a non-empty array A of N integers, returns the minimal difference that can be achieved.
+
+For example, given:
+
+ A[0] = 3
+ A[1] = 1
+ A[2] = 2
+ A[3] = 4
+ A[4] = 3
+
+the function should return 1, as explained above.
+
+Write an efficient algorithm for the following assumptions:
+
+N is an integer within the range [2..100,000];
+
+each element of array A is an integer within the range [−1,000..1,000].

TapeEqulibrium/test.spec.js

@@ -0,0 +1,9 @@
+const tapeEquilibrium = require('./index');
+
+describe('Tape Equilibrium', () => {
+ it ('returns the minimal difference in the tape equilibrium', () => {
+ expect(tapeEquilibrium([3, 1, 2, 4, 3])).toBe(1);
+ expect(tapeEquilibrium([0,0])).toBe(0);
+ })
+});
+