Plotting hearts with Python and C (github.com)

That's the same style in K&R, which is about as "idiomatic" as it gets. I don't see anything wrong with it.

  #include <stdio.h>

  /* count lines in input */
  main()
  {
      int c, nl;
      nl = 0;
      while ((c = getchar()) != EOF)
          if (c == '\n')
              ++nl;
      printf("%d\n", nl);
  }

  #include <stdio.h>

  #define IN   1  /* inside a word */
  #define OUT  0  /* outside a word */

  /* count lines, words, and characters in input */
  main()
  {
      int c, nl, nw, nc, state;

      state = OUT;
      nl = nw = nc = 0;
      while ((c = getchar()) != EOF) {
          ++nc;
          if (c == '\n')
              ++nl;
          if (c == ' ' || c == '\n' || c == '\t')
              state = OUT;
          else if (state == OUT) {
              state = IN;
              ++nw;
          }
      }
      printf("%d %d %d\n", nl, nw, nc);
  }

  found = 0;
  for (i = 0; i < n && !found; i++)
      for (j = 0; j < m && !found; j++)
          if (a[i] == b[j])
              found = 1;

  if (found)
      /* got one: a[i-1] == b[j-1] */
      ...
  else
      /* didn't find any common element */

  /* count C keywords */
  main()
  {
      int n;
      char word[MAXWORD];

      while (getword(word, MAXWORD) != EOF)
          if (isalpha(word[0]))
              if ((n = binsearch(word, keytab, NKEYS)) >= 0)
                  keytab[n].count++;
      for (n = 0; n < NKEYS; n++)
          if (keytab[n].count > 0)
              printf("%4d %s\n",
                  keytab[n].count, keytab[n].word);
      return 0;
  }

Don't see how.

It's exactly as you might see in K&R, and short enough that there's never going to be confusion from their lack.

I used to code like that for a long time so it doesn't bother me too much. Then I started learning Rust (which uses a C-style syntax but makes braces mandatory ever for single statements) and I started doing it even in C. In hindsight I feel stupid for not doing it earlier, it doesn't add too much noise (at least if you put the opening brace on the same line) and it wards off many potential nasty bugs if you copy code around or use poorly written macros.

I coded like this when I was self taught and then in college. Once I got my first programming job and started fixing other people's bugs that the braces would have avoided, I stopped doing this.

Just very clear code.

I'm sorry but I have to point out the irony in showing so much disgust about a few lines of code that happen to literally say "I love you."

And no unit tests or CI either? This is how rockets and hearts end up in pieces!

Good thing we can indicate our love with persnickety comments and have no need for such a program.

A brief math overview can be found here: http://mathworld.wolfram.com/Cardioid.html

Here's some info that might be handy: http://mathworld.wolfram.com/Cardioid.html

In the README of the repository, I have mentioned a link to a five year old Reddit thread where I have discussed this in detail. Here's the reddit thread: https://www.reddit.com/r/math/comments/1xwuv3/a_mathematical...

Some of the "plot" links to WolframAlpha in that thread do not show the example graphs anymore, so let me rewrite that comment here with updated links. Rewritten comment with updated link now follows.

---

I wanted something that resembles the hearts in playing cards more than it resembles a cardoid, so I made a simpler heart for my girlfriend (now my wife) composed of two simple curves. The heart is plotted with two semicircles and segments of two quartic curves. Here is an explanation of how I arrived at these equations.

PART 1 - Plotting the Two Semicircles

First, we want to draw a circle of radius 1/2 centered at (1/2, 0). We start with an equation of a circle: (x - 1/2)^2 + y^2 = (1/2)^2 ⇔ x^2 - x + y^2 = 0 ⇔ y^2 = x(1 - x). Plot: https://www.wolframalpha.com/input/?i=y%5E2%20%3D%20x%281%20...

With the previous equation, we got both negative and positive values of y, hence a full circle. We want to eliminate the negative values of y, thereby resulting in a semicircle lying above the x-axis. We take square root of both sides: y = sqrt(x(1 - x)). Plot: https://www.wolframalpha.com/input/?i=sqrt%28x%281%20-%20x%2...

Now, we want a mirror image of this curve on the left side of the y-axis, i.e., for negative values of x, we want the same values of y that we see in the above plot. We do this by substituting x with |x| in the above equation: y = sqrt(|x|(1 - |x|)). Plot: https://www.wolframalpha.com/input/?i=Re%28sqrt%28abs%28x%29...

This completes the top portion of the heart with two semicircles.

PART 2 - Plotting the Segments of Two Quartic Curves

Now we try to complete the bottom portion of the heart. I didn't start with quartic curves. Instead, I began with parabolas and arrived at quartic curves. We begin with a single parabola: y^2 = 1 - x. Plot: https://www.wolframalpha.com/input/?i=y%5E2+%3D+1+-+x

We go through the same drill. We first eliminate negative values of y and then mirror the graph on the left side of the y axis: y = sqrt(1 - |x|). Plot: https://www.wolframalpha.com/input/?i=Re%28sqrt%281%20-%20ab...

Let us get a mirror of this plot below the x-axis by multiplying the right hand side by -1: y = -sqrt(1 - |x|). Plot: https://www.wolframalpha.com/input/?i=Re%28-sqrt%281%20-%20a...

But I wanted to get a little bit of concave curvature at the bottom of the curves to resemble the hearts in playing cards. I could get this by a little trick I learnt somewhere online: We can vary the power of |x| between 0.5 and 1.0 to get different curvatures, i.e., we can vary r in y = -sqrt(1 - |x|^r) where 0.5 <= r <= 1.0 to get different curvatures. I liked the concave curvature with r = 0.5, so I chose y = -sqrt(1 - sqrt(|x|)). This turns the segments of parabolas into segments of quartic curves. Plot: <...