List comprehensions

List comprehensions
You are encouraged to solve this task according to the task description, using any language you may know.

A list comprehension is a special syntax in some programming languages to describe lists. It is similar to the way mathematicians describe sets, with a set comprehension, hence the name.

Some attributes of a list comprehension are that:

1. They should be distinct from (nested) for loops within the syntax of the language.
2. They should return either a list or an iterator (something that returns successive members of a collection, in order).
3. The syntax has parts corresponding to that of set-builder notation.

Write a list comprehension that builds the list of all Pythagorean triples with elements between 1 and n. If the language has multiple ways for expressing such a construct (for example, direct list comprehensions and generators), write one example for each.

Ada

Works with: Ada 2005 version Standard - no additional library

There is no equivalent construct in Ada. In Ada05, the predefined library Ada.Containers implements 3 types of Doubly_Linked_Lists : Basic; Indefinite; Restricted.

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Containers.Doubly_Linked_Lists;
 
procedure Pythagore_Set is
 
   type Triangles is array (1 .. 3) of Positive;
 
   package Triangle_Lists is new Ada.Containers.Doubly_Linked_Lists (
      Triangles);
   use Triangle_Lists;
 
   function Find_List (Upper_Bound : Positive) return List is
      L : List := Empty_List;
   begin
      for A in 1 .. Upper_Bound loop
         for B in A + 1 .. Upper_Bound loop
            for C in B + 1 .. Upper_Bound loop
               if ((A * A + B * B) = C * C) then
                  Append (L, (A, B, C));
               end if;
            end loop;
         end loop;
      end loop;
      return L;
   end Find_List;
 
   Triangle_List : List;
   C             : Cursor;
   T             : Triangles;
 
begin
   Triangle_List := Find_List (Upper_Bound => 20);
 
   C := First (Triangle_List);
   while Has_Element (C) loop
      T := Element (C);
      Put
        ("(" &
         Integer'Image (T (1)) &
         Integer'Image (T (2)) &
         Integer'Image (T (3)) &
         ") ");
      Next (C);
   end loop;
end Pythagore_Set;
 

program output:

( 3 4 5) ( 5 12 13) ( 6 8 10) ( 8 15 17) ( 9 12 15) ( 12 16 20)

ALGOL 68

ALGOL 68 does not have list comprehension, however it is sometimes reasonably generous about where a flex array is declared. And with the addition of an append operator "+:=" for lists they can be similarly manipulated.

Translation of: Python

Works with: ALGOL 68 version Standard - no extensions to language used

Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386

MODE XYZ = STRUCT(INT x,y,z);
 
OP +:= = (REF FLEX[]XYZ lhs, XYZ rhs)FLEX[]XYZ: (
  [UPB lhs+1]XYZ out;
  out[:UPB lhs] := lhs;
  out[UPB out] := rhs;
  lhs := out
);
 
INT n = 20;
print (([]XYZ(
  FLEX[0]XYZ xyz;
  FOR x TO n DO FOR y FROM x+1 TO n DO FOR z FROM y+1 TO n DO IF x*x + y*y = z*z THEN xyz +:= XYZ(x,y,z) FI OD OD OD;
  xyz), new line
))

Output:

         +3         +4         +5         +5        +12        +13         +6         +8        +10         +8        +15        +17         +9        +12        +15        +12        +16        +20

AutoHotkey

Works with: AutoHotkey_L

List Comprehension is not built in.

 
comprehend("show", range(1, 20), "triples")
return
 
comprehend(doToVariable, inSet, satisfying)
{
  set := %satisfying%(inSet.begin, inSet.end)
  index := 1
  While % set[index, 1]
  {
    item := set[index, 1] . ", " . set[index, 2] . ", " . set[index, 3]
    %doToVariable%(item)
    index += 1
  }
  return
}
 
 
show(var)
{
  msgbox % var
}
 
range(begin, end)
 {
   set := object()
   set.begin := begin
   set.end := end
   return set
 }
 
!r::reload
!q::exitapp
 
triples(begin, end)
{
 
  set := object()
  index := 1
  range := end - begin
 
  loop, % range
  {
    x := begin + A_Index 
    loop, % range
    {
      y := A_Index + x 
      if y > 20
	break
loop, % range
{
  z := A_Index + y 
  if z > 20
    break
  isTriple := ((x ** 2 + y ** 2) == z ** 2)
  if isTriple
  {
    set[index, 1] := x 
    set[index, 2] := y
    set[index, 3] := z
    index += 1
  ; msgbox % "triple: "  x . y . z
  }
 
}
}
}
return set
}
 

Bracmat

Bracmat does not have built-in list comprehension, but nevertheless there is a solution for fixed n that does not employ explicit loop syntax. By their positions in the pattern and the monotonically increasing values in the subject, it is guaranteed that x always is smaller than y and that y always is smaller than z. The combination of flags %@ ensures that x, y and z pick minimally one (%) and at most one (@) element from the subject list.

 
  :?py                         { Initialize the accumulating result list. }
& (     1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20   { This is the subject }
    :   ?                      { Here starts the pattern }
        %@?x
        ?
        %@?y
        ?
        %@?z
        ( ?
        & -1*!z^2+!x^2+!y^2:0
        & (!x,!y,!z) !py:?py
        & ~                    { This 'failure' expression forces backtracking }
        )                      { Here ends the pattern }
  | out$!py                    { You get here when backtracking has 
                                 exhausted all combinations of x, y and z }
  );

Output:

  (12,16,20)
  (9,12,15)
  (8,15,17)
  (6,8,10)
  (5,12,13)
  (3,4,5)

C#

LINQ

using System.Linq;
 
static class Program
{
  static void Main()
  {
    var ts =
      from a in Enumerable.Range(1, 20)
      from b in Enumerable.Range(a, 21 - a)
      from c in Enumerable.Range(b, 21 - b)
      where a * a + b * b == c * c
      select new { a, b, c };
 
      foreach (var t in ts)
        System.Console.WriteLine("{0}, {1}, {2}", t.a, t.b, t.c);
  }
}
 

C++

There is no equivalent construct in C++. The code below uses two nested loops and an if statement:

#include <vector>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <iterator>
 
void list_comprehension( std::vector<int> & , int ) ;
 
int main( ) {
   std::vector<int> triangles ;
   list_comprehension( triangles , 20 ) ;
   std::copy( triangles.begin( ) , triangles.end( ) ,
	 std::ostream_iterator<int>( std::cout , " " ) ) ;
   std::cout << std::endl ;
   return 0 ;
}
 
void list_comprehension( std::vector<int> & numbers , int upper_border ) {
   for ( int a = 1 ; a < upper_border ; a++ ) {
      for ( int b = a + 1 ; b < upper_border ; b++ ) {
	 double c = pow( a * a + b * b , 0.5 ) ; //remembering Mr. Pythagoras
	 if ( ( c * c ) < pow( upper_border , 2 ) + 1 ) {
	    if ( c == floor( c ) ) {
	       numbers.push_back( a ) ;
	       numbers.push_back( b ) ;	      
	       numbers.push_back( static_cast<int>( c ) ) ;
	    }
	 }
      }
   }
}
 

This produces the following output:

3 4 5 5 12 13 6 8 10 8 15 17 9 12 15 12 16 20

Works with: C++11

#include <functional>
#include <iostream>
 
void PythagoreanTriples(int limit, std::function<void(int,int,int)> yield)
{
    for (int a = 1; a < limit; ++a) {
        for (int b = a+1; b < limit; ++b) {
            for (int c = b+1; c <= limit; ++c) {
                if (a*a + b*b == c*c) {
                    yield(a, b, c);
                }
            }
        }
    }
}
 
int main()
{
    PythagoreanTriples(20, [](int x, int y, int z)
    {
        std::cout << x << "," << y << "," << z << "\n";
    });
    return 0;
}

Output:

3,4,5
5,12,13
6,8,10
8,15,17
9,12,15
12,16,20

Clojure

(defn pythagorean-triples [n]
  (for [x (range 1 (inc n))
	y (range x (inc n))
	z (range y (inc n))
	:when (= (+ (* x x) (* y y)) (* z z))]
    [x y z]))

CoffeeScript

flatten = (arr) -> arr.reduce ((memo, b) -> memo.concat b), []
 
pyth = (n) ->
  flatten (for x in [1..n]
    flatten (for y in [x..n]
      for z in [y..n] when x*x + y*y is z*z
        [x, y, z]
    ))
 
console.dir pyth 20

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])

Common Lisp

Common Lisp's loop macro has all of the features of list comprehension, except for nested iteration. (loop for x from 1 to 3 for y from x to 3 collect (list x y)) only returns ((1 1) (2 2) (3 3)). You can nest your macro calls, so (loop for x from 1 to 3 append (loop for y from x to 3 collect (list x y))) returns ((1 1) (1 2) (1 3) (2 2) (2 3) (3 3)).

Here are the Pythagorean triples:

(defun pythagorean-triples (n)
  (loop for x from 1 to n
        append (loop for y from x to n
                     append (loop for z from y to n
                                  when (= (+ (* x x) (* y y)) (* z z))
                                  collect (list x y z)))))

We can also define a new macro for list comprehensions. We can implement them easily with the help of the iterate package.

(defun nest (l)
  (if (cdr l)
    `(,@(car l) ,(nest (cdr l)))
    (car l)))
 
(defun desugar-listc-form (form)
  (if (string= (car form) 'for)
    `(iter ,form)
    form))
 
(defmacro listc (expr &body (form . forms) &aux (outer (gensym)))
  (nest
    `((iter ,outer ,form)
      ,@(mapcar #'desugar-listc-form forms)
      (in ,outer (collect ,expr)))))

We can then define a function to compute Pythagorean triples as follows:

(defun pythagorean-triples (n)
  (listc (list x y z)
    (for x from 1 to n)
    (for y from x to n)
    (for z from y to n)
    (when (= (+ (expt x 2) (expt y 2)) (expt z 2)))))

D

D doesn't have list comprehensions. One implementation:

import std.stdio, std.typetuple, std.range;
 
TA[] select(TA, TI1, TC1, TI2, TC2, TI3, TC3, TP)
           (lazy TA mapper,
            ref TI1 iter1, TC1 items1,
            ref TI2 iter2, lazy TC2 items2,
            ref TI3 iter3, lazy TC3 items3,
            lazy TP where) {
  Appender!(TA[]) result;
  auto iters = TypeTuple!(iter1, iter2, iter3);
 
  foreach (el1; items1) {
    iter1 = el1;
    foreach (el2; items2) {
      iter2 = el2;
      foreach (el3; items3) {
        iter3 = el3;
        if (where())
          result ~= mapper();
      }
    }
  }
 
  TypeTuple!(iter1, iter2, iter3) = iters;
  return result.data;
}
 
void main() {
  enum int n = 21;
  int x, y, z;
  auto r = select([x,y,z], x, iota(1,n+1), y, iota(x,n+1), z,
                  iota(y, n + 1), x*x + y*y == z*z);
  writeln(r);
}

Output:

[[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15], [12, 16, 20]]

E

pragma.enable("accumulator") # considered experimental
 
accum [] for x in 1..n { for y in x..n { for z in y..n { if (x**2 + y**2 <=> z**2) { _.with([x,y,z]) } } } }

Efene

pythag = fn (N) {
    [(A, B, C) for A in lists.seq(1, N) \
         for B in lists.seq(A, N) \
         for C in lists.seq(B, N) \
         if A + B + C <= N and A * A + B * B == C * C]
}
 
@public 
run = fn () {
    io.format("~p~n", [pythag(20)])
}
 

Ela

pyth n = [(x,y,z) \\ x <- [1..n], y <- [x..n], z <- [y..n] | x**2 + y**2 == z**2]

Erlang

pythag(N) ->
    [ {A,B,C} || A <- lists:seq(1,N),
                 B <- lists:seq(A,N),
                 C <- lists:seq(B,N),
                 A+B+C =< N,
                 A*A+B*B == C*C ].

F#

let pyth n = [ for a in [1..n] do
               for b in [a..n] do
               for c in [b..n] do
               if (a*a+b*b = c*c) then yield (a,b,c)]

GAP

# We keep only primitive pythagorean triples
pyth := n ->
  Filtered(Cartesian([1 .. n], [1 .. n], [1 .. n]),
  u -> u[3]^2 = u[1]^2 + u[2]^2 and u[1] < u[2] 
  and GcdInt(u[1], u[2]) = 1);
 
pyth(100);
# [ [ 3, 4, 5 ], [ 5, 12, 13 ], [ 7, 24, 25 ], [ 8, 15, 17 ], [ 9, 40, 41 ], [ 11, 60, 61 ], [ 12, 35, 37 ], 
#   [ 13, 84, 85 ], [ 16, 63, 65 ], [ 20, 21, 29 ], [ 28, 45, 53 ], [ 33, 56, 65 ], [ 36, 77, 85 ], [ 39, 80, 89 ], 
#   [ 48, 55, 73 ], [ 65, 72, 97 ] ]

Haskell

pyth n = [(x,y,z) | x <- [1..n], y <- [x..n], z <- [y..n], x^2 + y^2 == z^2]

Since lists are monads, one can alternatively also use the do-notation (which is practical if the comprehension is large):

import Control.Monad
 
pyth n = do
  x <- [1..n]
  y <- [x..n]
  z <- [y..n]
  guard $ x^2 + y^2 == z^2
  return (x,y,z)

Ioke

for(
  x <- 1..20, 
  y <- x..20, 
  z <- y..20,
  x * x + y * y == z * z,
  [x, y, z]
)

J

require'stats'
buildSet=:conjunction def '(#~ v) u y'
triples=: 1 + 3&comb
isPyth=: 2&{"1 = 1&{"1 +&.:*: 0&{"1
pythTr=: triples buildSet isPyth

The idiom here has two major elements:

First, you need a statement indicating the values of interest. In this case, (1+3&comb) which when used as a function of n specifies a list of triples each in the range 1..n.

Second, you need a statement of the form (#~ B) where B returns true for the desired members, and false for the undesired members.

In the above example, the word isPyth is our predicate (represented as B in the preceding paragraph). This corresponds to the constraint clause in set builder notation.

In the above example the word triples represents the universe of potential solutions (some of which will be valid, some not). This corresponds to the generator part of set builder notation.

The argument to isPyth will be the candidate solutions (the result of triples). The argument to triples will be the largest element desired in a triple.

Example use:

   pythTr 20
 3  4  5
 5 12 13
 6  8 10
 8 15 17
 9 12 15
12 16 20

JavaScript

Translation of: Python

Works with: JavaScript version 1.7+ (Firefox 2+)

Works with: SpiderMonkey version 1.7

See here for more details

function range(begin, end) {
    for (let i = begin; i < end; ++i) 
        yield i;
}
 
function triples(n) {
    return [[x,y,z] for each (x in range(1,n+1)) 
                     for each (y in range(x,n+1)) 
                     for each (z in range(y,n+1)) 
                     if (x*x + y*y == z*z) ]
}
 
for each (var triple in triples(20))
    print(triple);

outputs:

3,4,5
5,12,13
6,8,10
8,15,17
9,12,15
12,16,20

Lua

Lua doesn't have list comprehensions built in, but they can be constructed from chained coroutines:

 
LC={}
LC.__index = LC
 
function LC:new(o)
  o = o or {}
  setmetatable(o, self)
  return o
end
 
function LC:add_iter(func)
  local prev_iter = self.iter
  self.iter = coroutine.wrap(
    (prev_iter == nil) and (function() func{} end)
    or (function() for arg in prev_iter do func(arg) end end))
  return self
end
 
function maybe_call(maybe_func, arg)
  if type(maybe_func) == "function" then return maybe_func(arg) end
  return maybe_func
end
 
function LC:range(key, first, last)
  return self:add_iter(function(arg)
    for value=maybe_call(first, arg), maybe_call(last, arg) do
      arg[key] = value
      coroutine.yield(arg)
    end
  end)
end
 
function LC:where(pred)
  return self:add_iter(function(arg) if pred(arg) then coroutine.yield(arg) end end)
end
 

We can then define a function to compute Pythagorean triples as follows:

 
function get(key)
  return (function(arg) return arg[key] end)
end
 
function is_pythagorean(arg)
  return (arg.x^2 + arg.y^2 == arg.z^2)
end
 
function list_pythagorean_triples(n)
  return LC:new():range("x",1,n):range("y",1,get("x")):range("z", get("y"), n):where(is_pythagorean).iter
end
 
for arg in list_pythagorean_triples(100) do
  print(arg.x, arg.y, arg.z)
end
 

Mathematica

Select[Tuples[Range[n], 3], #1[[1]]^2 + #1[[2]]^2 == #1[[3]]^2 &]

MATLAB / Octave

In Matlab/Octave, one does not think much about lists rather than vectors and matrices. Probably, the find() operation comes closes to the task

  N = 100;
  [a,b] = mesgrid(1:N, 1:N);
  c     = sqrt(a.^2 + b.^2); 
  [x,y] = find( c==fix(c) );

Nemerle

Demonstrating a list comprehension and an iterator. List comprehension adapted from Haskell example, iterator adapted from C# example.

using System;
using System.Console;
using System.Collections.Generic;
 
module Program
{
 
    PythTriples(n : int) : list[int * int * int]
    {
        $[ (x, y, z) | x in [1..n], y in [x..n], z in [y..n], ((x**2) + (y**2)) == (z**2) ]
    }
 
    GetPythTriples(n : int) : IEnumerable[int * int * int]
    {
        foreach (x in [1..n])
        {
            foreach (y in [x..n])
            {
                foreach (z in [y..n])
                {
                    when (((x**2) + (y**2)) == (z**2))
                    {
                        yield (x, y, z)
                    }
                }
            }
        }
    }
 
    Main() : void
    {
        WriteLine("Pythagorean triples up to x = 20: {0}", PythTriples(20));
 
        foreach (triple in GetPythTriples(20))
        {
            Write(triple)
        }
    }
}

OCaml

OCaml Batteries Included has uniform comprehension syntax for lists, arrays, enumerations (like streams), lazy lists (like lists but evaluated on-demand), sets, hashtables, etc.

Comprehension are of the form [? expression | x <- enumeration ; condition; condition ; ...]

For instance,

#   [? 2 * x | x <- 0 -- max_int ; x * x > 3];;
- : int Enum.t = <abstr>

or, to compute a list,

#   [? List: 2 * x | x <- 0 -- 100 ; x * x > 3];;
- : int list = [2; 4; 6; 8; 10]

or, to compute a set,

#   [? PSet: 2 * x | x <- 0 -- 100 ; x * x > 3];;
- : int PSet.t = <abstr>

etc..

Oz

Oz does not have list comprehension.

However, there is a list comprehension package available here. It uses the unofficial and deprecated macro system. Usage example:

functor
import
   LazyList
   Application
   System
define
 
   fun {Pyth N}
      <<list [X Y Z] with
	 X <- {List.number 1 N 1}
	 Y <- {List.number X N 1}
	 Z <- {List.number Y N 1}
	 where X*X + Y*Y == Z*Z
      >>
   end
 
   {ForAll {Pyth 20} System.show}
 
   {Application.exit 0}
end

PARI/GP

GP 2.6.0 added support for a new comprehension syntax:

f(n)=[v|v<-vector(n^3,i,vector(3,j,i\n^(j-1)%n)),norml2(v)==2*v[3]^2]

Older versions of GP can emulate this through select:

f(n)=select(v->norml2(v)==2*v[3]^2,vector(n^3,i,vector(3,j,i\n^(j-1)%n)))

Version 2.4.2 (obsolete, but widespread on Windows systems) requires inversion:

f(n)=select(vector(n^3,i,vector(3,j,i\n^(j-1)%n)),v->norml2(v)==2*v[3]^2)

Perl

Perl 5 does not have built-in list comprehension syntax. The closest approach are the list map and grep (elsewhere often known as filter) operators:

sub triples ($) {
  my ($n) = @_;
  map { my $x = $_; map { my $y = $_; map { [$x, $y, $_] } grep { $x**2 + $y**2 == $_**2 } 1..$n } 1..$n } 1..$n;
}

map binds $_ to each element of the input list and collects the results from the block. grep returns every element of the input list for which the block returns true. The .. operator generates a list of numbers in a specific range.

for my $t (triples(10)) {
  print "@$t\n";
}

Perl 6

Perl 6 has single-dimensional list comprehensions that fall out naturally from nested modifiers; multidimensional comprehensions are also supported via the cross operator; however, Perl 6 does not (yet) support multi-dimensional list comprehensions with dependencies between the lists, so the most straightforward way is currently:

my $n = 20;
gather for 1..$n -> $x {
         for $x..$n -> $y {
           for $y..$n -> $z {
             take $x,$y,$z if $x*$x + $y*$y == $z*$z;
           }
         }
       }

Note that gather/take is the primitive in Perl 6 corresponding to generators or coroutines in other languages. It is not, however, tied to function call syntax in Perl 6. 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.

PicoLisp

PicoLisp doesn't have list comprehensions. We might use a generator function, pipe, coroutine or pilog predicate.

Using a generator function

(de pythag (N)
   (job '((X . 1) (Y . 1) (Z . 0))
      (loop
         (when (> (inc 'Z) N)
            (when (> (inc 'Y) N)
               (setq Y (inc 'X)) )
            (setq Z Y) )
         (T (> X N))
         (T (= (+ (* X X) (* Y Y)) (* Z Z))
            (list X Y Z) ) ) ) )
 
(while (pythag 20)
   (println @) )

Using a pipe

(pipe
   (for X 20
      (for Y (range X 20)
         (for Z (range Y 20)
            (when (= (+ (* X X) (* Y Y)) (* Z Z))
               (pr (list X Y Z)) ) ) ) )
   (while (rd)
      (println @) ) )

Using a coroutine

Coroutines are available only in the 64-bit version.

(de pythag (N)
   (co 'pythag
      (for X N
         (for Y (range X N)
            (for Z (range Y N)
               (when (= (+ (* X X) (* Y Y)) (* Z Z))
                  (yield (list X Y Z)) ) ) ) ) ) )
 
(while (pythag 20)
   (println @) )

Output in all three cases:

(3 4 5)
(5 12 13)
(6 8 10)
(8 15 17)
(9 12 15)
(12 16 20)

Using Pilog

Works with: PicoLisp version 3.0.9.7

(be pythag (@N @X @Y @Z)
   (for @X @N)
   (for @Y @X @N)
   (for @Z @Y @N)
   (@ let (X (-> @X)  Y (-> @Y)  Z (-> @Z))
       (= (+ (* X X) (* Y Y)) (* Z Z)) ) )

Test:

: (? (pythag 20 @X @Y @Z))
 @X=3 @Y=4 @Z=5
 @X=5 @Y=12 @Z=13
 @X=6 @Y=8 @Z=10
 @X=8 @Y=15 @Z=17
 @X=9 @Y=12 @Z=15
 @X=12 @Y=16 @Z=20
-> NIL

Prolog

SWI-Prolog does not have list comprehension, however we can simulate it.

% We need operators
:- op(700, xfx, <-).
:- op(450, xfx, ..).
:- op(1100, yfx, &).
 
% we need to define the intervals of numbers
Vs <- M..N :-
        integer(M),
	integer(N),
	M =< N,
	between(M, N, Vs).
 
% finally we define list comprehension
% prototype is Vs <- {Var, Dec, Pred} where
% Var is the list of variables to output
% Dec is the list of intervals of the variables
% Pred is the list of predicates
Vs <- {Var & Dec & Pred} :-
	findall(Var,  maplist(call, [Dec, Pred]), Vs).
 

Examples of use :
List of Pythagorean triples :

 ?- V <- {X, Y, Z & X <- 1..20, Y <- X..20, Z <- Y..20 & X*X+Y*Y =:= Z*Z}.
V = [ (3,4,5), (5,12,13), (6,8,10), (8,15,17), (9,12,15), (12,16,20)] ;
false.

List of double of x, where x^2 is greater than 50 :

 ?- V <- {Y & X <- 1..20 & X*X > 50, Y is 2 * X}.
V = [16,18,20,22,24,26,28,30,32,34,36,38,40] ;
false.

Python

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 comprehension (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)

R

R have inherent list comprehension:

 
x = (0:10)
> x^2
 [1]   0   1   4   9  16  25  36  49  64  81 100
> Reduce(function(y,z){return (y+z)},x)
[1] 55
> x[x[(0:length(x))] %% 2==0]
[1]  0  2  4  6  8 10
 

R's "data frame" functions can be used to achieve the same code clarity (at the cost of expanding the entire grid into memory before the filtering step)

 
subset(expand.grid(x=1:n, y=1:n, z=1:n), x^2 + y^2 == z^2)
 

Racket

 
#lang racket
(for*/list ([x (in-range 1 21)]
            [y (in-range x 21)]
            [z (in-range y 21)]
            #:when (= (+ (* x x) (* y y)) (* z z)))
  (list x y z))
 

Rascal

 
public list[tuple[int, int, int]]  PythTriples(int n) = [<a, b, c> | a <- [1..n], b <- [1..n], c <- [1 .. n], a*a + b*b == c*c];
 

REXX

There is no native comprehensive supoort for lists per se, except that
normal lists can be processed quite easily and without much effort.

/*REXX program to list  Pythagorean triples  up to a specified number.  */
parse arg n .                          /*get the argument (possibly).   */
if n=='' then n=100                    /*Not specified?  Then assume 100*/
call gen_triples n                     /*generate Pythagorean triples.  */
call showhdr                           /*show a nice header.            */
call showlist triples                  /*show the Pythagorean triples.  */
exit                                   /*stick a fork in it, we're done.*/
/*──────────────────────────────────GEN_TRIPLES subroutine──────────────*/
gen_triples: parse arg lim             /*generate Pythorgorean triples. */
triples=
 
      do a=1  for lim-2;     aa=a*a    /*a*a    is faster than    a**2  */
        do b=a+1  to lim-1;  aabb=aa+b*b
          do c=b+1 to lim
          if aabb==c*c  then triples=triples '['a"-" || b'-'c"]"
          end   /*c*/
        end     /*b*/
      end       /*a*/
 
triples=strip(triples)
return
/*──────────────────────────────────SHOWHDR subroutine──────────────────*/
showHdr: say
if 'f0'x==0 then do; super2='b2'x; le='8c'x; end   /*EBCDIC: super2, LE */
            else do; super2='fd'x; le='f3'x; end   /* ASCII:   "     "  */
note='(a'super2 "+ b"super2 '= c'super2",  c "le n')'  /*prettify equat.*/
say 'Pythagorean triples' note":"
return
/*──────────────────────────────────SHOWLIST subroutine─────────────────*/
showlist: procedure; parse arg L       /*get the list  (L).             */
w=words(L)                             /*number of members in the list. */
say;          do j=1  for w            /*display the members of the list*/
              say word(L,j)
              end   /*j*/
say;  say w 'members listed.'
return

output

Pythagorean triples (a² + b² = c²,  c ≤ 100):

[3-4-5]
[5-12-13]
[6-8-10]
[7-24-25]
[8-15-17]
[9-12-15]
[9-40-41]
[10-24-26]
[11-60-61]
[12-16-20]
[12-35-37]
[13-84-85]
[14-48-50]
[15-20-25]
[15-36-39]
[16-30-34]
[16-63-65]
[18-24-30]
[18-80-82]
[20-21-29]
[20-48-52]
[21-28-35]
[21-72-75]
[24-32-40]
[24-45-51]
[24-70-74]
[25-60-65]
[27-36-45]
[28-45-53]
[28-96-100]
[30-40-50]
[30-72-78]
[32-60-68]
[33-44-55]
[33-56-65]
[35-84-91]
[36-48-60]
[36-77-85]
[39-52-65]
[39-80-89]
[40-42-58]
[40-75-85]
[42-56-70]
[45-60-75]
[48-55-73]
[48-64-80]
[51-68-85]
[54-72-90]
[57-76-95]
[60-63-87]
[60-80-100]
[65-72-97]

52 members listed.

Ruby

Ruby has no special syntax for list comprehensions.

Enumerable#select comprises a list from one variable, like Perl grep() or Python filter(). Some lists need Array#map! to transform the variable.

• (1..100).select { |x| x % 3 == 0 } is the list of all x from 1 to 100 such that x is a multiple of 3.
• methods.select { |name| name.length <= 5 } is the list of all methods from self with names not longer than 5 characters.
• Dir["/bin/*"].select { |p| File.setuid? p }.map! { |p| File.basename p } is the list of all files in /bin with a setuid bit.

Ruby's object-oriented style enforces writing 1..100 before x. Think not of x in 1..100. Think of 1..100 giving x.

There is no elegant way to comprise a list from multiple variables. Pythagorean triplets need three variables, with 1..n giving x, then x..n giving y, then y..n giving z. A less than elegant way is to nest three blocks.

Ruby 1.9.2

Works with: Ruby version 1.9.2

n = 20
 
# select Pythagorean triplets
r = ((1..n).flat_map { |x|
       (x..n).flat_map { |y|
         (y..n).flat_map { |z|
           [[x, y, z]].keep_if { x * x + y * y == z * z }}}})
 
p r # print the array _r_

Output: [[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15], [12, 16, 20]]

Ruby 1.9.2 introduces two new methods: Enumerable#flat_map joins all the arrays from the block. Array#keep_if is an alternative to Enumerable#select that modifies the original array. (We avoid Array#select! because it might not return the array.)

• The [[x, y, z]].keep_if { ... } returns either an array of one Pythagorean triplet, or an empty array.
• The inner (y..n).flat_map { ... } concatenates those arrays for all z given some x, y.
• The middle (x..n).flat_map { ... } concatenates the inner arrays for all y given some x.
• The outer (1..n).flat_map { ... } concatenates the middle arrays for all x.

Ruby 1.8.6

Works with: Ruby version 1.8.6 or later

n = 20
 
unless Enumerable.method_defined? :flat_map
  module Enumerable
    def flat_map
      inject([]) { |a, x| a.concat yield(x) }
    end
  end
end
 
unless Array.method_defined? :keep_if
  class Array
    def keep_if
      delete_if { |x| not yield(x) }
    end
  end
end
 
# select Pythagorean triplets
r = ((1..n).flat_map { |x|
       (x..n).flat_map { |y|
         (y..n).flat_map { |z|
           [[x, y, z]].keep_if { x * x + y * y == z * z }}}})
 
p r # print the array _r_

This is the exact same code, except that it now defines Enumerable#flat_map and Array#keep_if when those methods are missing. It now works with older versions of Ruby, like 1.8.6.

Run BASIC

for  x = 1 to 20 
 for  y = x to 20 
  for  z = y to 20
   if x^2 + y^2 = z^2 then  print "[";x;",";y;",";z;"]"
  next z
 next y
next x

Output:

[3,4,5]
[5,12,13]
[6,8,10]
[8,15,17]
[9,12,15]
[12,16,20]

Scala

def pythagoranTriangles(n: Int) = for {
  x <- 1 to 21
  y <- x to 21
  z <- y to 21
  if x * x + y * y == z * z
} yield (x, y, z)

which is a syntactic sugar for:

 def pythagoranTriangles(n: Int) = (1 to n) flatMap (x => 
  (x to n) flatMap (y => 
    (y to n) filter (z => x * x + y * y == z * z) map (z => 
      (x, y, z))))

Alas, the type of collection returned depends on the type of the collection being comprehended. In the example above, we are comprehending a Range. Since a Range of triangles doesn't make sense, it returns the closest (supertype) collection for which it does, an IndexedSeq.

To get a List out of it, just pass a List to it:

def pythagoranTriangles(n: Int) = for {
  x <- List.range(1, n + 1)
  y <- x to 21
  z <- y to 21
  if x * x + y * y == z * z
} yield (x, y, z)

Sample:

scala> pythagoranTriangles(21)
res36: List[(Int, Int, Int)] = List((3,4,5), (5,12,13), (6,8,10), (8,15,17), (9,12,15), (12,16,20))

Scheme

Scheme has no native list comprehensions, but SRFI-42 [1] provides them:

 
(list-ec (:range x 1 21)
         (:range y x 21)
         (:range z y 21)
         (if (= (* z z) (+ (* x x) (* y y))))
         (list x y z))
 

((3 4 5) (5 12 13) (6 8 10) (8 15 17) (9 12 15) (12 16 20))

Smalltalk

Works with: Pharo version 1.3-13315

 
| test |
 
test := [ :a :b :c | a*a+(b*b)=(c*c) ].
 
(1 to: 20) 
    combinations: 3 atATimeDo: [ :x | 
        (test valueWithArguments: x) 
            ifTrue: [ ':-)' logCr: x ] ].
 
"output on Transcript:
#(3 4 5)
#(5 12 13)
#(6 8 10)
#(8 15 17)
#(9 12 15)
#(12 16 20)"
 

SuperCollider

var pyth = {
  arg n = 10; // default
  all {: [x,y,z],
    x <- (1..n),
    y <- (x..n),
    z <- (y..n),
    (x**2) + (y**2) == (z**2)
    };
};
 
pyth.value(20); // example call

returns

[ [ 3, 4, 5 ], [ 5, 12, 13 ], [ 6, 8, 10 ], [ 8, 15, 17 ], [ 9, 12, 15 ], [ 12, 16, 20 ] ]

Tcl

Tcl does not have list comprehensions built-in to the language, but they can be constructed.

package require Tcl 8.5
 
# from http://wiki.tcl.tk/12574 
proc lcomp {expression args} {
    # Check the number of arguments.
    if {[llength $args] < 2} {
        error "wrong # args: should be \"lcomp expression var1 list1\
            ?... varN listN? ?condition?\""
    }
 
    # Extract condition from $args, or use default.
    if {[llength $args] % 2 == 1} {
        set condition [lindex $args end]
        set args [lrange $args 0 end-1]
    } else {
        set condition 1
    }
 
    # Collect all var/list pairs and store in reverse order.
    set varlst [list]
    foreach {var lst} $args {
        set varlst [concat [list $var] [list $lst] $varlst]
    }
 
    # Actual command to be executed, repeatedly.
    set script {lappend result [subst $expression]}
 
    # If necessary, make $script conditional.
    if {$condition ne "1"} {
        set script [list if $condition $script]
    }
 
    # Apply layers of foreach constructs around $script.
    foreach {var lst} $varlst {
        set script [list foreach $var $lst $script]
    }
 
    # Do it!
    set result [list]
    {*}$script ;# Change to "eval $script" if using Tcl 8.4 or older.
    return $result
}
 
set range {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20}
puts [lcomp {$x $y $z} x $range y $range z $range {$x < $y && $x**2 + $y**2 == $z**2}]

{3 4 5} {5 12 13} {6 8 10} {8 15 17} {9 12 15} {12 16 20}

TI-89 BASIC

TI-89 BASIC does not have a true list comprehension, but it has the seq() operator which can be used for some similar purposes.

{1, 2, 3, 4} → a
seq(a[i]^2, i, 1, dim(a))

produces {1, 4, 9, 16}. When the input is simply a numeric range, an input list is not needed; this produces the same result:

seq(x^2, x, 1, 4)

Visual Basic .NET

Translation of: C#

Module ListComp
    Sub Main()
        Dim ts = From a In Enumerable.Range(1, 20) _
                 From b In Enumerable.Range(a, 21 - a) _
                 From c In Enumerable.Range(b, 21 - b) _
                 Where a * a + b * b = c * c _
                 Select New With { a, b, c }
 
        For Each t In ts
            System.Console.WriteLine("{0}, {1}, {2}", t.a, t.b, t.c)
        Next
    End Sub
End Module

Output:

3, 4, 5
5, 12, 13
6, 8, 10
8, 15, 17
9, 12, 15
12, 16, 20

Wrapl

ALL WITH x <- 1:to(n), y <- x:to(n), z <- y:to(n) DO (x^2 + y^2 = z^2) & [x, y, z];