summaryloggraphiclog1graphiclog2commitcommitdifftreerefseditfork
rawpatchinlineside by side (parent: 86cf18e)
rawpatchinlineside by side (parent: 86cf18e)
| author | Burdette Lamar <[email protected]> | |
| Tue, 17 Dec 2024 15:55:43 +0000 (17 09:55 -0600) | ||
| committer | GitHub <[email protected]> | |
| Tue, 17 Dec 2024 15:55:43 +0000 (17 10:55 -0500) |
| array.c | patchblobblamehistory | |
| array.rb | patchblobblamehistory |
--- a/array.c
+++ b/array.c
/*
* call-seq:
* max -> element
- * max(n) -> new_array
+ * max(count) -> new_array
* max {|a, b| ... } -> element
- * max(n) {|a, b| ... } -> new_array
+ * max(count) {|a, b| ... } -> new_array
*
* Returns one of the following:
*
*
* [1, 0, 3, 2].max # => 3
*
- * With non-negative numeric argument +n+ and no block,
- * returns a new array with at most +n+ elements,
+ * With non-negative numeric argument +count+ and no block,
+ * returns a new array with at most +count+ elements,
* in descending order, per method <tt>#<=></tt>:
*
* [1, 0, 3, 2].max(3) # => [3, 2, 1]
* ['0', '', '000', '00'].max {|a, b| a.size <=> b.size }
* # => "000"
*
- * With non-negative numeric argument +n+ and a block,
- * returns a new array with at most +n+ elements,
+ * With non-negative numeric argument +count+ and a block,
+ * returns a new array with at most +count+ elements,
* in descending order, per the block:
*
* ['0', '', '000', '00'].max(2) {|a, b| a.size <=> b.size }
/*
* call-seq:
* min -> element
- * min(n) -> new_array
+ * min(count) -> new_array
* min {|a, b| ... } -> element
- * min(n) {|a, b| ... } -> new_array
+ * min(count) {|a, b| ... } -> new_array
*
* Returns one of the following:
*
*
* [1, 0, 3, 2].min # => 0
*
- * With non-negative numeric argument +n+ and no block,
- * returns a new array with at most +n+ elements,
+ * With non-negative numeric argument +count+ and no block,
+ * returns a new array with at most +count+ elements,
* in ascending order, per method <tt>#<=></tt>:
*
* [1, 0, 3, 2].min(3) # => [0, 1, 2]
* ['0', '', '000', '00'].min {|a, b| a.size <=> b.size }
* # => ""
*
- * With non-negative numeric argument +n+ and a block,
- * returns a new array with at most +n+ elements,
+ * With non-negative numeric argument +count+ and a block,
+ * returns a new array with at most +count+ elements,
* in ascending order, per the block:
*
* ['0', '', '000', '00'].min(2) {|a, b| a.size <=> b.size }
/*
* call-seq:
- * permutation(n = self.size) {|permutation| ... } -> self
- * permutation(n = self.size) -> new_enumerator
+ * permutation(count = self.size) {|permutation| ... } -> self
+ * permutation(count = self.size) -> new_enumerator
*
* Iterates over permutations of the elements of +self+;
* the order of permutations is indeterminate.
*
- * With a block and an in-range positive integer argument +n+ (<tt>0 < n <= self.size</tt>) given,
- * calls the block with each +n+-tuple permutations of +self+;
+ * With a block and an in-range positive integer argument +count+ (<tt>0 < count <= self.size</tt>) given,
+ * calls the block with each permutation of +self+ of size +count+;
* returns +self+:
*
* a = [0, 1, 2]
* a.permutation(3) {|perm| perms.push(perm) }
* perms # => [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]]
*
- * When +n+ is zero, calls the block once with a new empty array:
+ * When +count+ is zero, calls the block once with a new empty array:
*
* perms = []
* a.permutation(0) {|perm| perms.push(perm) }
* perms # => [[]]
*
- * When +n+ is out of range (negative or larger than <tt>self.size</tt>),
+ * When +count+ is out of range (negative or larger than <tt>self.size</tt>),
* does not call the block:
*
* a.permutation(-1) {|permutation| fail 'Cannot happen' }
/*
* call-seq:
- * combination(n) {|element| ... } -> self
- * combination(n) -> new_enumerator
+ * combination(count) {|element| ... } -> self
+ * combination(count) -> new_enumerator
*
* When a block and a positive
* {integer-convertible object}[rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects]
- * argument +n+ (<tt>0 < n <= self.size</tt>)
- * are given, calls the block with all +n+-tuple combinations of +self+;
+ * argument +count+ (<tt>0 < count <= self.size</tt>)
+ * are given, calls the block with each combination of +self+ of size +count+;
* returns +self+:
*
* a = %w[a b c] # => ["a", "b", "c"]
*
* The order of the yielded combinations is not guaranteed.
*
- * When +n+ is zero, calls the block once with a new empty array:
+ * When +count+ is zero, calls the block once with a new empty array:
*
* a.combination(0) {|combination| p combination }
* [].combination(0) {|combination| p combination }
* []
* []
*
- * When +n+ is negative or larger than +self.size+ and +self+ is non-empty,
+ * When +count+ is negative or larger than +self.size+ and +self+ is non-empty,
* does not call the block:
*
* a.combination(-1) {|combination| fail 'Cannot happen' } # => ["a", "b", "c"]
/*
* call-seq:
- * drop(n) -> new_array
+ * drop(count) -> new_array
*
- * Returns a new array containing all but the first +n+ element of +self+,
- * where +n+ is a non-negative Integer;
+ * Returns a new array containing all but the first +count+ element of +self+,
+ * where +count+ is a non-negative integer;
* does not modify +self+.
*
* Examples:
diff --git a/array.rb b/array.rb
--- a/array.rb
+++ b/array.rb
end
# call-seq:
- # last -> last_object or nil
- # last(n) -> new_array
+ # last -> last_object or nil
+ # last(count) -> new_array
#
# Returns elements from +self+, or +nil+; +self+ is not modified.
#
# a # => [:foo, "bar", 2]
# [].last # => nil
#
- # With a non-negative integer argument +n+ given,
- # returns a new array containing the trailing +n+ elements of +self+, as available:
+ #
+ # With non-negative integer argument +count+ given,
+ # returns a new array containing the trailing +count+ elements of +self+, as available:
#
# a = [:foo, 'bar', 2]
# a.last(2) # => ["bar", 2]