Removes an array entry at the specified position.

@param ar  array to be resized
@param p   position
@param <T> array type
@return array
549917
public static <T> T[] delete(final T[] ar, final int p) {
        final int s = ar.length - 1;
        move(ar, p + 1, -1, s - p);
        return Arrays.copyOf(ar, s);
    }
1031427
public static <T extends CharSequence> T[] removeEmpty(T[] array) {
		return filter(array, new Filter<T>() {
			@Override
			public boolean accept(T t) {
				return false == StrUtil.isEmpty(t);
			}
		});
	}
145726
public static String[] removeFirst(String[] args) {
		String[] args2 = new String[args.length - 1];
		System.arraycopy(args, 1, args2, 0, args2.length);
		return args2;
	}
930214
function remove(arr1, arr2) {
  if (!Array.isArray(arr1) || !Array.isArray(arr2)) {
    throw new Error('expected both arguments to be arrays');
  }
  var result = [];
  var len = arr1.length;
  for (var i = 0; i < len; i++) {
    var elem = arr1[i];
    if (arr2.indexOf(elem) == -1) {
      result.push(elem);
    }
  }
  return result;
}
241175
public static <T extends CharSequence> T[] removeBlank(T[] array) {
		return filter(array, new Filter<T>() {
			@Override
			public boolean accept(T t) {
				return false == StrUtil.isBlank(t);
			}
		});
	}
853657
public static <T> T[] remove(final T[] array, final T target) {

    if (array == null) {
      return null;
    }
    int count = count(array, target);
    if (count > 0) {
      @SuppressWarnings("unchecked")
      T[] newArray = (T[]) buildArray(array.getClass().getComponentType(), array.length - count,
        null);
      int index = 0;
      for (T element : array) {
        if (JudgeUtils.notSame(element, target)) {
          newArray[index++] = element;
        }
      }
      return newArray;
    }
    return array;
  }
813454
public static function array_pop_top(array &$arr) {
		if (! \count($arr)) {
			return false;
		}

		\reset($arr);
		return $arr[\key($arr)];
	}
447642
public static <T extends Comparable<? super T>> void rsort (T[] a)
    {
        rsort(a, 0, a.length - 1);
    }
147868
public static byte[] remove(byte[] arr, int n) {
        int index = binarySearch(arr, n);
        byte[] arr2 = new byte[arr.length - 4];
        System.arraycopy(arr, 0, arr2, 0, index);
        System.arraycopy(arr, index + 4, arr2, index, arr.length - index - 4);
        return arr2;
    }
882001
public static <T> PositionFactory<Object, T> atArrayIndex(final int index) {
        return new PositionFactory<Object, T>(index) {

            @Override
            public <P> RelativePosition.ReadWrite<P, T> of(Position.Readable<P> parentPosition) {
                final Type parentType = parentPosition.getType();
                Validate.isTrue(TypeUtils.isArrayType(parentType), "%s is not an array type", parentType);
                return super.of(parentPosition);
            }

            @Override
            public String toString() {
                return String.format("Array Element [%s]", index);
            }

            @Override
            protected <P> Type evaluateElementType(Position<P> parentPosition) {
                return TypeUtils.getArrayComponentType(parentPosition.getType());
            }
        };
    }
659344
def p_array_type(self, p):
        ''''''
        if len(p) == 2:
            p[0] = p[1][0],
        elif len(p) == 5 and p[4] == ']':
            def args(t):
                return t.__args__ if isinstance(t, NDArray) else (t,)
            p[0] = tuple(NDArray[args(t) + p[3]] for t in p[1])
711470
function removeDoubles( arrInput ) {
    const
    arrOutput = [],
    map = {};
    arrInput.forEach( function forEachItem( itm ) {
        if ( itm in map ) return;
        map[ itm ] = 1;
        arrOutput.push( itm );
    } );
    return arrOutput;
}
359157
public ModelAdapter<Model, Item> removeRange(int position, int itemCount) {
        mItems.removeRange(position, itemCount, getFastAdapter().getPreItemCount(position));
        return this;
    }
1321182
@Override
  public V remove(Object o) {
    checkMutable();
    @SuppressWarnings("unchecked")
    final K key = (K) o;
    final int index = binarySearchInArray(key);
    if (index >= 0) {
      return removeArrayEntryAt(index);
    }
    // overflowEntries might be Collections.unmodifiableMap(), so only
    // call remove() if it is non-empty.
    if (overflowEntries.isEmpty()) {
      return null;
    } else {
      return overflowEntries.remove(key);
    }
  }
1188269
private void remove_i(final String p, final boolean fwd) {
	if (name_equals(p)) {
	    System.out.println("Group::remove_i::failed to remove " + p + " (can't remove self)");
	    return;
	}
	if (p.indexOf('*') == -1) {
	    final Iterator it = elements.iterator();
	    while (it.hasNext()) {
		final GroupElement e = (GroupElement) it.next();
		if (e.name_equals(p)) {
		    elements.remove(e);
		    break;
		}
	    }
	} else {
	    final Vector remove_list = new Vector();
	    Iterator it = elements.iterator();
	    while (it.hasNext()) {
		final GroupElement e = (GroupElement) it.next();
		if (e.name_matches(p)) {
		    remove_list.add(e);
		}
	    }
	    it = remove_list.iterator();
	    while (it.hasNext()) {
		elements.remove(it.next());
	    }
	}
	if (fwd == true) {
	    final Iterator it = elements.iterator();
	    while (it.hasNext()) {
		final GroupElement e = (GroupElement) it.next();
		if (e instanceof Group) {
		    ((Group) e).remove(p, fwd);
		}
	    }
	}
    }
315454
public static <T> T[] deleteRange(final T[] a, final int fromIndex, final int toIndex) {
        N.checkFromToIndex(fromIndex, toIndex, a.length);

        if (fromIndex == toIndex) {
            return a.clone();
        }

        final T[] b = Array.newInstance(a.getClass().getComponentType(), a.length - (toIndex - fromIndex));

        if (fromIndex > 0) {
            N.copy(a, 0, b, 0, fromIndex);
        }

        if (toIndex < a.length) {
            N.copy(a, toIndex, b, fromIndex, a.length - toIndex);
        }

        return b;
    }
1149738
public static Object remove(Object array, int index) {
        int length = length(array);
        if (index < 0 || index >= length) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
        }

        Object result = Array.newInstance(array.getClass().getComponentType(), length - 1);
        System.arraycopy(array, 0, result, 0, index);
        if (index < length - 1) {
            System.arraycopy(array, index + 1, result, index, length - index - 1);
        }

        return result;
    }