4 ms·
Oh, I thought it was doing some kind of prime search. But you have to give it a list of primes to start with? How about one of: print [(x,x+2) for x in prime
by sp332 8y ago
Oh, I thought it was doing some kind of prime search. But you have to give it a list of primes to start with? How about one of:
print [(x,x+2) for x in primes if (x+2 in primes)]
print [(x,y) for x, y in zip(primes, primes[1:]) if x+2 == y]
The simpler one doesn't even require the primes list to be sorted, so I thought the second one would be more equivalent. It's still a lot easier to read and write than Egison one.
- nine_k 8y agoYour first snippet has quadratic performance. The second is closer to the idea. Pattern-matching would be even more obvious is a piece of Haskell: pair :: [x] -> Maybe (x, x) pair p:q:rest = if q = p + 2 then Just (p, q) else Nothing pair _ = Nothing findTwins primes = [x | x <- map pair primes] I suppose that Eigson's power lies in matching of more complex structures, as they mention non-linear matching, matching with multiple results, matching with lexical scoping.
- tromp 8y agoYour Haskell code doesn't quite parse. But the following works: import Data.List primes = Data.List.nubBy (\a b -> gcd a b > 1) [2..] findTwins primes = [(p,q) | (p:q:_) <- tails primes, q == p+2] main = mapM_ print . take 10 . findTwins $ primes Finding primes arbitrarily far apart can be done in Haskell as findBigTwins gap primes = [(p,q) | (p:qs) <- tails primes, let q = p+gap, q `elem` takeWhile (<= q) qs]
- egi 8y agoThank you for your comment! The power of Egison's pattern matching becomes more obvious when we consider more general pattern such as (p, p+ 100) not only (p, p+2). We can write the first 5 prime pairs whose form is (p, p+100) with a small modification for pattern matching for twin primes. (take 5 (match-all primes (list integer) [<join _ <cons $p <join _ <cons ,(+ p 100) _>>>> [p (+ p 100)]])) ;=>{[3 103] [7 107] [13 113] [31 131] [37 137]}
- nerdponx 8y agoI still don't see how this should require nested cons-es and 3 different types of enclosing braces. Not only that, but you have redundancy between the ,(+ p n) part of the pattern and the emitted result of [p (+ p n)]. Point being: I applaud the attempt here, but it's not something I'll ever want to use.
- sp332 8y agoI guess I had just lost the context. It's pretty cool as a pattern-matching demo.
- allenz 8y ago> first snippet has quadratic performance Not if primes is a set.
- Ultimatt 8y agoOr in my fave language: my @primes = (1..∞).grep: *.is-prime; my @twin_primes = map { ($_, $_+2) }, @primes.grep: (*+2).is-prime;
- sp332 8y agoGonna go out on a limb and guess... Perl 6?
- ORioN63 8y ago`my` gives away perl infinite symbol gives away 6 So, yeah. Correct me if I'm wrong.
- Ultimatt 8y agoYup both right. All the clues were there >:3 I could have used Inf instead of the unicode but thats not really whimsical enough for Hacker News. A slightly less listy pattern style is to declare types. Like I'd prefer this sort of declarative style: subset Prime of Int where *.is-prime; subset TwinPrime of Prime where (* + (2|-2)).is-prime; my @twin_primes = grep TwinPrime, ^Inf; Just feels a lot more clear what my intent is and I get some cheap types for later, to use in function parameters that require twin primes.
- nerdponx 8y agoHuh, this is actually making me want to give Perl 6 another try. How is performance on a task like this compared to, say, Python?