Ignore the first n elements.

 @param n [Integer] the number of elements to drop
 @return [Enumerable] elements after the first N

 @see ::Enumerable#drop
346157
def drop(n)
      filter("drop") do |yielder|
        each_with_index do |element, index|
          next if index < n
          yielder.call(element)
        end
      end
    end
221846
public static int skip(IntIterator it, int n)
  {
    if (n < 0) {
      throw new IAE("n: " + n);
    }
    int skipped = 0;
    while (skipped < n && it.hasNext()) {
      it.nextInt();
      skipped++;
    }
    return skipped;
  }
859701
def drop_while(&predicate)
      filter("drop_while") do |yielder|
        take = false
        each do |element|
          take ||= !yield(element)
          yielder.call(element) if take
        end
      end
    end
338073
def first(n, it, constructor=list):
    
    return constructor(itertools.islice(it,n))
1006065
def insert n, *args
      new_frames = self.slice(0, n)
      args.each do |f|
        new_frames.push f
      end
      new_frames.concat self.slice(n..-1)

      self.clear
      self.concat new_frames
      self
    end
1017761
public long skip(long n) throws IOException
    {
        if (_closed)
            return -1;

        for (int i=0; i<n; i++)
            if (read()<0)
                return i==0?-1:i;
        return n;
    }
1331588
public function skip($n)
    {
        return new Enumerator(
            function () use($n) {
                foreach ($this->each() as $v) {
                    if (0 < $n) {
                        -- $n;
                    } else {
                        yield $v;
                    }
                }
            }
        );
    }
235576
def max
	    elements.reduce(elements.first.max) {|memo, e| memo.max(e.max) }
	end
1337650
def push(x, n = 1)
      x = [x] unless x.is_a? Array
      x.each { |value| _digest(value, n) }
    end
1296659
public Signature dropFirst(int n) {
        return new Signature(
                methodType.dropParameterTypes(0, n),
                Arrays.copyOfRange(argNames, n, argNames.length));
    }
772413
def drop_right_t(n):
    
    if n <= 0:
        end_index = None
    else:
        end_index = -n
    return Transformation(
        'drop_right({0})'.format(n),
        lambda sequence: sequence[:end_index],
        None
    )
14946
@Override
  public long skip(long n)
    throws IOException
  {
    if (n <= 0) {
      return n;
    }
    
    long skipLen = 0;
    
    while (n > 0) {
      long sublen = Math.min(n, _readLength - _readOffset);

      if (sublen > 0) {
        _readOffset += sublen;

        skipLen += sublen;
        n -= sublen;
      }
      else {
        if (_source.hasSkip()) {
          _readOffset = _readLength = 0;
          
          long sourceSkipped = _source.skip(n);

          if (sourceSkipped <= 0) {
            return skipLen;
          }
          else {
            _position += sourceSkipped;
            skipLen += sourceSkipped;
            
            n -= sourceSkipped;
          }
        }
        else if (! readBuffer()) {
          return skipLen;
        }
      }
    }
    
    return skipLen;
  }
985820
def Skip(self: dict, n):
    

    con = self.items()
    for i, _ in enumerate(con):
        if i == n:
            break
    return con
1254620
def dropSpans(spans, text):
    
    spans.sort()
    res = ''
    offset = 0
    for s, e in  spans:
        if offset <= s:         # handle nesting
            if offset < s:
                res += text[offset:s]
            offset = e
    res += text[offset:]
    return res
664698
private void moveAtFirst(int n_from) {
		int eT = elements[0];
		int eF = elements[n_from];
		positions[eT] = -1;
		positions[eF] = 0;
		elements[0] = eF;
		elements[n_from] = -1;
	}
1271820
public long skip(long n) throws IOException
    {
        int avail=_avail-_pos;
        if (avail <=0)
        {
            fill();
            avail=_avail-_pos;
        }

        if (avail <=0)
            n=0;
        else
        {
            n=(avail < n) ? avail : n;
            _pos +=n;
        }
        
        return n;
    }
919211
@Override
	public long skip(long n) throws IOException
    {
        if (n<=0)
            return 0;
        
        // How much can we skip ?
        long skippable = size - pos;
        if (skippable <= 0)
            return super.skip(n);
        
        long skipped = (skippable >= n) ? n : skippable;
        pos += skipped;
        return skipped;
    }