mirror/ioccc
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add hack-a-round for language specified markdown code blocks

Browse Source 
When language is specified in a markdown code block such as:

````
```c
    printf("Hello, world!\n");
```
````

is used, the resulting HTML as produced by `pandoc(1)` combined
with our revised `ioccc.css` is not intent the code block well.

A temporary "_hack-a-round_" is to turn the "markdown code language
specifier" into an HTML comment.  For example:

````
```<!---c-->
    printf("Hello, world!\n");
```
````

This commits turns off existing markdown code language specifiers
for now, while preserving our ability to restore them in the future
when a better  "_hack-a-round_" to the "markdown code language
specifier" problem is found.

The HTML impact if this "_hack-a-round_" is to produce HTML that
looks like this:

```
<pre class="&lt;!---c--&gt;"><code> .. </code></pre>
```

We might be able to create a complex set of classes for each markdown
code language (there won't be very many) in `ioccc.css`, or we might
find a more general CSS (or maybe `pandoc(1)`?) solution.

For now, this hack-a-round will have to do.
This commit is contained in:
Landon Curt Noll committed 2024-04-04 14:50:38 -07:00
1 parent 3919df50fb
commit b66c79254a
700 files changed
+7052 -7056
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

2005/aidan/README.md
+12 -12
View File
@@ -1,6 +1,6 @@
## To build:
```sh
```<!---sh-->
make
```
@@ -10,7 +10,7 @@ code](#alternate-code).
## To use:
```sh
```<!---sh-->
./aidan < puzzle
./aidan seed
@@ -21,7 +21,7 @@ where `seed` is a number.
## Try:
```sh
```<!---sh-->
./try.sh
```
@@ -34,7 +34,7 @@ which is slower, inelegant and not as obscure, as the author put it.
### Alternate build:
```sh
```<!---sh-->
make alt
```
@@ -46,7 +46,7 @@ Use `aidan.alt` as you would `aidan` above.
### Alternate try:
```sh
```<!---sh-->
./try.alt.sh
```
@@ -139,7 +139,7 @@ Telegraph](https://www.telegraph.co.uk/), a UK newspaper.
Now, with modern computers this **can** be solved using brute force, e.g.:
```c
```<!---c-->
#include <stdio.h> /* sudoku-bfi.c */
#define S(t) for(n=0;n<9;v[n++]=0);for(n=0;n<81;n++)if(i[n]){z=1<<i[n];if(v[t]\\
&z)for(;;){if(p<0)goto d;if(i[p]++<9)goto f;i[p]=0;p=s[p];}v[t]|=z;}
@@ -186,20 +186,20 @@ reasons. That's the worst performance I've had from brute-force so far!)
#### Building
```sh
```<!---sh-->
cc -o sudoku-sf sudoku-sf.c
```
or, if using gcc, try:
```sh
```<!---sh-->
gcc -O2 -Wall -Wextra -ansi -pedantic-errors -o sudoku-sf sudoku-sf.c
```
#### Testing (optional)
```sh
```<!---sh-->
perl ./test-su.perl
```
@@ -211,7 +211,7 @@ really.
#### Solving
```sh
```<!---sh-->
./aidan < somefile.txt
```
@@ -232,7 +232,7 @@ though slightly slower. See if you can figure out what it does.)
#### Generating
```sh
```<!---sh-->
./sudoku <seed>
```
@@ -292,7 +292,7 @@ least 32. (No, that isn't a typo - I did say 15, not 16).
Also requires that `cpp` can properly handle something like:
```c
```<!---c-->
#define foo(x,y) x y
foo(bar,)
```
2005/aidan/index.html
+22 -22
View File
@@ -141,25 +141,25 @@ Location: <a href="../../location.html#GB">GB</a> - <em>United Kingdom of Great
<!-- START: this line starts content for HTML phase 21 by: bin/pandoc-wrapper.sh via bin/md2html.sh -->
<h2 id="to-build">To build:</h2>
<div class="sourceCode" id="cb1"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a> <span class="fu">make</span></span></code></pre></div>
<pre class="&lt;!---sh--&gt;"><code> make</code></pre>
<p>There is an alternate version based on the author’s remarks. See <a href="#alternate-code">alternate
code</a>.</p>
<h2 id="to-use">To use:</h2>
<div class="sourceCode" id="cb2"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a> <span class="ex">./aidan</span> <span class="op">&lt;</span> puzzle</span>
<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a> <span class="ex">./aidan</span> seed</span></code></pre></div>
<pre class="&lt;!---sh--&gt;"><code> ./aidan &lt; puzzle
./aidan seed</code></pre>
<p>where <code>seed</code> is a number.</p>
<h2 id="try">Try:</h2>
<div class="sourceCode" id="cb3"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a> <span class="ex">./try.sh</span></span></code></pre></div>
<pre class="&lt;!---sh--&gt;"><code> ./try.sh</code></pre>
<h2 id="alternate-code">Alternate code:</h2>
<p>This code is formatted differently and is not the approach used by the author
which is slower, inelegant and not as obscure, as the author put it.</p>
<h3 id="alternate-build">Alternate build:</h3>
<div class="sourceCode" id="cb4"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a> <span class="fu">make</span> alt</span></code></pre></div>
<pre class="&lt;!---sh--&gt;"><code> make alt</code></pre>
<h3 id="alternate-use">Alternate use:</h3>
<p>Use <code>aidan.alt</code> as you would <code>aidan</code> above.</p>
<h3 id="alternate-try">Alternate try:</h3>
<div class="sourceCode" id="cb5"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a> <span class="ex">./try.alt.sh</span></span></code></pre></div>
<pre class="&lt;!---sh--&gt;"><code> ./try.alt.sh</code></pre>
<h2 id="judges-remarks">Judges’ remarks:</h2>
<p>Are you puzzled about puzzles? This entry might puzzle you
more while it puzzles out some puzzles: all in a puzzling way!</p>
@@ -223,14 +223,14 @@ figure out how to solve them, but there’s a useful tutorial on
<a href="http://www.sudoku.org.uk/" class="uri">http://www.sudoku.org.uk/</a>, which is roughly affiliated with the <a href="https://www.telegraph.co.uk/">Daily
Telegraph</a>, a UK newspaper.</p>
<p>Now, with modern computers this <strong>can</strong> be solved using brute force, e.g.:</p>
<div class="sourceCode" id="cb7"><pre class="sourceCode c"><code class="sourceCode c"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a> <span class="pp">#include </span><span class="im">&lt;stdio.h&gt;</span><span class="pp"> </span><span class="co">/* sudoku-bfi.c */</span></span>
<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a> <span class="pp">#define S</span><span class="op">(</span><span class="pp">t</span><span class="op">)</span><span class="pp"> </span><span class="cf">for</span><span class="op">(</span><span class="pp">n</span><span class="op">=</span><span class="dv">0</span><span class="op">;</span><span class="pp">n</span><span class="op">&lt;</span><span class="dv">9</span><span class="op">;</span><span class="pp">v</span><span class="op">[</span><span class="pp">n</span><span class="op">++]=</span><span class="dv">0</span><span class="op">);</span><span class="cf">for</span><span class="op">(</span><span class="pp">n</span><span class="op">=</span><span class="dv">0</span><span class="op">;</span><span class="pp">n</span><span class="op">&lt;</span><span class="dv">81</span><span class="op">;</span><span class="pp">n</span><span class="op">++)</span><span class="cf">if</span><span class="op">(</span><span class="pp">i</span><span class="op">[</span><span class="pp">n</span><span class="op">]){</span><span class="pp">z</span><span class="op">=</span><span class="dv">1</span><span class="op">&lt;&lt;</span><span class="pp">i</span><span class="op">[</span><span class="pp">n</span><span class="op">];</span><span class="cf">if</span><span class="op">(</span><span class="pp">v</span><span class="op">[</span><span class="pp">t</span><span class="op">]</span><span class="pp">\</span><span class="op">\</span></span>
<span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a><span class="pp"> </span><span class="op">&amp;</span><span class="pp">z</span><span class="op">)</span><span class="cf">for</span><span class="op">(;;){</span><span class="cf">if</span><span class="op">(</span><span class="pp">p</span><span class="op">&lt;</span><span class="dv">0</span><span class="op">)</span><span class="cf">goto</span><span class="pp"> d</span><span class="op">;</span><span class="cf">if</span><span class="op">(</span><span class="pp">i</span><span class="op">[</span><span class="pp">p</span><span class="op">]++&lt;</span><span class="dv">9</span><span class="op">)</span><span class="cf">goto</span><span class="pp"> f</span><span class="op">;</span><span class="pp">i</span><span class="op">[</span><span class="pp">p</span><span class="op">]=</span><span class="dv">0</span><span class="op">;</span><span class="pp">p</span><span class="op">=</span><span class="pp">s</span><span class="op">[</span><span class="pp">p</span><span class="op">];}</span><span class="pp">v</span><span class="op">[</span><span class="pp">t</span><span class="op">]|=</span><span class="pp">z</span><span class="op">;}</span></span>
<span id="cb7-4"><a href="#cb7-4" aria-hidden="true" tabindex="-1"></a> <span class="dt">int</span> i<span class="op">[</span><span class="dv">82</span><span class="op">],</span>s<span class="op">[</span><span class="dv">81</span><span class="op">],</span>v<span class="op">[</span><span class="dv">9</span><span class="op">],</span>n<span class="op">,</span>p<span class="op">,</span>z<span class="op">;</span><span class="dt">int</span> main<span class="op">(</span><span class="dt">void</span><span class="op">){</span><span class="cf">for</span><span class="op">(</span>n<span class="op">=</span><span class="dv">0</span><span class="op">;</span>n<span class="op">&lt;</span><span class="dv">81</span><span class="op">;){</span>p<span class="op">=</span>getchar<span class="op">()^</span><span class="dv">48</span><span class="op">;</span><span class="cf">if</span><span class="op">(</span>p<span class="op">==</span></span>
<span id="cb7-5"><a href="#cb7-5" aria-hidden="true" tabindex="-1"></a> <span class="dv">30</span><span class="op">)</span>p<span class="op">=</span><span class="dv">0</span><span class="op">;</span><span class="cf">if</span><span class="op">(</span>p<span class="op">&lt;</span><span class="dv">10</span><span class="op">)</span>i<span class="op">[</span>n<span class="op">++]=</span>p<span class="op">;}</span>i<span class="op">[</span><span class="dv">81</span><span class="op">]=</span><span class="dv">0</span><span class="op">;</span>p<span class="op">=-</span><span class="dv">1</span><span class="op">;</span>f<span class="op">:</span>S<span class="op">(</span>n<span class="op">%</span><span class="dv">9</span><span class="op">)</span>S<span class="op">(</span>n<span class="op">/</span><span class="dv">9</span><span class="op">)</span>S<span class="op">(</span>n<span class="op">%</span><span class="dv">9</span><span class="op">/</span><span class="dv">3</span><span class="op">+</span>n<span class="op">/</span><span class="dv">27</span><span class="op">*</span><span class="dv">3</span><span class="op">)</span><span class="cf">if</span><span class="op">(</span>p<span class="op">&gt;</span><span class="dv">80</span><span class="op">)</span><span class="cf">goto</span></span>
<span id="cb7-6"><a href="#cb7-6" aria-hidden="true" tabindex="-1"></a> d<span class="op">;</span><span class="cf">for</span><span class="op">(</span>n<span class="op">=</span>p<span class="op">;</span>i<span class="op">[++</span>p<span class="op">];);</span>s<span class="op">[</span>p<span class="op">]=</span>n<span class="op">;</span>i<span class="op">[</span>p<span class="op">]=</span><span class="dv">1</span><span class="op">;</span><span class="cf">goto</span> f<span class="op">;</span>d<span class="op">:</span>z<span class="op">=</span>p<span class="op">&lt;</span><span class="dv">81</span><span class="op">;</span>printf<span class="op">(</span><span class="st">&quot;</span><span class="sc">\n%s</span><span class="st">!</span><span class="sc">\n\n</span><span class="st">&quot;</span><span class="op">,</span>z<span class="op">?</span><span class="st">&quot;Fail&quot;</span><span class="op">:</span></span>
<span id="cb7-7"><a href="#cb7-7" aria-hidden="true" tabindex="-1"></a> <span class="st">&quot;Success&quot;</span><span class="op">);</span><span class="cf">for</span><span class="op">(</span>n<span class="op">=</span><span class="dv">0</span><span class="op">;</span>n<span class="op">&lt;</span><span class="dv">81</span><span class="op">;){</span>p<span class="op">=</span>i<span class="op">[</span>n<span class="op">];</span>printf<span class="op">(</span><span class="st">&quot;</span><span class="sc">%c</span><span class="st"> </span><span class="sc">%s</span><span class="st">&quot;</span><span class="op">,(</span>p<span class="op">?</span>p<span class="op">|</span><span class="dv">48</span><span class="op">:</span><span class="ch">&#39;.&#39;</span><span class="op">),(++</span>n<span class="op">%</span><span class="dv">3</span><span class="op">?</span><span class="st">&quot;&quot;</span><span class="op">:</span>n<span class="op">%</span><span class="dv">9</span><span class="op">?</span><span class="st">&quot;| &quot;</span></span>
<span id="cb7-8"><a href="#cb7-8" aria-hidden="true" tabindex="-1"></a> <span class="op">:</span>n<span class="op">%</span><span class="dv">27</span><span class="op">?</span><span class="st">&quot;</span><span class="sc">\n</span><span class="st">&quot;</span><span class="op">:</span>n<span class="op">%</span><span class="dv">81</span><span class="op">?</span><span class="st">&quot;</span><span class="sc">\n</span><span class="st">------+-------+------</span><span class="sc">\n</span><span class="st">&quot;</span><span class="op">:</span><span class="st">&quot;</span><span class="sc">\n\n</span><span class="st">&quot;</span><span class="op">));}</span><span class="cf">return</span> z<span class="op">;}</span></span></code></pre></div>
<pre class="&lt;!---c--&gt;"><code> #include &lt;stdio.h&gt; /* sudoku-bfi.c */
#define S(t) for(n=0;n&lt;9;v[n++]=0);for(n=0;n&lt;81;n++)if(i[n]){z=1&lt;&lt;i[n];if(v[t]\\
&amp;z)for(;;){if(p&lt;0)goto d;if(i[p]++&lt;9)goto f;i[p]=0;p=s[p];}v[t]|=z;}
int i[82],s[81],v[9],n,p,z;int main(void){for(n=0;n&lt;81;){p=getchar()^48;if(p==
30)p=0;if(p&lt;10)i[n++]=p;}i[81]=0;p=-1;f:S(n%9)S(n/9)S(n%9/3+n/27*3)if(p&gt;80)goto
d;for(n=p;i[++p];);s[p]=n;i[p]=1;goto f;d:z=p&lt;81;printf(&quot;\n%s!\n\n&quot;,z?&quot;Fail&quot;:
&quot;Success&quot;);for(n=0;n&lt;81;){p=i[n];printf(&quot;%c %s&quot;,(p?p|48:&#39;.&#39;),(++n%3?&quot;&quot;:n%9?&quot;| &quot;
:n%27?&quot;\n&quot;:n%81?&quot;\n------+-------+------\n&quot;:&quot;\n\n&quot;));}return z;}</code></pre>
<blockquote>
<p>Judges’ note: this was added as <a href="aidan.alt.c">aidan.alt.c</a>.</p>
</blockquote>
@@ -259,17 +259,17 @@ also has trouble - it took 66 seconds to solve it - but probably for different
reasons. That’s the worst performance I’ve had from brute-force so far!)</p>
<h3 id="usage">Usage</h3>
<h4 id="building">Building</h4>
<div class="sourceCode" id="cb9"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a> <span class="fu">cc</span> <span class="at">-o</span> sudoku-sf sudoku-sf.c</span></code></pre></div>
<pre class="&lt;!---sh--&gt;"><code> cc -o sudoku-sf sudoku-sf.c</code></pre>
<p>or, if using gcc, try:</p>
<div class="sourceCode" id="cb10"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a> <span class="fu">gcc</span> <span class="at">-O2</span> <span class="at">-Wall</span> <span class="at">-Wextra</span> <span class="at">-ansi</span> <span class="at">-pedantic-errors</span> <span class="at">-o</span> sudoku-sf sudoku-sf.c</span></code></pre></div>
<pre class="&lt;!---sh--&gt;"><code> gcc -O2 -Wall -Wextra -ansi -pedantic-errors -o sudoku-sf sudoku-sf.c</code></pre>
<h4 id="testing-optional">Testing (optional)</h4>
<div class="sourceCode" id="cb11"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a> <span class="fu">perl</span> ./test-su.perl</span></code></pre></div>
<pre class="&lt;!---sh--&gt;"><code> perl ./test-su.perl</code></pre>
<p>Note that this requires Perl 5 (I use 5.8.5, earlier versions untested) and is
somewhat slow (should take under a minute on a fairly modern PC - try
appending <code>-n 0</code> if you’re in a hurry). I wrote it mostly for my own benefit,
really.</p>
<h4 id="solving">Solving</h4>
<div class="sourceCode" id="cb12"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a> <span class="ex">./aidan</span> <span class="op">&lt;</span> somefile.txt</span></code></pre></div>
<pre class="&lt;!---sh--&gt;"><code> ./aidan &lt; somefile.txt</code></pre>
<p>Input should be the numbers of each row in turn. Empty spaces can be
represented as a full stop (<code>.</code>) or zero (<code>0</code>). Other characters are ignored, so you
can cut-and-paste either example sudoku puzzle from above into a file and feed that
@@ -282,7 +282,7 @@ an extra 15 bytes of (very simple) code to add, so it doesn’t really matter to
me. (It’s the same as the normal mode for most input you’re likely to feed it,
though slightly slower. See if you can figure out what it does.)</p>
<h4 id="generating">Generating</h4>
<div class="sourceCode" id="cb13"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb13-1"><a href="#cb13-1" aria-hidden="true" tabindex="-1"></a> <span class="ex">./sudoku</span> <span class="op">&lt;</span>seed<span class="op">&gt;</span></span></code></pre></div>
<pre class="&lt;!---sh--&gt;"><code> ./sudoku &lt;seed&gt;</code></pre>
<p>Output is a blank grid, then the solution, then the problem. There’s no
control over the difficulty. Sorry. However, all generated sudokus should have
exactly one solution - if one doesn’t, that’s a bug.</p>
@@ -321,8 +321,8 @@ can’t help you figure out where the mistake is, sadly.</p></li>
<p>Dependant on ASCII, requires that an <code>int</code> is at least 15 bits and a <code>long</code> at
least 32. (No, that isn’t a typo - I did say 15, not 16).</p>
<p>Also requires that <code>cpp</code> can properly handle something like:</p>
<div class="sourceCode" id="cb14"><pre class="sourceCode c"><code class="sourceCode c"><span id="cb14-1"><a href="#cb14-1" aria-hidden="true" tabindex="-1"></a> <span class="pp">#define foo</span><span class="op">(</span><span class="pp">x</span><span class="op">,</span><span class="pp">y</span><span class="op">)</span><span class="pp"> x y</span></span>
<span id="cb14-2"><a href="#cb14-2" aria-hidden="true" tabindex="-1"></a> foo<span class="op">(</span>bar<span class="op">,)</span></span></code></pre></div>
<pre class="&lt;!---c--&gt;"><code> #define foo(x,y) x y
foo(bar,)</code></pre>
<p>Apparently, a few can’t (ANSI C specifically doesn’t require that this works,
though it usually does). Unfortunately, I didn’t discover this issue until too
late. (It was mentioned in the notes for people modifying GCC in the “beware