List comprehensions: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
(→{{header|Raku}}: add output) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
| (8 intermediate revisions by 2 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">▼
for (int i = f + 1; i <= t; i ++) { e = e->nx = listNew(sizeof i, &i); }▼
</syntaxhighlight>▼
<syntaxhighlight lang="c">▼
int i;▼
</syntaxhighlight>▼
<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;
return l;
}
Line 611 ⟶ 604:
[x, y, z]
))
console.dir pyth 20</syntaxhighlight>
▲<code>pyth</code> can also be written more concisely as
▲<syntaxhighlight lang="coffeescript">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])</syntaxhighlight>
=={{header|Common Lisp}}==
Line 1,045 ⟶ 1,036:
12 16 20
->
</pre>
=={{header|Insitux}}==
{{Trans|Clojure}}
(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,935 ⟶ 1,947:
=={{header|Python}}==
List comprehension:▼
import itertools
n = 20
<syntaxhighlight lang="python">[(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]</syntaxhighlight>▼
A Python generator expression (note the outer round brackets), returns an iterator over the same result rather than an explicit list:▼
<syntaxhighlight lang="python">((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)</syntaxhighlight>▼
A slower but more readable version: ▼
▲# List comprehension:
<syntaxhighlight lang="python">[(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]</syntaxhighlight>▼
▲
# A Python generator expression (note the outer round brackets),
Or as an iterator:▼
▲
▲
▲# A slower but more readable version:
<syntaxhighlight lang="python">((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)</syntaxhighlight>▼
▲
▲# Or as an iterator:
Alternatively we shorten the initial list comprehension but this time without compromising on speed. First we introduce a generator which generates all triplets:▼
▲
▲# 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:
# Or as an iterator:▼
▲<syntaxhighlight lang="python">[(x, y, z) for (x, y, z) in triplets(n) if x**2 + y**2 == z**2]</syntaxhighlight>
# More generally, the list comprehension syntax can be understood as a concise syntactic sugaring
▲Or as an iterator:
# 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.
▲<syntaxhighlight lang="python">((x, y, z) for (x, y, z) in triplets(n) if x**2 + y**2 == z**2)</syntaxhighlight>
# The following three formulations of a '''pts''' (pythagorean triangles) function are equivalent:
▲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:
▲<syntaxhighlight lang="python">from functools import (reduce)
from operator import (add)
# pts :: Int -> [(Int, Int, Int)]
Line 2,029 ⟶ 2,042:
main()
▲</syntaxhighlight>
{{Out}}
<pre>[(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15), (12, 16, 20)]
Line 2,693 ⟶ 2,707:
=={{header|Wren}}==
Using a generator.
<syntaxhighlight lang="
(1..n-2).each { |x|
(x+1..n-1).each { |y|
| |||