aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data update

Browse source
This commit is contained in:
Ingy döt Net 2023-09-16 17:28:03 -07:00
parent 5af6d93694
commit 796d366b97
455 changed files with 7413 additions and 1900 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Task/List-comprehensions/Python/list-comprehensions-1.py
View file

@ -1 +0,0 @@
[(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]

1
Task/List-comprehensions/Python/list-comprehensions-2.py
View file

@ -1 +0,0 @@
((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)

1
Task/List-comprehensions/Python/list-comprehensions-3.py
View file

@ -1 +0,0 @@
[(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]

1
Task/List-comprehensions/Python/list-comprehensions-4.py
View file

@ -1 +0,0 @@
((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)

5
Task/List-comprehensions/Python/list-comprehensions-5.py
View file

@ -1,5 +0,0 @@
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

1
Task/List-comprehensions/Python/list-comprehensions-6.py
View file

@ -1 +0,0 @@
[(x, y, z) for (x, y, z) in triplets(n) if x**2 + y**2 == z**2]

1
Task/List-comprehensions/Python/list-comprehensions-7.py
View file

@ -1 +0,0 @@
((x, y, z) for (x, y, z) in triplets(n) if x**2 + y**2 == z**2)

59
Task/List-comprehensions/Python/list-comprehensions-8.py
View file

@ -1,59 +0,0 @@
from functools import (reduce)
from operator import (add)
# pts :: Int -> [(Int, Int, Int)]
def pts(n):
m = 1 + n
return [(x, y, z) for x in xrange(1, m)
for y in xrange(x, m)
for z in xrange(y, m) if x**2 + y**2 == z**2]
# pts2 :: Int -> [(Int, Int, Int)]
def pts2(n):
m = 1 + n
return bindList(
xrange(1, m)
)(lambda x: bindList(
xrange(x, m)
)(lambda y: bindList(
xrange(y, m)
)(lambda z: [(x, y, z)] if x**2 + y**2 == z**2 else [])))
# pts3 :: Int -> [(Int, Int, Int)]
def pts3(n):
m = 1 + n
return concatMap(
lambda x: concatMap(
lambda y: concatMap(
lambda z: [(x, y, z)] if x**2 + y**2 == z**2 else []
)(xrange(y, m))
)(xrange(x, m))
)(xrange(1, m))
# GENERIC ---------------------------------------------------------
# concatMap :: (a -> [b]) -> [a] -> [b]
def concatMap(f):
return lambda xs: (
reduce(add, map(f, xs), [])
)
# (flip concatMap)
# bindList :: [a] -> (a -> [b]) -> [b]
def bindList(xs):
return lambda f: (
reduce(add, map(f, xs), [])
)
def main():
for f in [pts, pts2, pts3]:
print (f(20))
main()

95
Task/List-comprehensions/Python/list-comprehensions.py Normal file
View file

@ -0,0 +1,95 @@
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)]
def pts(n):
m = 1 + n
return [(x, y, z) for x in xrange(1, m)
for y in xrange(x, m)
for z in xrange(y, m) if x**2 + y**2 == z**2]
# pts2 :: Int -> [(Int, Int, Int)]
def pts2(n):
m = 1 + n
return bindList(
xrange(1, m)
)(lambda x: bindList(
xrange(x, m)
)(lambda y: bindList(
xrange(y, m)
)(lambda z: [(x, y, z)] if x**2 + y**2 == z**2 else [])))
# pts3 :: Int -> [(Int, Int, Int)]
def pts3(n):
m = 1 + n
return concatMap(
lambda x: concatMap(
lambda y: concatMap(
lambda z: [(x, y, z)] if x**2 + y**2 == z**2 else []
)(xrange(y, m))
)(xrange(x, m))
)(xrange(1, m))
# GENERIC ---------------------------------------------------------
# concatMap :: (a -> [b]) -> [a] -> [b]
def concatMap(f):
return lambda xs: (
reduce(add, map(f, xs), [])
)
# (flip concatMap)
# bindList :: [a] -> (a -> [b]) -> [b]
def bindList(xs):
return lambda f: (
reduce(add, map(f, xs), [])
)
def main():
for f in [pts, pts2, pts3]:
print (f(20))
main()