testsAndMisc/python_pkg/js_anki/array.json

[
 {"method":"push","tier":"core","task":"Append x to the END of arr","call":"arr.push(x)","mutates":true,"returns":"the NEW LENGTH (not the array)","example":"const a=[1,2]; const r=a.push(3); return [r,a];","expected":"[3,[1,2,3]]"},
 {"method":"pop","tier":"core","task":"Remove and get the LAST element of arr","call":"arr.pop()","mutates":true,"returns":"the removed element (undefined if empty)","example":"const a=[1,2,3]; const r=a.pop(); return [r,a];","expected":"[3,[1,2]]"},
 {"method":"unshift","tier":"core","task":"Add x to the START of arr","call":"arr.unshift(x)","mutates":true,"returns":"the NEW LENGTH","example":"const a=[2,3]; const r=a.unshift(1); return [r,a];","expected":"[3,[1,2,3]]","gotcha":"O(n): every element shifts. Don't use in hot loops."},
 {"method":"shift","tier":"core","task":"Remove and get the FIRST element of arr","call":"arr.shift()","mutates":true,"returns":"the removed element (undefined if empty)","example":"const a=[1,2,3]; const r=a.shift(); return [r,a];","expected":"[1,[2,3]]","gotcha":"O(n). A BFS queue via shift() is fine on LeetCode sizes, but use an index pointer for big inputs."},
 {"method":"splice","tier":"core","task":"Remove k elements at index i and/or insert items there, in place","call":"arr.splice(i, k, ...items)","mutates":true,"returns":"ARRAY of the removed elements","signature":"arr.splice(start, deleteCount, ...itemsToInsert)","example":"const a=[1,2,3,4]; const r=a.splice(1,2,9); return [r,a];","expected":"[[2,3],[1,9,4]]","gotcha":"Insert only: arr.splice(i, 0, x). Second arg is a COUNT, not an end index."},
 {"method":"slice","tier":"core","task":"Copy arr[i..j) into a new array","call":"arr.slice(i, j)","mutates":false,"returns":"new array (shallow copy); end is exclusive","signature":"arr.slice(start, end)  // end exclusive, negatives count from the end, slice() = shallow copy","example":"return [[1,2,3,4].slice(1,3),[1,2,3,4].slice(-2)];","expected":"[[2,3],[3,4]]"},
 {"method":"concat","tier":"core","task":"Join arrays into a new array","call":"a.concat(b, c)","mutates":false,"returns":"new array","example":"return [1].concat([2],[3,4]);","expected":"[1,2,3,4]","gotcha":"[...a, ...b] does the same."},
 {"method":"indexOf","tier":"core","task":"Find the index of x in arr (-1 if absent)","call":"arr.indexOf(x)","mutates":false,"returns":"first index, or -1","example":"return [[1,2,3].indexOf(2),[1,2,3].indexOf(9)];","expected":"[1,-1]","gotcha":"Uses ===, so it can't find NaN; includes() can."},
 {"method":"lastIndexOf","tier":"core","task":"Find the LAST index of x in arr","call":"arr.lastIndexOf(x)","mutates":false,"returns":"last index, or -1","example":"return [1,2,1].lastIndexOf(1);","expected":"2"},
 {"method":"includes","tier":"core","task":"Check whether arr contains x","call":"arr.includes(x)","mutates":false,"returns":"boolean","example":"return [[1,2,3].includes(2),[NaN].includes(NaN)];","expected":"[true,true]"},
 {"method":"find","tier":"core","task":"Get the first element matching a predicate","call":"arr.find((x) => x > 2)","mutates":false,"returns":"the element, or undefined","example":"return [1,2,3,4].find((x)=>x>2);","expected":"3"},
 {"method":"findIndex","tier":"core","task":"Get the INDEX of the first element matching a predicate","call":"arr.findIndex((x) => x > 2)","mutates":false,"returns":"index, or -1","example":"return [1,2,3,4].findIndex((x)=>x>2);","expected":"2"},
 {"method":"findLast","tier":"core","task":"Get the LAST element matching a predicate","call":"arr.findLast((x) => x < 3)","mutates":false,"returns":"the element, or undefined","example":"return [1,2,3,4].findLast((x)=>x<3);","expected":"2"},
 {"method":"filter","tier":"core","task":"Keep only elements matching a predicate","call":"arr.filter((x) => x % 2 === 0)","mutates":false,"returns":"new array","example":"return [1,2,3,4].filter((x)=>x%2===0);","expected":"[2,4]"},
 {"method":"map","tier":"core","task":"Transform every element into a new array","call":"arr.map((x, i) => x * 2)","mutates":false,"returns":"new array of same length","example":"return [1,2,3].map((x)=>x*2);","expected":"[2,4,6]","gotcha":"['1','2','3'].map(parseInt) is [1,NaN,NaN] — map passes the index as the 2nd arg. Use map(Number)."},
 {"method":"reduce","tier":"core","task":"Fold an array into one value (e.g. a sum)","call":"arr.reduce((acc, x) => acc + x, 0)","mutates":false,"returns":"the final accumulator","signature":"arr.reduce((acc, cur, idx, arr) => newAcc, initialValue)","example":"return [1,2,3].reduce((acc,x)=>acc+x,0);","expected":"6","gotcha":"Without an initial value an empty array throws TypeError."},
 {"method":"forEach","tier":"core","task":"Run a side effect for every element","call":"arr.forEach((x, i) => { ... })","mutates":false,"returns":"undefined (not chainable)","example":"const out=[]; [1,2,3].forEach((x)=>out.push(x*2)); return out;","expected":"[2,4,6]","gotcha":"Can't break/return early. Use for...of when you need that."},
 {"method":"some","tier":"core","task":"Check whether ANY element matches","call":"arr.some((x) => x > 2)","mutates":false,"returns":"boolean (short-circuits)","example":"return [[1,2,3].some((x)=>x>2),[].some((x)=>x>2)];","expected":"[true,false]"},
 {"method":"every","tier":"core","task":"Check whether ALL elements match","call":"arr.every((x) => x > 0)","mutates":false,"returns":"boolean (short-circuits)","example":"return [[1,2,3].every((x)=>x>0),[].every((x)=>x>0)];","expected":"[true,true]","gotcha":"Empty array → true."},
 {"method":"sort","tier":"core","task":"Sort numbers ascending (in place)","call":"arr.sort((a, b) => a - b)","mutates":true,"returns":"the SAME array (sorted)","signature":"arr.sort((a, b) => a - b)  // ascending; b - a = descending","example":"const a=[10,9,1]; const d=[...a].sort(); a.sort((x,y)=>x-y); return [d,a];","expected":"[[1,10,9],[1,9,10]]","gotcha":"Default sort is LEXICOGRAPHIC: [10,9,1].sort() → [1,10,9]."},
 {"method":"reverse","tier":"core","task":"Reverse an array in place","call":"arr.reverse()","mutates":true,"returns":"the SAME array (reversed)","example":"const a=[1,2,3]; const r=a.reverse(); return [r,a,r===a];","expected":"[[3,2,1],[3,2,1],true]","gotcha":"Need a copy? toReversed() or [...arr].reverse()."},
 {"method":"join","tier":"core","task":"Join array elements into a string","call":"arr.join(sep)","mutates":false,"returns":"string","example":"return [1,2,3].join('-');","expected":"\"1-2-3\"","gotcha":"Default separator is a comma, not empty. Use join('') to concatenate."},
 {"method":"flat","tier":"core","task":"Flatten nested arrays (any depth)","call":"arr.flat(Infinity)","mutates":false,"returns":"new array; default depth is 1","example":"return [1,[2,[3]]].flat(Infinity);","expected":"[1,2,3]"},
 {"method":"flatMap","tier":"core","task":"Map each element to several and flatten one level","call":"arr.flatMap((x) => [x, x * 2])","mutates":false,"returns":"new array","example":"return [1,2].flatMap((x)=>[x,x*2]);","expected":"[1,2,2,4]"},
 {"method":"fill","tier":"core","task":"Create an array of n zeros","call":"new Array(n).fill(0)","mutates":true,"returns":"the SAME array (filled)","signature":"arr.fill(value, start, end)","example":"return new Array(3).fill(0);","expected":"[0,0,0]","gotcha":"fill([]) / fill({}) shares ONE reference across all slots. Use Array.from for a 2D grid."},
 {"method":"Array.from","tier":"core","task":"Create an array of length n from a function of the index","call":"Array.from({ length: n }, (_, i) => i * i)","mutates":false,"returns":"new array","signature":"Array.from(iterableOrArrayLike, mapFn)","example":"return Array.from({length:3},(_,i)=>i*i);","expected":"[0,1,4]","gotcha":"Also converts a Set/Map/string: Array.from(set)."},
 {"method":"Array.from (2D grid)","tier":"core","task":"Create an m×n grid of zeros (rows must be independent)","call":"Array.from({ length: m }, () => Array(n).fill(0))","mutates":false,"returns":"new array of independent rows","example":"const g=Array.from({length:2},()=>Array(3).fill(0)); g[0][0]=1; return g;","expected":"[[1,0,0],[0,0,0]]","gotcha":"Array(m).fill(Array(n).fill(0)) makes every row the SAME array."},
 {"method":"Array.isArray","tier":"core","task":"Check whether a value is an array","call":"Array.isArray(x)","mutates":false,"returns":"boolean","example":"return [Array.isArray([]),Array.isArray('a')];","expected":"[true,false]","gotcha":"typeof [] is 'object', so typeof can't tell."},
 {"method":"at","tier":"core","task":"Get the LAST element (or the nth from the end)","call":"arr.at(-1)","mutates":false,"returns":"element, or undefined","example":"return [[1,2,3].at(-1),[1,2,3].at(0)];","expected":"[3,1]","gotcha":"arr[-1] is undefined — only at() takes negatives."},
 {"method":"entries","tier":"core","task":"Loop with both index and value","call":"for (const [i, x] of arr.entries()) { ... }","mutates":false,"returns":"iterator of [index, value] pairs","example":"return [...['a','b'].entries()];","expected":"[[0,\"a\"],[1,\"b\"]]"},
 {"method":"length","tier":"core","task":"Empty an array in place","call":"arr.length = 0","mutates":true,"returns":"(assignment) — array is truncated","example":"const a=[1,2,3]; a.length=0; return a;","expected":"[]","gotcha":"Aliases see the change; arr = [] only rebinds the variable."},
 {"method":"toSorted","tier":"core","task":"Get a sorted COPY (don't touch the original)","call":"arr.toSorted((a, b) => a - b)","mutates":false,"returns":"new sorted array","example":"const a=[3,1,2]; return [a.toSorted((x,y)=>x-y),a];","expected":"[[1,2,3],[3,1,2]]","gotcha":"ES2023; same lexicographic default as sort()."},
 {"method":"toReversed","tier":"core","task":"Get a reversed COPY (don't touch the original)","call":"arr.toReversed()","mutates":false,"returns":"new reversed array","example":"const a=[1,2,3]; return [a.toReversed(),a];","expected":"[[3,2,1],[1,2,3]]"},
 {"method":"findLastIndex","tier":"rare","task":"Get the INDEX of the last element matching a predicate","call":"arr.findLastIndex((x) => x < 3)","mutates":false,"returns":"index, or -1","example":"return [1,2,3,4].findLastIndex((x)=>x<3);","expected":"1"},
 {"method":"reduceRight","tier":"rare","task":"Fold an array from right to left","call":"arr.reduceRight((acc, x) => acc + x, '')","mutates":false,"returns":"the final accumulator","example":"return ['a','b','c'].reduceRight((acc,x)=>acc+x,'');","expected":"\"cba\""},
 {"method":"copyWithin","tier":"rare","task":"Copy part of the array onto another part of itself, in place","call":"arr.copyWithin(target, start, end)","mutates":true,"returns":"the SAME array","signature":"arr.copyWithin(target, start, end)","example":"return [1,2,3,4,5].copyWithin(0,3);","expected":"[4,5,3,4,5]"},
 {"method":"keys","tier":"rare","task":"Iterate over the indices of an array","call":"arr.keys()","mutates":false,"returns":"iterator of indices","example":"return [...['a','b','c'].keys()];","expected":"[0,1,2]"},
 {"method":"values","tier":"rare","task":"Iterate over the values of an array as an iterator","call":"arr.values()","mutates":false,"returns":"iterator of values","example":"return [...['a','b'].values()];","expected":"[\"a\",\"b\"]"},
 {"method":"toSpliced","tier":"rare","task":"Get a COPY with items removed/inserted (splice without mutation)","call":"arr.toSpliced(i, k, ...items)","mutates":false,"returns":"new array","signature":"arr.toSpliced(start, deleteCount, ...items)","example":"const a=[1,2,3,4]; return [a.toSpliced(1,2,9),a];","expected":"[[1,9,4],[1,2,3,4]]"},
 {"method":"with","tier":"rare","task":"Get a COPY with one index replaced","call":"arr.with(i, v)","mutates":false,"returns":"new array","example":"const a=[1,2,3]; return [a.with(1,9),a];","expected":"[[1,9,3],[1,2,3]]"},
 {"method":"Array.of","tier":"rare","task":"Create an array from the given arguments","call":"Array.of(7)","mutates":false,"returns":"new array","example":"return [Array.of(7),Array(3).length];","expected":"[[7],3]","gotcha":"Array(7) makes 7 empty slots; Array.of(7) makes [7]."}
]