Nodejs Array Swap swap(x, y)

Here you can find the source of swap(x, y)

Method Source Code

Array.prototype.swap = function (x, y) {
    var b = this[x];
    this[x] = this[y];//from  ww w.  ja va  2 s.c  o m
    this[y] = b;
    return this;
};

Related

  1. swap(indexA, indexB)
    export default function stringPermutation(string) {
      let permutations = []
      function recursivePermutations(array, index) {
        if(index === array.length) {
          permutations.push(array.join(''))
          return
        for (let i = index; i < array.length; i++) {
          let copy = array.slice(0)
    ...
    
  2. swap(index_A, index_B)
    Array.prototype.swap = function(index_A, index_B) {
        var input = this;
        var temp = input[index_A];
        input[index_A] = input[index_B];
        input[index_B] = temp;
    
  3. swap(one, two)
    Array.prototype.swap = function (one, two) {
      var tmp = this[one];
      this[one] = this[two];
      this[two] = tmp;
    function randInt (low, high) {
      return Math.floor(Math.random() * (high - low + 1)) + low;
    function randChar () {
    ...
    
  4. swap(pos1, pos2)
    Array.prototype.swap = function(pos1, pos2) {
      var temp = this[pos1];
      this[pos1] = this[pos2];
      this[pos2] = temp;
    
  5. swap(sIdx, tIdx )
    ;"use strict";
    var log=function(msg){console.log(msg);};
    var alert=function(msg){log(msg);};
    var arr = [3,6,7,5,3,6,2,9,1,5,33,-12,0,-122,-Infinity, 125, 33, 55, 77];
    Array.prototype.swap = function (sIdx, tIdx ) {
      var tmp = this[sIdx];
      this[sIdx] = this[tIdx];
      this[tIdx] = tmp; 
    Array.prototype.quickSort = function () {
      function _quickSort(arr, leftIdx, rightIdx) {
        if(leftIdx < rightIdx) {
          var pivot = arr[leftIdx],
          chkLeftIdx = leftIdx,
          chkRightIdx = rightIdx;
          while(chkLeftIdx < chkRightIdx) {
            while(arr[chkRightIdx] > pivot) {
              chkRightIdx--;
            while(chkLeftIdx < chkRightIdx && arr[chkLeftIdx] <= pivot) {
              chkLeftIdx++;
            arr.swap(chkLeftIdx, chkRightIdx);
          arr.swap(leftIdx, chkLeftIdx);
          _quickSort(arr, leftIdx, chkLeftIdx-1);
          _quickSort(arr, chkLeftIdx+1, rightIdx);
        return arr;
      return _quickSort(this, 0, this.length -1);
    };
    console.log(arr.sort());
    console.log(arr.quickSort());
    
  6. swap(x, y)
    function MathDist(xo, yo, x, y) {
      return Math.sqrt((x-xo)*(x-xo) + (y-yo)*(y-yo));
    function MathVecNorm(vx, vy) {
      return Math.sqrt(vx*vx + vy*vy);
    function MathDotProduct(a1, a2, b1, b2) {
      return a1*b1 + a2*b2;
    function MathSign(n) {
      return (n >= 0) ? 1 : -1;
    const MAX_RADIUS = 50.0;
    const MIN_RADIUS = 5;
    const MAX_DENSITY = 8.00 * 1/1963.495;
    const MIN_DENSITY =  0.50 * 1/1963.495;
    Array.prototype.swap = function (x, y) {
      var b = this[x];
      this[x] = this[y];
      this[y] = b;
      return this;
    function NewArray2d(rows, columns) {
       var array = new Array(rows);
       for (var i = 0; i < rows; i++) {
           array[i] = new Array(columns);
       return array;
    
  7. swap(x, y)
    "use strict";
    function Median(A) {
        var n = A.length;
        if (n == 1) {
            return A[0];
        } else {
            return Select(A, 0, Math.floor(n / 2), n - 1);
    function Select(A, l, m, h) {
        var pos = Partition(A, l, h);
        if (pos == m) {
            return A[pos];
        } else if (pos > m) {
            return Select(A, l, m, pos - 1);
        } else if (pos < m) {
            return Select(A, pos + 1, m, h);
    function Partition(A, l, h) {
        var pivotval = A[l];
        var pivotloc = l;
        var j;
        for (j = l + 1; j <= h; j = j + 1) {
            if (A[j] < pivotval) {
                pivotloc = pivotloc + 1;
                A.swap(pivotloc, j);
        A.swap(l, pivotloc);
        return pivotloc;
    Array.prototype.swap = function (x, y) {
        var tmp = this[x];
        this[x] = this[y];
        this[y] = tmp;
        return this;
    };
    module.exports = Median;
    
  8. swap(x, y)
    Array.prototype.swap = function(x, y) {
        if (x > this.length || y > this.length || x === y) {
            return
        var tem = this[x];
        this[x] = this[y];
        this[y] = tem;
    
  9. swap(x, y)
    Array.prototype.swap = function(x, y){
      var temp = this[x];
      this[x] = this[y];
      this[y] = temp;
      return this;