cp-project-euler VS gcodepreview

I do hobby programing. It is sometimes to create something (supposedly) useful. Lately though it is more discovery and a little math like. I enjoy Project Euler (https://projecteuler.net/. Recently I have been playing with superpermutations (https://projecteuler.net/) and pencil and paper is useful but filling lots of paper with lots of numbers is not that fun.

As pointed out in a sibling comment, it appears that quote only shows up if you're logged in, but assuming you have an account and are logged in, it's on the homepage (https://projecteuler.net/), second paragraph under the following heading:

> I learned so much solving problem XXX, so is it okay to publish my solution elsewhere?

> It appears that you have answered your own question. There is nothing quite like that "Aha!" moment when you finally beat a problem which you have been working on for some time. It is often through the best of intentions in wishing to share our insights so that others can enjoy that moment too. Sadly, that will rarely be the case for your readers. Real learning is an active process and seeing how it is done is a long way from experiencing that epiphany of discovery. Please do not deny others what you have so richly valued yourself.

> However, the rule about sharing solutions outside of Project Euler does not apply to the first one-hundred problems, as long as any discussion clearly aims to instruct methods, not just provide answers, and does not directly threaten to undermine the enjoyment of solving later problems. Problems 1 to 100 provide a wealth of helpful introductory teaching material and if you are able to respect our requirements, then we give permission for those problems and their solutions to be discussed elsewhere.

You could say that providing code in an obscure language isn't really to "instruct methods", but I think it's within the spirit of the rules.

A long time ago, when I was playing with Project Euler problems, I had to resolve the following one:

Project Euler: Solve math and programming puzzles that help you think logically and improve your problem-solving skills.

With this newfound perspective, I embarked on a new path. I decided to tackle problems from Project Euler, solving them at scale and under various constraints. It is my hope that this approach will not only provide practical challenges but also allow me to apply and solidify my programming knowledge in a more engaging way.

Could solve Project Euler problems in Lua - aka, the easiest programming language to learn

https://projecteuler.net/

Alternatively, you could get a homeschool math textbook. They're written differently because the assumption is that the kid is going to have to teach themselves, and as such they are significantly more thorough and easy to understand. I highly recommend them. Don't get the kind that are "workbooks", those are usually trash. Find a good textbook that the kid can write in their own notebook for and sell after they're done with it. They'll learn how Ebay works, and algebra!

Project Euler

I read SICP a long while back, so the video lecture was a useful review.

For the balance, I managed to get a working version of my project pretty quickly when the Python version of OpenSCAD first became available: https://pythonscad.org/ but I quickly hit a plateau and was having trouble adding features and improving it, so I began researching and trying to learn what I needed for:

https://github.com/WillAdams/gcodepreview

Been collecting lists of the books I've been using at:

https://www.goodreads.com/review/list/21394355-william-adams...

https://www.goodreads.com/review/list/21394355-william-adams...

I will note that my preference (as a person coming at this from (La)TeX is for Literate Programming:

http://literateprogramming.com/

so have also put together:

https://www.goodreads.com/review/list/21394355-william-adams...

Still chugging away at:

https://github.com/WillAdams/gcodepreview

Currently finishing up a re-write which changes from using union commands (which resulted in an ever more deeply nested CSG tree) to collecting everything in a pair of lists using append/extend and then applying one each union operation, resulting a flatter structure.

Once all that is done I'm hoping to add support for METAFONT/POST curves....

My current project for a while was in a state where it was necessary to keep code in 3 separate files:

- gcodepreview.py (gcpy) --- the Python functions and variables

- pygcodepreview.scad (pyscad) --- the Python functions wrapped in OpenSCAD

- gcodepreview.scad (gcpscad) --- OpenSCAD modules and variables

as explained in: https://github.com/WillAdams/gcodepreview/blob/main/gcodepre... and it worked quite well (far better than the tiled set of three text editor windows which I was using at first) and I find the ability to sequence the code for the separate files in a single master file very helpful.

Well, I worked up:

https://github.com/WillAdams/gcodepreview/blob/main/literati...

for my current project (and will use it going forward for any new ones) and:

https://github.com/topics/literate-programming

has 443 projects...

For me, it's Bézier curves --- Freya Holmér has a wonderful video on them:

https://www.youtube.com/watch?v=jvPPXbo87ds

and I've been trying to read through _METAFONT: The Program_ and https://pomax.github.io/bezierinfo/ and I keep wondering if I shouldn't just try scripting Inkscape....

I want to do a couple of different things, and not sure if they all fit in one project or no:

- implement a single line font in my current project: https://github.com/WillAdams/gcodepreview

- implement a way to convert arbitrary curves into smooth arcs (for DXFs or G2/G3 arcs for G-code)

- work up an interactive version of METAFONT/METAPOST which allows both programming and drawing

Yeah, that sums things up well --- the problem of course is what happens when one works on a project which blurs boundaries.

I had to drop into BlockSCAD to rough out an arc algorithm for my current project:

https://github.com/WillAdams/gcodepreview

(see the subsubsection "Arcs for toolpaths and DXFs")

Jupyter Notebooks come close to allowing a seamless blending of text and algorithm, but they are sorely missing on the graphic design and vector graphics front --- which now that I write that, makes me realize that that is the big thing which I miss when trying to use them. Makes me wish for JuMP, a Jupyter Notebook which incorporates METAPOST --- if it also had an interactive drawing mode, it would be perfect.... (for my needs).

I've actually been using OpenPythonSCAD for this sort of thing:

https://pythonscad.org/

paired with:

https://www.blockscad3d.com/editor/

it lets me rough out an algorithm (see the section on arcs in: https://github.com/WillAdams/gcodepreview/blob/main/gcodepre... ) interactively, seeing the result on-screen --- then once I have the rough concept, I can re-write it in Python, retaining this interactivity.

Well, there are pages on problems such as;

https://scriptsofanotherdimension.tumblr.com/

https://blueprintsfromhell.tumblr.com/

and the biggest problem is that a strong bound is screen/display size --- any code chunk which won't fit on a single screen becomes hard to follow (which direction does one scroll next?) and if one does the obvious of declaring modules, then one runs into the wall of text which one was presumably trying to escape from --- just each word is wrapped up in pretty boxes and decorated with lines.

My take on this has always been that we don't have an answer for the question:

>What does an algorithm look like?

That said, I work in this style when I can, often using:

https://www.blockscad3d.com/editor/

to rough out a design, or:

https://github.com/derkork/openscad-graph-editor

for more complex projects --- though that latter usually with a special-purpose library I've been working on: https://github.com/WillAdams/gcodepreview

I'm actually working on something along the lines of:

>CAD engine can do "production-aware design" that constrains design to the capabilities of standardized machines, e.g. keeping a metal part 3-d millable.

by modeling a part by only using subtraction based on tooling:

https://github.com/WillAdams/gcodepreview

you'll need: https://pythonscad.org/ but it's allowed me to do pretty much everything I've tried out in it thus far, and I'm putting the finishing touches on a joinery module which should let one make pretty much anything of wood, and metals should be much the same --- even turned out a thread cutting program as a proof of concept a while back.