Be concise.
Be useful.
All contributions dictatorially edited by webmasters to match personal tastes.
Please do not paste any copyright violating material.
Please try to avoid dependencies to third-party libraries and frameworks.
foo(List<List<int>> a) => print("${a.length} ${a[0].length}");
var a = [
[1, 2],
[3, 4],
[5, 6]
];
foo(a);module x
contains
subroutine foo(a)
integer, dimension(:,:) :: a
print *,size(a,1), size(a,2)
end subroutine foo
end module x
program main
use x
integer, dimension(5,10) :: a
call foo(a)
end program mainfoo :: [[a]] -> IO ()
foo a = print (length a, length $ head a)
main :: IO ()
main = foo [[1, 2, 3], [4, 5, 6]]int i = 0, m = a.length;
while (i < m) out.println(a[i++].length);type
T2DArray = array of array of Integer;
procedure foo(A: T2DArray);
begin
writeln(Length(A),', ', Length(A[0]));
end;
var A: T2DArray;
begin
A := T2DArray.Create([1,2,3],[1,2,3]);
foo(A); //prints 2, 3
end.sub foo {
my ($a) = @_;
return scalar @{ $a }, scalar @{ $a->[0] };
}
my $a = [[1,2,3], [4,5,6]];
printf "%d %d\n", foo($a);
List reference $a is dereferenced into a list using @{ }. The 'scalar' operator forces scalar context, in which a list evaluates to its length.
The two lengths are returned as a list.
This code presumes that all elements of the inner list have the same length as the zeroeth element.
The two lengths are returned as a list.
This code presumes that all elements of the inner list have the same length as the zeroeth element.
def foo(a):
print(len(a), len(a[0]))
return
a = [[1,2,3], [4,5,6]]
foo(a)
foo = lambda a: \
print(*(len(x) for x in a))
foo(a)def foo(a):
print(*(len(x) for x in a))
foo(a)def foo(ar)
puts "#{ar.size} #{ar.first.size}"
end
a = [[1,2,3], [4,5,6]]
foo(a)fn foo(matrix: &[Vec<i32>]) {
let iter = matrix.iter();
let (vertical, _) = iter.size_hint();
let horizontal = iter
.max()
.expect("empty array!")
.len();
println!("{horizontal} by {vertical}");
}
fn main() {
let matrix = vec![
vec![1, 2, 3],
vec![4, 5, 6],
];
foo(&matrix);
}'&[Vec<i32>]' because we just read the Vec instead of consuming it.
This is emphasised with the '&' in front of types inside the functions signature.
'&Vec' can be coerced to '&[...]', which is a borrowed 'slice'.
A 'slice' is an 'array' with an unknown size at compile time.
'(vertical, _)' because 'size_hint()' returns a lower and a possible upper bound (the '_' in this case).
'max()' may return 'None' if the iterator (in this case our array) is empty.
This is emphasised with the '&' in front of types inside the functions signature.
'&Vec' can be coerced to '&[...]', which is a borrowed 'slice'.
A 'slice' is an 'array' with an unknown size at compile time.
'(vertical, _)' because 'size_hint()' returns a lower and a possible upper bound (the '_' in this case).
'max()' may return 'None' if the iterator (in this case our array) is empty.
fn foo<const X: usize, const Y: usize>(_: [[i32;X];Y]) {
println!("{} {}", Y, X);
}
let a = [
[1, 2, 3],
[4, 5, 6],
];
foo(a);