Solution 1 (Click to Show/Hide)
+ +```javascript +function knightTour (w, h) { + var b, cnt=0; + + var dx = [ -2, -2, -1, 1, 2, 2, 1, -1 ]; + var dy = [ -1, 1, 2, 2, 1, -1, -2, -2 ]; + + function init_board() + { + var i, j, k, x, y; + // * b is board; a is board with 2 rows padded at each side + + for(i=0;iSolution 1 (Click to Show/Hide)
+ +```javascript +function maxCombine(xs) { + return parseInt( + xs.sort( + function(x, y) { + var a = x.toString(), + b = y.toString(), + ab = parseInt(a + b), + ba = parseInt(b + a); + + return ab > ba ? -1 : (ab < ba ? 1 : 0); + } + ) + .join(''), 10 + ); +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function lastFriday (year, month) { + var i, last_day; + i = 0; + while (true) { + last_day = new Date(year, month, i); + if (last_day.getDay() === 5) { + return last_day.getDate(); + } + i -= 1; + } +}; +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function isLeapYear (year) { + return (year % 100 === 0) ? (year % 400 === 0) : (year % 4 === 0); +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function LCM (A) { + var n = A.length, a = Math.abs(A[0]); + for (var i = 1; i < n; i++) + { var b = Math.abs(A[i]), c = a; + while (a && b){ a > b ? a %= b : b %= a; } + a = Math.abs(c*A[i])/(a+b); + } + return a; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function leftFactorial(n) { + if (n == 0) + return 0 + if (n == 1) + return 1; + + // Note: for n>=20, the result may not be correct. + // This is because JavaScript uses 53 bit integers and + // for n>=20 result becomes too large. + + let res = 2, fact = 2; + for (var i = 2; i < n; i++) { + res += fact; + fact *= (i + 1); + } + + return res; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function sortByKey (arr) { + return arr.sort(function(a, b) { + return a.key - b.key + }); +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function sortDisjoint(values, indices) { + let sublist = []; + + indices.sort(function (a, b) { return a - b; }); + + for (let i = 0; i < indices.length; i++) { + sublist.push(values[indices[i]]); + } + + sublist.sort((a, b) => { return a - b; }); + + for (let i = 0; i < indices.length; i++) { + values[indices[i]] = sublist[i]; + } + + return values; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function stableSort(arr) { + arr.sort(function(a, b) { return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0)) }); + return arr; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function lengthSorter(arr) { + arr.sort(function(a, b) { + var result = b.length - a.length; + if (result == 0) + result = a.localeCompare(b); + return result; + }) + return arr; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function beadSort(arr) { + var max = 0; + for (var i = 0; i < arr.length; i++) + if (arr[i] > max) + max = arr[i];; + var grid = new Array(arr.length); + for (var i = 0; i < grid.length; i++) { + grid[i] = new Array(max); + } + var levelcount = new Array(max); + levelcount.fill(0) + for (var i = 0; i < max; i++) { + levelcount[i] = 0; + for (var j = 0; j < arr.length; j++) + grid[j][i] = '_'; + }; + for (var i = 0; i < arr.length; i++) { + var num = arr[i]; + for (var j = 0; num > 0; j++) { + grid[levelcount[j]++][j] = '*'; + num--; + }; + }; + var sorted = new Array(arr.length) + sorted.fill(0) + for (var i = 0; i < arr.length; i++) { + var putt = 0; + for (var j = 0; j < max && (function(c) { + return c.charCodeAt == null ? c : c.charCodeAt(0); + })(grid[arr.length - 1 - i][j]) == '*'.charCodeAt(0); j++) + putt++; + sorted[i] = putt; + }; + return sorted; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function bogosort(v) { + function shuffle(v) { + for (var j, x, i = v.length; i; j = Math.floor(Math.random() * i), x = v[--i], v[i] = v[j], v[j] = x); + return v; + }; + + function isSorted(v) { + for (var i = 1; i < v.length; i++) { + if (v[i - 1] > v[i]) { + return false; + } + } + return true; + } + var sorted = false; + while (sorted == false) { + v = shuffle(v); + sorted = isSorted(v); + } + return v; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function cocktailSort(arr) { + let isSorted = true; + while (isSorted) { + for (let i = 0; i < arr.length - 1; i++) { + if (arr[i] > arr[i + 1]) { + let temp = arr[i]; + arr[i] = arr[i + 1]; + arr[i + 1] = temp; + isSorted = true; + } + } + + if (!isSorted) + break; + + isSorted = false; + + for (let j = arr.length - 1; j > 0; j--) { + if (arr[j - 1] > arr[j]) { + let temp = arr[j]; + arr[j] = arr[j - 1]; + arr[j - 1] = temp; + isSorted = true; + } + } + } + + return arr; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function combSort(arr) { + function is_array_sorted(arr) { + var sorted = true; + for (var i = 0; i < arr.length - 1; i++) { + if (arr[i] > arr[i + 1]) { + sorted = false; + break; + } + } + return sorted; + } + var iteration_count = 0; + var gap = arr.length - 2; + var decrease_factor = 1.25; + + // Until array is not sorted, repeat iterations + while (!is_array_sorted(arr)) { + // If not first gap + if (iteration_count > 0) + // Calculate gap + gap = (gap == 1) ? gap : Math.floor(gap / decrease_factor); + + // Set front and back elements and increment to a gap + var front = 0; + var back = gap; + while (back <= arr.length - 1) { + // If elements are not ordered swap them + if (arr[front] > arr[back]) { + var temp = arr[front]; + arr[front] = arr[back]; + arr[back] = temp; + } + + // Increment and re-run swapping + front += 1; + back += 1; + } + iteration_count += 1; + } + + return arr; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function gnomeSort(a) { + function moveBack(i) { + for (; i > 0 && a[i - 1] > a[i]; i--) { + var t = a[i]; + a[i] = a[i - 1]; + a[i - 1] = t; + } + } + for (var i = 1; i < a.length; i++) { + if (a[i - 1] > a[i]) moveBack(i); + } + return a; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function pancakeSort(arr) { + for (var i = arr.length - 1; i >= 1; i--) { + // find the index of the largest element not yet sorted + var max_idx = 0; + var max = arr[0]; + for (var j = 1; j <= i; j++) { + if (arr[j] > max) { + max = arr[j]; + max_idx = j; + } + } + + if (max_idx == i) + continue; // element already in place + + var new_slice; + + // flip arr max element to index 0 + if (max_idx > 0) { + new_slice = arr.slice(0, max_idx + 1).reverse(); + for (var j = 0; j <= max_idx; j++) + arr[j] = new_slice[j]; + } + + // then flip the max element to its place + new_slice = arr.slice(0, i + 1).reverse(); + for (var j = 0; j <= i; j++) + arr[j] = new_slice[j]; + } + return arr; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function permutationSort(arr) { + function pSort(a) { + var list = []; + permute(a, a.length, list); + for (var i = 0; i < list.length; i++) { + var x = list[i]; + if (isSorted(x)) + return x; + } + return a; + }; + + function permute(a, n, list) { + if (n === 1) { + var b = a.slice(); + list.push(b); + return; + } + for (var i = 0; i < n; i++) { + swap(a, i, n - 1); + permute(a, n - 1, list); + swap(a, i, n - 1); + }; + }; + + function isSorted(a) { + for (var i = 1; i < a.length; i++) + if (a[i - 1] > a[i]) + return false;; + return true; + }; + + function swap(arr, i, j) { + var temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + }; + return pSort(arr); +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function shellSort(a) { + for (var h = a.length; h > 0; h = parseInt(h / 2)) { + for (var i = h; i < a.length; i++) { + var k = a[i]; + for (var j = i; j >= h && k < a[j - h]; j -= h) + a[j] = a[j - h]; + a[j] = k; + } + } + return a; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function stoogeSort(arr) { + function stoogeSortRecurse(array, i, j) { + if (j === undefined) { + j = array.length - 1; + } + + if (i === undefined) { + i = 0; + } + + if (array[j] < array[i]) { + var aux = array[i]; + array[i] = array[j]; + array[j] = aux; + } + + if (j - i > 1) { + var t = Math.floor((j - i + 1) / 3); + stoogeSortRecurse(array, i, j - t); + stoogeSortRecurse(array, i + t, j); + stoogeSortRecurse(array, i, j - t); + } + } + stoogeSortRecurse(arr); + return arr; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function strandSort(list) { + + function merge(left, right) { + var result = []; + while (left.length != 0 && right.length != 0) { + if (left[0] <= right[0]) + result.push(left.shift()); + else + result.push(right.shift()); + } + result.push.apply(result, left); + result.push.apply(result, right); + return result; + } + + if (list.length <= 1) return list; + var result = []; + while (list.length > 0) { + var sorted = []; + sorted.push(list.shift()); + var len = list.length; + for (var i = 1; i < len; i++) { + var elem = list[i]; + if (sorted[i - 1] <= elem) { + sorted.push(elem); + sorted.splice(i, 1); + } + } + + result = merge(result, sorted); + } + return result; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function soundex(s) { + var a = s.toLowerCase().split('') + var f = a.shift(), + r = '', + codes = { + a: '', e: '', i: '', o: '', u: '', + b: 1, f: 1, p: 1, v: 1, + c: 2, g: 2, j: 2, k: 2, q: 2, s: 2, x: 2, z: 2, + d: 3, t: 3, + l: 4, + m: 5, n: 5, + r: 6 + }; + r = f + a + .map(function(v, i, a) { + return codes[v] + }) + .filter(function(v, i, a) { + return ((i === 0) ? v !== codes[f] : v !== a[i - 1]); + }) + .join(''); + + return (r + '000').slice(0, 4).toUpperCase(); +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function spiralArray(n) { + var arr = Array(n), + x = 0, y = n, + total = n * n--, + dx = 1, dy = 0, + i = 0, j = 0; + while (y) arr[--y] = []; + while (i < total) { + arr[y][x] = i++; + x += dx; y += dy; + if (++j == n) { + if (dy < 0) { x++; y++; n -= 2 } + j = dx; dx = -dy; dy = j; j = 0; + } + } + return arr; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function split(str) { + const concat = xs => + xs.length > 0 ? (() => { + const unit = typeof xs[0] === 'string' ? '' : []; + return unit.concat.apply(unit, xs); + })() : []; + + const group = xs => groupBy((a, b) => a === b, xs); + + const groupBy = (f, xs) => { + const dct = xs.slice(1) + .reduce((a, x) => { + const + h = a.active.length > 0 ? a.active[0] : undefined, + blnGroup = h !== undefined && f(h, x); + return { + active: blnGroup ? a.active.concat([x]) : [x], + sofar: blnGroup ? a.sofar : a.sofar.concat([a.active]) + }; + }, { + active: xs.length > 0 ? [xs[0]] : [], + sofar: [] + }); + return dct.sofar.concat(dct.active.length > 0 ? [dct.active] : []); + }; + + const map = (f, xs) => xs.map(f); + + const stringChars = s => s.split(''); + + return map(concat, group(stringChars(str))) +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function solve(input) { + var orig = {}; + input.forEach(function(e) { + orig[e.replace(/\s/g, "").toLowerCase()] = e; + }) + + input = Object.keys(orig) + var map = {}; + for (var i = 0; i < input.length - 1; i++) { + var pair0 = input[i]; + for (var j = i + 1; j < input.length; j++) { + + var pair = [pair0, input[j]]; + var s = pair0 + pair[1]; + var key = s.split("").sort(); + + var val = map[key] ? map[key] : []; + val.push(pair); + map[key] = val; + } + } + + var result = []; + Object.keys(map).forEach((key) => { + + for (var i = 0; i < map[key].length - 1; i++) { + var a = map[key][i]; + for (var j = i + 1; j < map[key].length; j++) { + var b = map[key][j]; + + if ((new Set([a[0], b[0], a[1], b[1]])).size < 4) + continue; + var from = [orig[a[0]], orig[a[1]]].sort() + var to = [orig[b[0]], orig[b[1]]].sort() + result.push({ + from, + to + }) + } + } + }); + + return result; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function sternBrocot(num) { + function f(n) { + return n < 2 ? n : (n & 1) ? f(Math.floor(n / 2)) + f(Math.floor(n / 2 + 1)) : f(Math.floor(n / 2)); + } + + function gcd(a, b) { + return a ? a < b ? gcd(b % a, a) : gcd(a % b, b) : b; + } + var n; + for (n = 1; f(n) != num; n++); + return n; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function straddle(message, alphabet) { + var prefixes = new Array("", alphabet[0].indexOf(" "), alphabet[0].lastIndexOf(" ")) + + var out = "" + message = message.toUpperCase() + message = message.replace(/([0-9])/g, "/$1") // dumb way to escape numbers + for (var i = 0; i < message.length; i++) { + var chr = message[i] + if (chr == " ") continue + for (var j = 0; j < 3; j++) { + var k = alphabet[j].indexOf(chr) + if (k < 0) continue + out += prefixes[j].toString() + k + } + if (chr == "/") out += message[++i] + } + return out +} +function unstraddle(message, alphabet) { + var prefixes = new Array("", alphabet[0].indexOf(" "), alphabet[0].lastIndexOf(" ")) + var out = "" + var n, o + for (var i = 0; i < message.length; i++) { + n = message[i] * 1 + switch (n) { + case prefixes[1]: + o = alphabet[1][message[++i]]; + break + case prefixes[2]: + o = alphabet[2][message[++i]]; + break + default: + o = alphabet[0][n] + } + o == "/" ? out += message[++i] : out += o + } + return out +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function mergeLists(lists) { + function merge (l1, l2) { + var result = [], i=0, j=0; + while (l1.length && l2.length) { + if(l1[i]<=l2[j]){ + result.push(l1.shift()); + }else{ + result.push(l2.shift()); + } + } + + result.push.apply(result, l1); + result.push.apply(result, l2); + return result; + } + + var result=lists[0]; + for (var i = 1; i < lists.length; i++) { + result=merge(result, lists[i]); + } + + return result; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function strip(s) { + return s.split('').filter(function(x) { + var n = x.charCodeAt(0); + + return 31 < n && 127 > n; + }).join(''); +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function Subleq(mem) { + var out = ""; + var instructionPointer = 0; + do { + var a = mem[instructionPointer]; + var b = mem[instructionPointer + 1]; + if (a === -1) {} else if (b === -1) { + out += String.fromCharCode(mem[a]); + } else { + mem[b] -= mem[a]; + if (mem[b] < 1) { + instructionPointer = mem[instructionPointer + 2]; + continue; + } + } + instructionPointer += 3; + } while ((instructionPointer >= 0)); + + return out; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function solveSudoku(puzzle) { + var solution; + + class DoX { + constructor(V, H) { + this.V = V; + this.L = this; + this.R = this; + this.U = this; + this.D = this; + this.S = 1; + this.H = H || this; + H && (H.S += 1); + } + } + + const addRight = (e, n) => { + n.R = e.R; + n.L = e; + e.R.L = n; + return e.R = n; + }; + + const addBelow = (e, n) => { + n.D = e.D; + n.U = e; + e.D.U = n; + return e.D = n; + }; + + const search = function(h, s) { + if (h.R == h) { + printSol(s); + } else { + let c = chooseColumn(h); + cover(c); + for (let r = c.D; r != c; r = r.D) { + s.push(r); + for (let j = r.R; r != j; j = j.R) { + cover(j.H); + } + search(h, s); + r = s.pop(); + for (let j = r.R; j != r; j = j.R) { + uncover(j.H); + } + } + uncover(c); + } + }; + + const chooseColumn = h => { + let s = Number.POSITIVE_INFINITY; + let c = h; + for (let j = h.R; j != h; j = j.R) { + if (j.S < s) { + c = j; + s = j.S; + } + } + return c; + }; + + const cover = c => { + c.L.R = c.R; + c.R.L = c.L; + for (let i = c.D; i != c; i = i.D) { + for (let j = i.R; j != i; j = j.R) { + j.U.D = j.D; + j.D.U = j.U; + j.H.S = j.H.S - 1; + } + } + }; + + const uncover = c => { + for (let i = c.U; i != c; i = i.U) { + for (let j = i.L; i != j; j = j.L) { + j.H.S = j.H.S + 1; + j.U.D = j; + j.D.U = j; + } + } + c.L.R = c; + c.R.L = c; + }; + + const printSol = a => { + solution = a.reduce((p, c) => { + let [i, v] = c.V.split(':'); + p[i * 1] = v; + return p; + }, new Array(a.length).fill('.')); + }; + + const gridMeta = s => { + const g = s.split(''); + const cellCount = g.length; + const tokenCount = Math.sqrt(cellCount); + const N = Math.sqrt(tokenCount); + const g2D = g.map(e => isNaN(e * 1) ? + new Array(tokenCount).fill(1).map((_, i) => i + 1) : [e * 1]); + return [cellCount, N, tokenCount, g2D]; + }; + + const indexesN = n => i => { + let c = Math.floor(i / (n * n)); + i %= n * n; + return [c, i, Math.floor(c / n) * n + Math.floor(i / n)]; + }; + + const reduceGrid = puzString => { + + const [ + numCells, // The total number of cells in a grid (81 for a 9x9 grid) + N, // the 'n' value of the grid. (3 for a 9x9 grid) + U, // The total number of unique tokens to be placed. + g2D // A 2D array representation of the grid, with each element + // being an array of candidates for a cell. Known cells are + // single element arrays. + ] = gridMeta(puzString); + + const getIndex = indexesN(N); + + const headRow = new Array(4 * numCells) + .fill('') + .map((_, i) => new DoX(`H${i}`)); + + let H = new DoX('ROOT'); + headRow.reduce((p, c) => addRight(p, c), H); + + for (let i = 0; i < numCells; i++) { + const [ri, ci, bi] = getIndex(i); + g2D[i].forEach(num => { + let id = `${i}:${num}`; + let candIdx = num - 1; + + // The 4 columns that we will populate. + const A = headRow[i]; + const B = headRow[numCells + candIdx + (ri * U)]; + const C = headRow[(numCells * 2) + candIdx + (ci * U)]; + const D = headRow[(numCells * 3) + candIdx + (bi * U)]; + + // The Row-Column Constraint + let rcc = addBelow(A.U, new DoX(id, A)); + + // The Row-Number Constraint + let rnc = addBelow(B.U, addRight(rcc, new DoX(id, B))); + + // The Column-Number Constraint + let cnc = addBelow(C.U, addRight(rnc, new DoX(id, C))); + + // The Block-Number Constraint + addBelow(D.U, addRight(cnc, new DoX(id, D))); + }); + } + search(H, []); + }; + + var stringPuzzle = ""; + + for (var i = 0; i < puzzle.length; i++) { + puzzle[i].forEach(function(e) { + if (e == -1) + stringPuzzle += "."; + else + stringPuzzle += e; + }) + } + + reduceGrid(stringPuzzle) + + var result = []; + + for (var i = 0; i < 9; i++) { + result.push(solution.slice(i * 9, (i + 1) * 9).map(e => parseInt(e))) + } + + return result; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function sumDigits(n) { + n += '' + for (var s=0, i=0, e=n.length; iSolution 1 (Click to Show/Hide)
+ +```javascript +function sumMults(n) { + var sum = 0; + for (var i = 1; i < n; i++) { + if (i % 3 == 0 || i % 5 == 0) sum += i; + } + return sum; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function sum(a, b) { + function fn(x) { + return 1 / (x * x) + } + var s = 0; + for (; a <= b; a++) s += fn(a); + return s; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function sumsq(array) { + var sum = 0; + var i, iLen; + + for (i = 0, iLen = array.length; i < iLen; i++) { + sum += array[i] * array[i]; + } + return sum; +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function sumTo100(n) { + var permutationsWithRepetition = function(n, as) { + return as.length > 0 ? + foldl1(curry(cartesianProduct)(as), replicate(n, as)) : []; + }; + + var cartesianProduct = function(xs, ys) { + return [].concat.apply([], xs.map(function(x) { + return [].concat.apply([], ys.map(function(y) { + return [ + [x].concat(y) + ]; + })); + })); + }; + + var curry = function(f) { + return function(a) { + return function(b) { + return f(a, b); + }; + }; + }; + + var flip = function(f) { + return function(a, b) { + return f.apply(null, [b, a]); + }; + }; + + var foldl1 = function(f, xs) { + return xs.length > 0 ? xs.slice(1) + .reduce(f, xs[0]) : []; + }; + + var replicate = function(n, a) { + var v = [a], + o = []; + if (n < 1) return o; + while (n > 1) { + if (n & 1) o = o.concat(v); + n >>= 1; + v = v.concat(v); + } + return o.concat(v); + }; + + var asSum = function(xs) { + var dct = xs.reduceRight(function(a, sign, i) { + var d = i + 1; // zero-based index to [1-9] positions + if (sign !== 0) { + // Sum increased, digits cleared + return { + digits: [], + n: a.n + sign * parseInt([d].concat(a.digits) + .join(''), 10) + }; + } else return { // Digits extended, sum unchanged + digits: [d].concat(a.digits), + n: a.n + }; + }, { + digits: [], + n: 0 + }); + return dct.n + ( + dct.digits.length > 0 ? parseInt(dct.digits.join(''), 10) : 0 + ); + }; + + var asString = function(xs) { + var ns = xs.reduce(function(a, sign, i) { + var d = (i + 1) + .toString(); + return sign === 0 ? a + d : a + (sign > 0 ? '+' : '-') + d; + }, ''); + + return ns[0] === '+' ? tail(ns) : ns; + }; + + var universe = permutationsWithRepetition(9, [0, 1, -1]) + .filter(function(x) { + return x[0] !== 1 && asSum(x) === n; + }).map(asString); + return universe.sort() +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function clip(subjectPolygon, clipPolygon) { + var cp1, cp2, s, e, i, j; + var inside = function(p) { + return (cp2[0] - cp1[0]) * (p[1] - cp1[1]) > (cp2[1] - cp1[1]) * (p[0] - cp1[0]); + }; + var intersection = function() { + var dc = [cp1[0] - cp2[0], cp1[1] - cp2[1]], + dp = [s[0] - e[0], s[1] - e[1]], + n1 = cp1[0] * cp2[1] - cp1[1] * cp2[0], + n2 = s[0] * e[1] - s[1] * e[0], + n3 = 1.0 / (dc[0] * dp[1] - dc[1] * dp[0]); + return [(n1 * dp[0] - n2 * dc[0]) * n3, (n1 * dp[1] - n2 * dc[1]) * n3]; + }; + var outputList = subjectPolygon; + cp1 = clipPolygon[clipPolygon.length - 1]; + for (j in clipPolygon) { + var cp2 = clipPolygon[j]; + var inputList = outputList; + outputList = []; + s = inputList[inputList.length - 1]; //last on the input list + for (i in inputList) { + var e = inputList[i]; + if (inside(e)) { + if (!inside(s)) { + outputList.push(intersection()); + } + outputList.push(e); + } else if (inside(s)) { + outputList.push(intersection()); + } + s = e; + } + cp1 = cp2; + } + return outputList.map(e => e.map(f => Math.round(f * 1000) / 1000)); +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +function symmetricDifference(A, B) { + function relative_complement(A, B) { + return A.filter(function(elem) { + return B.indexOf(elem) == -1 + }); + } + + function unique(ary) { + var u = ary.concat().sort(); + for (var i = 1; i < u.length;) { + if (u[i - 1] === u[i]) + u.splice(i, 1); + else + i++; + } + return u; + } + + return unique(relative_complement(A, B).concat(relative_complement(B, A))).sort(); +} +``` + +Solution 1 (Click to Show/Hide)
- +```javascript +function dotProduct(...vectors) { + if (!vectors || !vectors.length) { + return null; + } + if (!vectors[0] || !vectors[0].length) { + return null; + } + const vectorLen = vectors[0].length; + const numVectors = vectors.length; + + // If all vectors not same length, return null + for (let i = 0; i < numVectors; i++) { + if (vectors[i].length !== vectorLen) { + return null; // return undefined + } + } + + let prod = 0; + let sum = 0; + let j = vectorLen; + let i = numVectors; + // Sum terms + while (j--) { + i = numVectors; + prod = 1; + + while (i--) { + prod *= vectors[i][j]; + } + sum += prod; + } + return sum; +} +``` + +longitude: " + position.coords.longitude); + + }); + +} +``` diff --git a/guide/english/certifications/data-visualization/json-apis-and-ajax/get-json-with-the-javascript-fetch-method/index.md b/guide/english/certifications/data-visualization/json-apis-and-ajax/get-json-with-the-javascript-fetch-method/index.md new file mode 100644 index 0000000000..78292a3bea --- /dev/null +++ b/guide/english/certifications/data-visualization/json-apis-and-ajax/get-json-with-the-javascript-fetch-method/index.md @@ -0,0 +1,60 @@ +--- +title: Get JSON with the JavaScript fetch method +--- +# Get JSON with the JavaScript fetch method + +--- +## Solutions + +
Solution 1 (Click to Show/Hide)
+ +```html + + +Cat Photo Finder
++ The message will go here +
++ +
+``` + +Solution 1 (Click to Show/Hide)
- +```html + + +Cat Photo Finder
+ ++ +
+``` + +Solution 1 (Click to Show/Hide)
- +```html + + + +
+ 
+
+ 
+
+
+
+
+```
+
+CatPhotoApp
+ +Click here for cat photos.
+ +Things cats love:
+-
+
- cat nip +
- laser pointers +
- lasagna +
Top 3 things cats hate:
+-
+
- flea treatment +
- thunder +
- other cats +
Solution 1 (Click to Show/Hide)
+ +```html + + + + +
+
+```
+
+jQuery Playground
+
+
+
+
+ #left-well
+
+
+
+
+
+
+
+ #right-well
+
+
+
+
+
+ Solution 1 (Click to Show/Hide)
+ +```jsx +class MyComponent extends React.Component { + constructor(props) { + super(props); + this.state = { + display: true + } + this.toggleDisplay = this.toggleDisplay.bind(this); + } + toggleDisplay() { + this.setState({ + display: !this.state.display + }); + } + render() { + // change code below this line + if (this.state.display) { + return ( +
+
+
+ );
+ } else {
+ return (
+ Displayed!
+
+
+
+ );
+ }
+ }
+};
+```
+
+Solution 1 (Click to Show/Hide)
```javascript -var quotient = 0.6 / 0.3; //quotient gets the value 2 +var quotient = 4.4 / 2.0; // Fix this line ```Solution 1 (Click to Show/Hide)
+ +```javascript +function rangeOfNumbers(startNum, endNum) { + if (endNum - startNum === 0) { + return [startNum]; + } else { + var numbers = rangeOfNumbers(startNum, endNum - 1); + numbers.push(endNum); + return numbers; + } +} +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +const makeServerRequest = new Promise((resolve, reject) => { + // responseFromServer represents a response from a server + let responseFromServer; + + if(responseFromServer) { + resolve("We got the data"); + } else { + reject("Data not received"); + } +}); +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +const makeServerRequest = new Promise((resolve, reject) => { + +}); +``` + +Solution 1 (Click to Show/Hide)
+ +```html + + + + + + + +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +const makeServerRequest = new Promise((resolve, reject) => { + // responseFromServer is set to true to represent a successful response from a server + let responseFromServer = true; + + if(responseFromServer) { + resolve("We got the data"); + } else { + reject("Data not received"); + } +}); + +makeServerRequest.then(result => { + console.log(result); +}); +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +const makeServerRequest = new Promise((resolve, reject) => { + // responseFromServer is set to false to represent an unsuccessful response from a server + let responseFromServer = false; + + if(responseFromServer) { + resolve("We got the data"); + } else { + reject("Data not received"); + } +}); + +makeServerRequest.then(result => { + console.log(result); +}); + +makeServerRequest.catch(error => { + console.log(error); +}); +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +import { uppercaseString, lowercaseString } from './string_functions.js'; +// add code above this line + +uppercaseString("hello"); +lowercaseString("WORLD!"); +``` + +Solution 1 (Click to Show/Hide)
-#### More Information: - +```javascript +const HIGH_TEMPERATURES = { + yesterday: 75, + today: 77, + tomorrow: 80 +}; + +// change code below this line + +const { today: highToday, tomorrow: highTomorrow } = HIGH_TEMPERATURES; + +// change code above this line + +console.log(highToday); // should be 77 +console.log(highTomorrow); // should be 80 +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +const HIGH_TEMPERATURES = { + yesterday: 75, + today: 77, + tomorrow: 80 +}; + +// change code below this line + +const { today, tomorrow } = HIGH_TEMPERATURES; + +// change code above this line + +console.log(yesterday) // should be not defined +console.log(today); // should be 77 +console.log(tomorrow); // should be 80 +``` + +Solution 1 (Click to Show/Hide)
+ +```javascript +export const uppercaseString = (string) => { + return string.toUpperCase(); +} + +export const lowercaseString = (string) => { + return string.toLowerCase() +} +``` + +Solution 1 (Click to Show/Hide)
- - -In the ```:root``` selector we need to declare the ```--penguin-belly``` variable and give it the value of ```pink```: - -```css - :root { - --penguin-belly: pink; - } -``` - -#### Relevant Links - -1. [Visit MDN's Cascading CSS Variables page for more information.](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_variables) -2. [Perna, Maria Antonietta. "A Practical Guide to CSS Variables (Custom Properties)" *sitepoint*. August 01, 2018. Accessed: October 5, 2018](https://www.sitepoint.com/practical-guide-css-variables-custom-properties/) -Solution 1 (Click to Show/Hide)
+ + +In the ```:root``` selector we need to declare the ```--penguin-belly``` variable and give it the value of ```pink```: + +```html + +
+
+```
+
+#### Relevant Links
+
+1. [Visit MDN's Cascading CSS Variables page for more information.](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_variables)
+2. [Perna, Maria Antonietta. "A Practical Guide to CSS Variables (Custom Properties)" *sitepoint*. August 01, 2018. Accessed: October 5, 2018](https://www.sitepoint.com/practical-guide-css-variables-custom-properties/)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+