Sum and product puzzle: Difference between revisions

{{task}}

Solve the "<i>Impossible Puzzle</i>":

 

{{trans|Python}}

 

DefaultDict[Int, Int] d

L(a) arr

V final_pairs = p_pairs.filter((a, b) -> :sum_counts[a + b] == 1)

 

 

{{out}}

<pre>

[(4, 13)]

</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f SUM_AND_PRODUCT_PUZZLE.AWK

BEGIN {

return(1)

}

<p>Output:</p>

<pre>

17 (4+13)

</pre>

 

=={{header|C}}==

{{trans|C#}}

#include <stdio.h>

#include <stdlib.h>

free_list(&candidates);

return 0;

{{out}}

<pre>2352 candidates

=={{header|C++}}==

{{trans|C}}

#include <iostream>

#include <map>

 

return 0;

{{out}}

<pre>2352 candidates

 

=={{header|C sharp}}==

using System.Linq;

using System.Collections.Generic;

public static HashSet<T> ToHashSet<T>(this IEnumerable<T> source) => new HashSet<T>(source);

{{out}}

<pre>

=={{header|Common Lisp}}==

===Version 1===

;;; Calculate all x's and their possible y's.

(defparameter *x-possibleys*

(statement-2

(statement-1b *x-possibleys*)))) ;; => ((PRODUCT . 52) (SUM . 17) (Y . 13) (X . 4))

 

===Version 2===

;;; Algorithm of Rosetta code:

 

 

(find-xy *all-possible-pairs*) ;; => ((4 13))

 

=={{header|D}}==

{{trans|Scala}}

import std.stdio, std.algorithm, std.range, std.typecons;

 

const s3 = s2.filter!(p => mulEq(p).setIntersection(s2).walkLength == 1).array;

s3.filter!(p => sumEq(p).setIntersection(s3).walkLength == 1).writeln;

{{out}}

<pre>[const(Tuple!(int, int))(4, 13)]</pre>

 

With an older version of the LDC2 compiler replace the <code>cartesianProduct</code> line with:

const s1 = iota(1, 101).map!(x => iota(1, 101).map!(y => tuple(x, y))).joiner

The <code>.array</code> turn the lazy ranges into arrays. This is a necessary optimization because D lazy Ranges aren't memoized as Haskell lazy lists.

 

=={{header|Elixir}}==

{{trans|Ruby}}

def sum_and_product do

s1 = for x <- 2..49, y <- x+1..99, x+y<100, do: {x,y}

end

 

 

{{out}}

=={{header|Factor}}==

A loose translation of D.

math.ranges memoize prettyprint sequences sets tools.time ;

IN: rosetta-code.sum-and-product

[ s2 [ mul-eq ] [ sum-eq ] [ only-1 ] bi@ . ] time ;

 

{{out}}

<pre>

Running time: 0.241637693 seconds

</pre>

 

=={{header|Go}}==

 

import "fmt"

}

return pairs

{{out}}

For x + y < 100 (<code>max = 100</code>):

=={{header|Haskell}}==

{{trans|D}}

 

s1, s2, s3, s4 :: [(Int, Int)]

s4 = filter (\p -> length (sumEq p `intersect` s3) == 1) s3

 

{{out}}

<pre>[(4,13)]</pre>

 

Finally, as we expect and need only one solution, Haskell's lazy evaluation strategy will avoid wasted tests if we request only the first item from the possible solution stream.

 

s1, s2, s3, s4 :: [(Int, Int)]

s1 =

 

 

 

sumEq, mulEq :: (Int, Int) -> [(Int, Int)]

sumEq p = filter ((add p ==) . add) s1

mulEq p = filter ((mul p ==) . mul) s1

 

 

main :: IO ()

{{Out}}

<pre>[(4,13)]</pre>

 

=={{header|Java}}==

 

 

import java.util.ArrayList;

return list;

}

 

{{Out}}

 

{{Trans|Haskell}}

'use strict';

 

return s4;

})();

 

{{Out}}

(Finished in 0.69s)

 

===ES6===

{{Trans|Haskell}}

 

const main = () => {

const

// xs :: [Int]

 

// s1 s2, s3, s4 :: [(Int, Int)]

),

);

 

return s3.filter(

);

};

 

 

// add, mul :: (Int, Int) -> Int

mul = xy => xy[0] * xy[1],

 

sumEq = (p, s) => {

const addP = add(p);

},

mulEq = (p, s) => {

},

 

// pairEQ :: ((a, a) -> (a, a)) -> Bool

 

 

 

// enumFromTo :: Int -> Int -> [Int]

length: 1 + n - m

}, (_, i) => m + i);

 

 

// intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

 

// MAIN ---

return main();

{{Out}}

 

=={{header|jq}}==

 

A transcription from the problem statement, with these helper functions:

# For readability:

def collect(c): map(select(c));

 

solve

{{out}}

<pre>[4,13]</pre>

using filters would be much slower in Julia, which often favors fast for loops over lists for speed.

 

using Primes

 

println("Solution: ($j, $(i - j))")

end

 

{{out}}

 

=={{header|Kotlin}}==

 

data class P(val x: Int, val y: Int, val sum: Int, val prod: Int)

print("The only solution is : ")

for ((x, y, _, _) in fact3) println("x = $x, y = $y")

 

{{out}}

=={{header|Lua}}==

{{trans|C++}}

local cnt = 0

for k,v in pairs(t) do

end

 

{{out}}

<pre>2352 candidates

1 candidates

a=4, b=13; S=17, P=52</pre>

 

=={{header|Nim}}==

 

var

for s in sums:

for (x, y) in s.terms:

 

{{out}}

{{trans|REXX}}

for comments see REXX version 4.

Call time 'R'

cnt.=0

take=0

End

{{out}}

<pre>There are 2352 pairs where X+Y <= MAX (and X<Y)

Uses objects for storing the number pairs. Note the computed hash value and the == method

(required to make the set difference work)

Call time 'R'

cnt.=0

::method string -- this creates the string to be shown

expose a b

{{out}}

<pre>There are 2352 pairs where X+Y <= MAX (and X<Y)

=={{header|Perl}}==

{{trans|Raku}}

 

sub grep_unique {

@final_pair = grep_unique(\&sum, @p_pairs);

 

{{out}}

<pre>X = 4, Y = 13</pre>

{{trans|AWK}}

Runs in 0.03s

{{out}}

<pre>

17 (4+13)

</pre>

 

=={{header|Python}}==

 

Based on the Python solution from [[wp:Sum_and_Product_Puzzle#Python_code|Wikipedia]]:

 

from collections import Counter

final_pairs = [(a,b) for a,b in p_pairs if sum_counts[a+b]==1]

 

 

{{out}}

=={{header|Racket}}==

{{trans|D}}To calculate the results faster this program use memorization. So it has a modified version of <code>sum=</code> and <code>mul=</code> to increase the chances of reusing the results.

(define-syntax-rule (define/mem (name args ...) body ...)

(begin

(displayln s4))

 

{{out}}

<pre>Max Sum: 100

{{trans|Python}}

{{works with|Rakudo|2016.07}}

sub sums ($n) { ($_, $n - $_ for 2 .. $n div 2) }

sub product ([$x, $y]) { $x * $y }

 

my @all-pairs = (|($_ X $_+1 .. 98) for 2..97);

my @final-pairs = grep-unique &sum, @p-pairs;

 

 

{{out}}

http://www.win.tue.nl/~gwoegi/papers/freudenthal1.pdf

which had a very clear description.

If debug Then Do

oid='sppn.txt'; 'erase' oid

End

/* Say swl */

{{out}}

<pre>2352 possible pairs

===version 2===

{{trans|AWK}}

Do s=2 To 100

a=satisfies_statement3(s)

If datatype(x/i,'W') Then Return 0

End

{{out}}

<pre>4/13 s=17 p=52

===version 3===

{{trans|GO}}

* X and Y are two different whole numbers greater than 1.

* Their sum is no greater than 100, and Y is greater than X.

End

Say "Elapsed time:" time('E') "seconds"

{{out}}

<pre>There are 2352 pairs where X+Y <= 100 (and X<Y)

===version 4===

Now that I have understood the logic (I am neither S nor P) I have created an alternative to version 3.

* X and Y are two different whole numbers greater than 1.

* Their sum is no greater than 100, and Y is greater than X.

End

Say "Elapsed time:" time('E') "seconds"

{{out}}

<pre>There are 2352 pairs where X+Y <= 100 (and X<Y)

===version 5, fast ===

This REXX version is over &nbsp; '''ten''' &nbsp; times faster than the previous REXX version.

@.= 0; h= 100; @.3= 1 /*assign array default; assign high P.*/

do j=5 by 2 to h /*find all odd primes ≤ 1st argument.*/

else $= 1

end

{{out|output|text=&nbsp; when using the default internal input:}}

<pre>

=={{header|Ruby}}==

{{trans|D}}

def mul(x,y) x * y end

 

s2 = s1.select{|p| sumEq(s1,p).all?{|q| mulEq(s1,q).size != 1} }

s3 = s2.select{|p| (mulEq(s1,p) & s2).size == 1}

 

{{out}}

<pre>

[[4, 13]]

</pre>

 

=={{header|Scala}}==

type XY = (Int, Int)

val step0 = for {

val step4 = step3 filter { sumEq(_).intersect(step3).size == 1 }

println(step4)

{{out}}

<pre>Vector((4,13))</pre>

=={{header|Scheme}}==

 

(import (scheme base)

(scheme cxr)

(number->string (cadar *fact-3*))

"\n"))

 

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

func sums (n) { 2 .. n//2 -> map {|i| [i, n-i] } }

 

var f_pairs = grep_uniq(p_pairs, :sum)

 

{{out}}

<pre>

{{libheader|Wren-dynamic}}

{{libheader|Wren-seq}}

 

var P = Tuple.create("P", ["x", "y", "sum", "prod"])

var fact3 = fact2.where { |c| intersect.call(sumMap[c.sum], fact2).count == 1 }.toList

System.write("The only solution is : ")

 

{{out}}

=={{header|zkl}}==

Damn it Jim, I'm a programmer, not a logician. So I translated the python code found in https://qmaurmann.wordpress.com/2013/08/10/sam-and-polly-and-python/ but I don't understand it. It does seem quite a bit more efficient than the Scala code, on par with the Python code.

var allPairs=[[(a,b); [2..100]; { [a+1..100] },{ a+b<100 }; ROList]]; // 2,304 pairs

 

sOK2:='wrap(s){ 1==sxys[s].filter('wrap(xy){ pOK(xy:mul(_)) }).len() };

allPairs.filter('wrap([(x,y)]){ sOK(x+y) and pOK(x*y) and sOK2(x+y) })

[[ ]] denotes list comprehension, filter1 returns (and stops at) the first thing that is "true", 'wrap creates a closure so the "wrapped" code/function can see local variables (read only). In a [function] prototype, the "[(x,y)]xy]" notation says xy is a list like thing, assign the parts to x & y (xy is optional), used here to just to do it both ways. The ":" says take the LHS and stuff it into the "_".

{{out}}<pre>L(L(4,13))</pre>