Comments for Lingua Computa

Comment on Sudoku solver in C++11 by Thomas Petit

Thomas Petit — Thu, 16 Aug 2012 17:48:49 +0000

What a funny coincidence ! I did the very same exercise (porting norvig sudoku solver to C++11) a few days ago.

Here is where I deviated a bit from your solution :

1) The “operator”" _vec” part. That’s quite fancy
Here is a more common solution: First, overload cross() to take two std::string

std::vector cross(const std::string& s1, const std::string& s2)
{
std::vector output;
for(char c1 : s1){
for(char c2 : s2){
std::string s;
s += c1;
s += c2;
output.push_back(s);
}
}
}

Then, you can fill unitlist this way :

for(const std::string& r : {“ABC”, “DEF”, “GHI”})
for(const std::string& c : {“123″, “456″, “789″}
unitlist.push_back(cross(r, c));

2) When initializing peers, you don’t need to accumulate everything into a std::vector then copy it to the set of peers. You can actually directly accumulate into a std::set this way :

for(const std::string& s : squares){
peers[s] = std::accumulate(units[s].begin(), units[s].end(), std::set(),
[&](std::set& peer, const std::vector& v){
for(const std::string& square : v)
if(square != s)
peer.insert(square );
return peer;
});
}

Comment on Sudoku solver in C++11 by David Grant

David Grant — Wed, 15 Aug 2012 04:02:35 +0000

“Time wise, I found that the C++ implementation followed the same trend as the Python implementation. That is, most problems were solved in less than few milliseconds”

I found that your C++ implementation (with -O2) takes about 4ms for the example problem you gave and about 40ms using the Python solver.

Comment on Sudoku solver in C++11 by Manjunath

Manjunath — Tue, 14 Aug 2012 17:00:08 +0000

Yep, I was wrong. I meant milli when I wrote micro. But the 160 seconds is really in seconds, not milliseconds.

Comment on Sudoku solver in C++11 by David Grant

David Grant — Tue, 14 Aug 2012 16:15:48 +0000

Your time units are a bit messed up. I think for microseconds you should put “us”. And then you say “most problems were solved in less than a few microseconds” where I think you meant to say “milliseconds”. And when you say the hard problem took 160 seconds in C++ did you mean to say millseconds?

Comment on Sudoku solver in C++11 by Eric

Eric — Tue, 14 Aug 2012 03:09:29 +0000

Did you mean to copy elements in all your for loops? ISTR for(auto& elem : container) is needed to avoid a copy. This might be part of the source of the slowly execution time. I’d expect far better results relative to python.

Comment on Sudoku solver in C++11 by Arjun Nayini

Arjun Nayini — Tue, 14 Aug 2012 02:16:30 +0000

Thanks for this. I had hoped to actually write my own in C++ and its nice that you have written this in the latest standard.

Comment on Lazy Lists in Different Languages by googya

googya — Mon, 16 May 2011 07:36:55 +0000

def Take(n,l)
return [] if n==0
return [l['first']]+Take(n-1,l['rest'].call)
end

def From(n)
{‘first’=>n,’rest’=>lambda{From(n+1)}}
end

t=From(1)
puts Take(50,t).inspect

the codes wrote with Ruby! almost the same with Python

Comment on Lazy Lists in Different Languages by Manjunath

Manjunath — Mon, 16 May 2011 00:04:39 +0000

Thanks Don, for the better Haskell way, and others for pointing out Python generators. I wanted to keep the implementation uniform between Python, R, and C++. Yes, Python yield is definitely more natural.

Comment on Lazy Lists in Different Languages by j2d2

j2d2 — Sun, 15 May 2011 21:32:38 +0000

Why not use a Python generator?

Comment on Lazy Lists in Different Languages by Don Stewart

Don Stewart — Sun, 15 May 2011 19:50:20 +0000

Rather than using list boxing and append, your original Haskell could be more simply expressed as:

from n = n : from (n+1)

Though having this lazy in the list, yet strict in the accumulator, would be more sensible:

from !n = n : from (n+1)