List comprehensions: Difference between revisions
PascalABC.NET
(Remove outdated and no longer supported OCaml solutions) |
(PascalABC.NET) |
||
| (11 intermediate revisions by 5 users not shown) | |||
Line 21:
{{trans|Python}}
{{out}}
Line 275:
end mReturn</syntaxhighlight>
{{Out}}
<
=={{header|Arturo}}==
Line 397:
C doesn't have a built-in syntax for this, but any problem can be solved if you throw enough macros at it:
{{works with|GCC}}
The program below is C11 compliant. For C99 compilers note the change on line 57
<syntaxhighlight lang="c">
#include <stdlib.h>
Line 464 ⟶ 455:
List * intRangeList(int f, int t) {
List * l = listNew(sizeof f, &f), * e = l;
for (int i = f + 1; i <= t; i ++) { e = e->nx = listNew(sizeof i, &i); } // C11 compliant
//int i;
//for (i = f + 1; i <= t; i ++) { e = e->nx = listNew(sizeof i, &i); } // use this for C99
return l;
}
Line 611 ⟶ 604:
[x, y, z]
))
# pyth can also be written more concisely as
# pyth = (n) -> flatten (flatten ([x, y, z] for z in [y..n] when x*x + y*y is z*z for y in [x..n]) for x in [1..n])
console.dir pyth 20</syntaxhighlight>
=={{header|Common Lisp}}==
Line 1,045 ⟶ 1,036:
12 16 20
->
</pre>
=={{header|Insitux}}==
{{Trans|Clojure}}
<syntaxhighlight lang="insitux">
(function pythagorean-triples n
(let n+1 (inc n))
(for x (range 1 n+1)
y (range x n+1)
z (range y n+1)
(unless (= (+ (* x x) (* y y)) (* z z))
(continue))
[x y z]))
(pythagorean-triples 20)
</syntaxhighlight>
{{out}}
<pre>
[[3 4 5] [5 12 13] [6 8 10] [8 15 17] [9 12 15] [12 16 20]]
</pre>
Line 1,721 ⟶ 1,733:
{{works with|PARI/GP|2.4.2}}
<syntaxhighlight lang="parigp">f(n)=select(vector(n^3,i,vector(3,j,i\n^(j-1)%n)),v->norml2(v)==2*v[3]^2)</syntaxhighlight>
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
##
(1..20).CartesianPower(3).Where(\(x,y,z) -> (x*x + y*y = z*z) and (x < y)).PrintLines
</syntaxhighlight>
{{out}}
<pre>
[3,4,5]
[5,12,13]
[6,8,10]
[8,15,17]
[9,12,15]
[12,16,20]
</pre>
=={{header|Perl}}==
Line 1,935 ⟶ 1,962:
=={{header|Python}}==
<syntaxhighlight lang="python">
import itertools
n = 20
# List comprehension:
[(x,y,z) for x in xrange(1,n+1) for y in xrange(x,n+1) for z in xrange(y,n+1) if x**2 + y**2 == z**2]
# A Python generator expression (note the outer round brackets),
# returns an iterator over the same result rather than an explicit list:
((x,y,z) for x in xrange(1,n+1) for y in xrange(x,n+1) for z in xrange(y,n+1) if x**2 + y**2 == z**2)
# A slower but more readable version:
[(x, y, z) for (x, y, z) in itertools.product(xrange(1,n+1),repeat=3) if x**2 + y**2 == z**2 and x <= y <= z]
# Or as an iterator:
((x, y, z) for (x, y, z) in itertools.product(xrange(1,n+1),repeat=3) if x**2 + y**2 == z**2 and x <= y <= z)
# Alternatively we shorten the initial list comprehension but this time without compromising on speed.
# First we introduce a generator which generates all triplets:
def triplets(n):
for x in xrange(1, n + 1):
for y in xrange(x, n + 1):
for z in xrange(y, n + 1):
yield x, y, z
# Apply this to our list comprehension gives:
[(x, y, z) for (x, y, z) in triplets(n) if x**2 + y**2 == z**2]
# Or as an iterator:
((x, y, z) for (x, y, z) in triplets(n) if x**2 + y**2 == z**2)
# More generally, the list comprehension syntax can be understood as a concise syntactic sugaring
# of a use of the list monad, in which non-matches are returned as empty lists, matches are wrapped
# as single-item lists, and concatenation flattens the output, eliminating the empty lists.
# The monadic 'bind' operator for lists is concatMap, traditionally used with its first two arguments flipped.
# The following three formulations of a '''pts''' (pythagorean triangles) function are equivalent:
from functools import (reduce)
from operator import (add)
# pts :: Int -> [(Int, Int, Int)]
Line 2,029 ⟶ 2,057:
main()
</syntaxhighlight>
{{Out}}
<pre>[(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15), (12, 16, 20)]
Line 2,067 ⟶ 2,096:
Raku has single-dimensional list comprehensions that fall out naturally from nested modifiers; multidimensional comprehensions are also supported via the cross operator; however, Raku does not (yet) support multi-dimensional list comprehensions with dependencies between the lists, so the most straightforward way is currently:
<syntaxhighlight lang="raku" line>my $n = 20;
say gather for 1..$n -> $x {
for $x..$n -> $y {
for $y..$n -> $z {
Line 2,074 ⟶ 2,103:
}
}</syntaxhighlight>
{{out}}
<pre>((3 4 5) (5 12 13) (6 8 10) (8 15 17) (9 12 15) (12 16 20))</pre>
Note that <tt>gather</tt>/<tt>take</tt> is the primitive in Raku corresponding to generators or coroutines in other languages. It is not, however, tied to function call syntax in Raku. We can get away with that because lists are lazy, and the demand for more of the list is implicit; it does not need to be driven by function calls.
Line 2,623 ⟶ 2,654:
Pythagorean triples:
[[3, 4, 5], [5, 12, 13], [6, 8, 10], [9, 12, 15]]
</pre>
=={{header|Uiua}}==
<syntaxhighlight lang="uiua">
☇1⊞≡⊂⊞⊂..+1⇡20 # Cartesian product, flattened.
▽⊸≡(=1/↧/≥◫2) # Keep triplets which are in ascending order.
▽⊸≡(=⊃(/+⊏0_1|⊡2)×.) # Keep pythagorean triplets.
</syntaxhighlight>
{{out}}
<pre>
╭─
╷ 3 4 5
5 12 13
6 8 10
8 15 17
9 12 15
12 16 20
╯
</pre>
Line 2,691 ⟶ 2,740:
=={{header|Wren}}==
Using a generator.
<syntaxhighlight lang="
(1..n-2).each { |x|
(x+1..n-1).each { |y|
| |||