‘‘Loopy’’ C loop

Question

What is the smallest number of non-space characters that can be added in order to change the following code into a complete C program that prints  LoopyLoopyLoopyLoopy?

#include<stdio.h>
main(){
<-- ^
| @ |
v --> printf("Loopy");}

Starts as: 5 lines with no leading spaces, totaling 52 non-space characters and 5 within-line spaces.

Possible edits (additions that don't move the original characters):
•   Single non-space characters may replace any of the 5 original spaces.
•   Spaces and non-space characters may be added to the ends of lines.

No-nos and pedantry:
•   No commenting.
•   No additional " quotation marks.
•   No new lines. (Intended, but not made explicit, in the original puzzle statement.)
•   All syntax should abide by The C Programming Language, 2nd Edition, Kernighan & Ritchie.
•   If any variables are used before they are initialized, the program should be successful with any initial values for those variables.

_{Notes about the original puzzle statement: The word visible was used instead of instead of non-space. Adding lines was unintentionally allowed as a newline would count as a character added to the end of an existing line. The line #include<stdio.h> could have been left out for a more streamlined version of essentially the same puzzle, as mentioned by Arkku.}

Answer 1

21

#include<stdio.h>
main(){int v=8;for(;0                   # 13 (because the space doesn't count …
<--v^0;0                                #  4                … as a visible character)
|'@'|0)                                 #  4
v --> printf("Loopy");}

Cleaned up:

#include<stdio.h>
main()
{
    int v=8;
    for(; 0 < --v^0; 0|'@'|0)
        v-- > printf("Loopy");
}

Pretend that the v=8 is in the initialize field of the for statement.  for(v=8; 0 < --v^0; … is a slightly warped version of for(v=8; --v > 0; … or, approximately, for(v=8; v > 0; v--)  (I'm not sweating the fence-post issues for now).  This uses the ^ bitwise exclusive OR operator, for which 0 is the identity; value ^ 0 = value and, in particular, --v^0 = --v.

The step portion (third field) of the for statement evaluates the constant 0|'@'|0 and does nothing with the result, so that is a no-op.  Note that the rules prohibit adding ", but don't mention '.

Naïvely, for(v=8; v > 0; v--) will loop eight times.  But the body of the loop does v--, so v gets decremented twice for each iteration, and the loop runs only four times.  The body of the loop evaluates v-- and printf("Loopy") (evaluating the return code of the printf), compares them, and does nothing with the result of the comparison.

Answer 2

Quick attempt with 24 visible characters:

#include<stdio.h>
main(){f(f(f(f())));}f(v){v
<--v^v
|'@'|
v --> printf("Loopy");}

Explanation:

Put the printf into a function f() that is called 4 times (nested to save on some semicolons) and just make the rest of the stuff valid syntax.

---

Other failed ideas:

• Digraphs / trigraphs - None that could be abused.
• Use of isxdigit - Assuming a simple macro definition that evaluates its argument 4 times in its 4 comparisons, and hoping that <stdio.h> includes <ctype.h>. The latter is true for gcc but sadly the former isn't.
• Use of qsort - Works (probably compiler dependent), but is suboptimal. Example updated first line:

  main(){f(0);}f(v){v||qsort(&v,3,1,f),v

Answer 3

Here's what I came up with: $20$ Characters

  #include
 main(){int v=8;for(;0        //13 characters
 <--v^0;0                    //4 characters
 |'@ |')                     //3 characters
 v --> printf("Loopy");}    

This is basically the same idea as Peregrine Rook, with some minor changes.

I also found this: $19$ characters

 #include<stdio.h>
 main(){int v;for(;-8        //12 characters
 <--v^0;0                    //4 characters
 |'@ |')                     //3 characters
 v --> printf("Loopy");}  

This interestingly enough compiles but doesn't count in this challenge as the value of v is not defined.

Answer 4

19

In accordance with the updated rules:

#include<stdio.h>
main(){int v=4;for('\
<-- ^\
| @ |';v;)
v --> printf("Loopy");}

16 or 17

The original rules (in effect at the time of posting this) unintentionally permitted adding a newline character to the end of a line, which enabled:

#include<stdio.h>
v;
main(){for(;-8
<--v^0;'\
| @ |')
v --> printf("Loopy");}

(16 if adding a newline character to end of line counts as space, 17 if it counts as a non-space.)

Note: The type of the global v defaults to int and is implicitly initialized to zero in ANSI C (the standard at the time of K&R 2nd edition) due to static duration.

15

If it were permitted to insert a single non-space character between two non-space characters:

#include<stdio.h>
main(v){for(;-8
<--v^0;'\
| @ |')
v --> printf("Loopy");}

This with the caveat:

The program must be run without arguments in an environment that passes 1 as the initial argument of main in that case. (As discussed in comments, this is permitted.)

Answer 5

Only 19

My code is:

#include<stdio.h>
main(){for(int v=8;0           // Here 12 non-space characters          
<--v^0;0                       // Here 4 non-space characters        
|'@ |')                        // Here 3 non-space characters          
v --> printf("Loopy");}

so, total of 19 non-space characters