24
\$\begingroup\$

My father who was a really good APLer and taught me all the basics of APL (and much more), passed away on this day, five years ago. In preparation for 50 Years of APL, I found this patent letter (translated for the convenience of those who do not read Danish) for a handwritten logo. It explains a major reason for APL never gaining a large user base – a reason which of course applies to all of this community's amazing golfing languages too:


A 3497/77                           Req. 29th Aug. 1977 at 13

EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS …

Henri Brudzewsky, engineering consultancy company, Mindevej 28, Søborg,

class 9, including computers, especially APL coded computers,
class 42: IT service agency company, especially during use of APL coded computers.


Task

Produce infinitely repeating output of the text EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS with no newlines. You may begin the text with EASIER or FASTER or FEWER.

\$\endgroup\$
  • \$\begingroup\$ I misinterpreted your challenge and what I did was i.imgur.com/qKnTj3q.png ! \$\endgroup\$ – sergiol Nov 12 '17 at 0:14
  • \$\begingroup\$ @sergiol Almost valid over here. \$\endgroup\$ – Adám Nov 12 '17 at 0:23

37 Answers 37

13
\$\begingroup\$

05AB1E, 25 bytes

[‘æƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂ ‘?

Try it online!

Explanation:

[‘æƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂ ‘?
[                         Start infinite loop
 ‘æƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂ ‘   Push the compressed string in uppercase, starting from FEWER, with a trailing space
                        ?  Print without trailing newline
\$\endgroup\$
  • 13
    \$\begingroup\$ Honestly, I don't understand why Python solutions get explanations and this one doesn't. What in the world is happening here? \$\endgroup\$ – nluigi May 7 '17 at 20:39
  • 3
    \$\begingroup\$ @nluigi black magic \$\endgroup\$ – Nic Robertson May 7 '17 at 22:10
  • 2
    \$\begingroup\$ It's physically impossible to know what is going on here if you don't know the language, would you mind giving an explanation please. \$\endgroup\$ – George Willcox May 8 '17 at 7:23
  • 1
    \$\begingroup\$ @nluigi The [ means 'start of infinite loop', the ‘æƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂ ‘ is a compressed version of EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS , and ? means print without newline. \$\endgroup\$ – Okx May 8 '17 at 10:35
  • 1
    \$\begingroup\$ @Leo That's greatly under-explained. First, you go to this file. To the right of some of the extended characters, you can see a number. If it's one-digit, pad with a leading zero. Two such chars form a 4-digit number with possible leading zeroes. Then, this number is used as an zero-based index to this dictionary. The behavior of each word then depends on the quotes, which you can find on the first file I linked by searching for compressed. \$\endgroup\$ – Erik the Outgolfer May 8 '17 at 12:14
41
\$\begingroup\$

SVG(HTML5), 336 bytes

<svg width=500 height=500><defs><path id=p d=M49,250a201,201,0,0,1,402,0a201,201,0,0,1,-402,0></defs><text font-size="32"><textPath xlink:href=#p>EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS</textPath><animateTransform attributeName=transform type=rotate from=360,250,250 to=0,250,250 dur=9s repeatCount=indefinite>

Edit: Some people have found that the font doesn't quite fit for them so here is a version that allows you a few pixels of adjustment:

<p><input type=number value=0 min=0 max=9 oninput=p.setAttribute('d','M250,250m20_,0a20_,20_,0,1,1,-20_,-20_a20_,20_,0,1,1,-20_,20_a20_,20_,0,1,1,20_,20_a20_,20_,0,1,1,20_,-20_'.replace(/_/g,this.value))></p>
<svg width=500 height=500><defs><path id=p d=M250,250m200,0a200,200,0,1,1,-200,-200a200,200,0,1,1,-200,200a200,200,0,1,1,200,200a200,200,0,1,1,200,-200></defs><text font-size="32"><textPath xlink:href=#p>EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS</textPath><animateTransform attributeName=transform type=rotate from=360,250,250 to=0,250,250 dur=9s repeatCount=indefinite>

\$\endgroup\$
  • \$\begingroup\$ This is beautiful, but can you make it inside out (top of letters facing out from the circle) and all uppercase? \$\endgroup\$ – Adám May 7 '17 at 15:38
  • \$\begingroup\$ @Adám How's this? I've had to tweak the dimensions slightly but it's the same byte count. \$\endgroup\$ – Neil May 7 '17 at 16:24
  • 1
    \$\begingroup\$ @Adám, you should; that's what I thought this challenge was going to be when I first read it. \$\endgroup\$ – Shaggy May 7 '17 at 18:25
  • 8
    \$\begingroup\$ There's a space missing in "MEANSEASIER", which is present between other words. \$\endgroup\$ – ShreevatsaR May 8 '17 at 1:58
  • 1
    \$\begingroup\$ @ShreevatsaR I've added a second version which includes a textbox for making small adjustments, maybe that helps. \$\endgroup\$ – Neil May 8 '17 at 12:27
13
\$\begingroup\$

PHP, 76 Bytes

for(;;)echo strtr(EASI0MMUNICATION1FAST0DING1FEW0DERS1,["ER CO"," MEANS "]);

Try it online!

\$\endgroup\$
  • 4
    \$\begingroup\$ Only in PHP.... \$\endgroup\$ – immibis May 8 '17 at 4:18
  • \$\begingroup\$ @immibis What do you mean? \$\endgroup\$ – Jörg Hülsermann May 8 '17 at 8:55
  • \$\begingroup\$ I mean you managed to demonstrate at least 3 PHP "design quirks" in one line of code. This line of code is an illustration of why PHP is considered harmful. \$\endgroup\$ – immibis May 8 '17 at 9:07
  • 1
    \$\begingroup\$ @immibis "mimimi don't like php" Thought we were past that point for like a decade. :-) \$\endgroup\$ – Zsolt Szilagy May 8 '17 at 15:40
  • 4
    \$\begingroup\$ @Arc676 First, a name without a dollar sign is assumed to be a constant. Second, an undefined constant is assumed to be itself as a string. So in this code EASI0MMUNICATION1FAST0DING1FEW0DERS1 is treated as the string "EASI0MMUNICATION1FAST0DING1FEW0DERS1". Third, strtr expects an associative array (a "map" or "dictionary" in other languages), but this code passed in a regular array, so it treats the regular array as an associative array with keys 0 and 1. Finally, those integers 0 and 1 get treated as strings "0" and "1" because, you guessed it, the function needs strings. \$\endgroup\$ – wavemode May 9 '17 at 14:53
11
\$\begingroup\$

Vim 69 bytes

qqAFEWER CODERS MEANS EASIER COMMUNICATION M<C-n> FASTER CODING M<C-n> <esc>@qq@q
\$\endgroup\$
  • \$\begingroup\$ I just love it when a straightforward Vim command sequence makes for a decent code golf solution. :-D \$\endgroup\$ – DevSolar May 8 '17 at 9:05
7
\$\begingroup\$

HTML, 122 bytes.

Sorry, can't help myself.

<marquee style="width:5em;word-spacing:5em;">EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS </marquee>

\$\endgroup\$
  • \$\begingroup\$ why the huge word spacing? \$\endgroup\$ – Adám May 8 '17 at 19:53
  • \$\begingroup\$ @Adám Because a marquee always leaves that amount of width between iterations (i.e. its own width). And I couldn't find a way to collapse that, so I had to improvise and put the same amount of space between each word as well. \$\endgroup\$ – Mr Lister May 8 '17 at 19:56
  • \$\begingroup\$ Can't you remove the end tag? \$\endgroup\$ – NoOneIsHere Nov 12 '17 at 17:10
  • \$\begingroup\$ @NoOneIsHere How would that help? Or did you mean it would golf it down by 10 bytes? I'm not sure I want to do that; the end tag is not actually optional. \$\endgroup\$ – Mr Lister Nov 12 '17 at 18:00
  • \$\begingroup\$ @MrLister I meant golf it down. I thought single-tag HTML documents didn't need the end tag. \$\endgroup\$ – NoOneIsHere Nov 12 '17 at 18:49
6
\$\begingroup\$

Python 2, 82 81 bytes

-1 byte thanks to Leaky Nun.

I'm probably doing something wrong but it's really late so meh. Note the trailing comma.

while 1:print'FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS',

Try it online!

Another solution, 85 bytes

I can probably golf this further.

while 1:print'%sER CO%s MEANS'*3%('FEW','DERS',' EASI','MMUNICATION',' FAST','DING'),

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ You can delete the second space. \$\endgroup\$ – Leaky Nun May 7 '17 at 8:39
  • \$\begingroup\$ @LeakyNun How did I miss that? o0 Thanks! \$\endgroup\$ – totallyhuman May 7 '17 at 8:42
  • \$\begingroup\$ In the second one, you can move the spaces into the format string. \$\endgroup\$ – wizzwizz4 May 7 '17 at 10:36
  • \$\begingroup\$ @wizzwizz4 Leading whitespace is disallowed. \$\endgroup\$ – totallyhuman May 7 '17 at 14:23
  • 2
    \$\begingroup\$ @totallyhuman Currently, you have a bug where it will output "FEWER CODERS MEANSEASIER COMMUNICATION MEANSFASTER CODING MEANSFEWER...". If you change the format string to '%sER CO%s MEANS ' and remove the spaces from the format items, it'll be golfier and work properly. \$\endgroup\$ – wizzwizz4 May 7 '17 at 16:01
5
\$\begingroup\$

Jelly, 33 29 bytes

4 bytes thanks to Erik the Outgolfer.

“©%5ÐƬwȮh¬Þ6.⁷ḷḊḥṫɠlḶṀġß»Œu⁶¢

Try it online!

\$\endgroup\$
  • \$\begingroup\$ 1) You can use a better compressed string: “©%5ÐƬwȮh¬Þ6.⁷ḷḊḥṫɠlḶṀġß» (still need to use Œu and ;⁶) 2) You can use ß instead of 1¿. \$\endgroup\$ – Erik the Outgolfer May 7 '17 at 7:28
5
\$\begingroup\$

Brachylog, 70 bytes

"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "w↰

Try it online!

How it works

"..."w↰
"..."     generate the string "..."
     w    print to STDOUT without trailing newline
      ↰   do the whole thing all over again
\$\endgroup\$
4
\$\begingroup\$

LOLCODE, 116 bytes

HAI 1
IM IN YR O
VISIBLE "FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "!
IM OUTTA YR O
KTHXBYE

Try it online!

\$\endgroup\$
  • \$\begingroup\$ I'm not familiar with LOLCODE. How does this output forever? \$\endgroup\$ – Esolanging Fruit May 7 '17 at 11:49
  • \$\begingroup\$ @Challenger5 IM IN YR ... and IM OUTTA YR ... form an infinite loop. \$\endgroup\$ – Leaky Nun May 7 '17 at 12:09
  • 1
    \$\begingroup\$ You can remove HAI and KTHXBYE as compilers don't require them. Also, no exclamation at end of VISIBLE. \$\endgroup\$ – OldBunny2800 May 7 '17 at 17:14
  • \$\begingroup\$ @OldBunny2800 What version of LOLCODE are you using? In this version, the trailing ! suppresses the carriage return after printing. \$\endgroup\$ – Arc676 May 9 '17 at 9:29
  • \$\begingroup\$ Oh, I forgot about the no-line-break rule. I didn't realize LOLCODE had a way to do this! \$\endgroup\$ – OldBunny2800 May 9 '17 at 11:31
3
\$\begingroup\$

Python 3, 87 bytes

while 1:print(end="FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ")

Try it online!

\$\endgroup\$
  • \$\begingroup\$ What does end= do? \$\endgroup\$ – Adám May 7 '17 at 7:45
  • \$\begingroup\$ @Adám It lets you print without a trailing newline. \$\endgroup\$ – Erik the Outgolfer May 7 '17 at 7:46
  • 3
    \$\begingroup\$ @Adám The default arguments to print are print("",end="\n"). \$\endgroup\$ – Leaky Nun May 7 '17 at 7:46
  • \$\begingroup\$ I thought that substituting ER CO and MEANS (leading+trailing space) would save some bytes, but apparently not. \$\endgroup\$ – Erik the Outgolfer May 7 '17 at 7:55
3
\$\begingroup\$

C (gcc), 92 bytes

main(){for(;printf("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "););}

Try it online!

\$\endgroup\$
3
\$\begingroup\$

Ruby, 77 bytes

assigning " MEANS " to a variable saved all of 1 byte :-)

loop{$><<"EASIER COMMUNICATION#{m=" MEANS "}FASTER CODING#{m}FEWER CODERS"+m}
\$\endgroup\$
3
\$\begingroup\$

HTML/CSS (firefox only), 179 177 183 176 173 bytes

<b id=a>EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS </b>E<a><style>*{margin:0;}a{position:fixed;left:0;right:0;height:1em;background:-moz-element(#a)}

Certianly nowhere near the lowest scores, I just thought it would be fun to get infinite repitition in HTML/CSS, without any JS involved :)

Changelog:

  • Removed quotes around id attribute
  • added "round" background-repeat to stretch the text so it wraps correctly
  • changed to single-line output
  • replace width:100% style with right:0 to save 3 bytes
\$\endgroup\$
  • \$\begingroup\$ Nice try, but that starts over on every line. OP: with no newlines. \$\endgroup\$ – Adám May 8 '17 at 8:28
  • \$\begingroup\$ Any of the answers that print to a terminal will wrap at the end of the row. Try zooming out; you'll see it continues on forever horizontally as well, it's just "hidden" by the browser window. \$\endgroup\$ – dn3s May 8 '17 at 8:37
  • \$\begingroup\$ Also, I wasted a few bytes having the repeating image "round off" so that it wraps more convincingly, hope that helps \$\endgroup\$ – dn3s May 8 '17 at 8:38
  • \$\begingroup\$ Wrapping is fine, but yours doesn't. It could be seen as "printing" infinitely many infinite lines. Just restrict the background to a single line. \$\endgroup\$ – Adám May 8 '17 at 8:39
  • 1
    \$\begingroup\$ yes. i thought i would have to put repeat no-repeat or ; background-repeat: repeat-x, but figured out how to avoid it. Turns out obeying the spec saves bytes! \$\endgroup\$ – dn3s May 8 '17 at 8:56
3
\$\begingroup\$

JavaScript (ES6), 90 87 bytes

while(1)console.log`EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS `

Functioning Alternative, 100 bytes

"Functioning" here meaning "won't crash your browser" (for a while, at least)!

setInterval(_=>console.log`EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS `,1)
\$\endgroup\$
  • 1
    \$\begingroup\$ Your code does not work: document.write`EASIER COMMUNICATION${m=" MEANS "}FASTER CODING${m}FEWER CODERS`+m is equivalent to document.write([ 'EASIER COMMUNICATION', 'FASTER CODING', 'FEWER CODERS' ], ' MEANS ', ' MEANS ') + ' MEANS ', which 1) will convert all arguments to strings and concatenate (printing EASIER COMMUNICATION,FASTER CODING,FEWER CODERS MEANS MEANS ), and 2) won't include the last ' MEANS ' anyways since it's outside the function call... \$\endgroup\$ – Frxstrem May 7 '17 at 18:52
2
\$\begingroup\$

Befunge, 73 bytes

" SNAEM GNIDOC RETSAF SNAEM NOITACINUMMOC REISAE SNAEM SREDOC REWEF">:#,_

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Using Befunge 98, you can replace ">:#,_ with A"k, and save two bytes. Link \$\endgroup\$ – Hactar May 7 '17 at 16:49
2
\$\begingroup\$

Octave, 86 bytes

while fprintf('FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ')end

Explanation:

This is fairly self-explanatory. The only real "trick" here is to use while fprintf. When fprintf is given a return argument, it will return the number of characters printed, and all non-zero numbers are considered true in Octave, so the loop condition will always be true.


I desperately tried to make the more interesting approach shorter, but it turned out to be 9 bytes longer, unfortunately:

while fprintf('FEW%sDERS%sEASI%sMMUNICATION%sFAST%sDING%s',{'ER CO',' MEANS '}{'ababab'-96})end

This tries to insert the strings 'ER CO' and ' MEANS' into the string at the correct locations, using direct indexing where 'ababab'-96 is a shorter version of [1 2 1 2 1 2].

This was a bit shorter (93 bytes), but still longer than the naive approach

while fprintf('FEWER CODERS%sEASIER COMMUNICATION%sFASTER CODING%s',{' MEANS '}{[1,1,1]})end

And another one (89 bytes), using Level River St's approach:

while fprintf(['FEWER CODERS',s=' MEANS ','EASIER COMMUNIDATION',s,'FASTER CODING',s])end

This should work in theory, for one less byte than the original solution, but it fails for some strange reason:

while fprintf"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "
end

This uses the buggy feature that fprintf('abc def') is equivalent to fprintf"abc def". The end must be on the next line, but it's still one byte shorter since two parentheses are skipped.

And one more for 87:

while fprintf('FEWER CODERS%sEASIER COMMUNICATION%sFASTER CODING%s',k=' MEANS ',k,k)end

Well, don't say I didn't try :)

\$\endgroup\$
2
\$\begingroup\$

Alice, 70 bytes

" SNAEM "k"SREDOC REWEF"e0j"GNIDOC RETSAF"e0j"NOITACINUMMOC REISAE"d&o

Try it online!

Explanation

Unfortunately, reusing the MEANS (with spaces) only saves a single byte over just printing the whole thing in one go. Consequently, extracting the ER CO would actually cost a byte (or probably more, because it would be slightly more expensive to extract another section).

" SNAEM "                Push the code points of " MEANS " in reverse.
k                        If there is a return address on the return address stack (which
                         there isn't right now), pop it and jump there.
"SREDOC REWEF"           Push the code points of "FEWER CODERS" in reverse.
e0j                      Jump to the beginning of the line, pushing the location of the
                         j to the return address stack. Hence, we push the code points
                         of " MEANS " again, but then the k pops the return address and
                         jumps back here.
"GNIDOC RETSAF"          Push the code points of "FASTER CODING" in reverse.
e0j                      Jump to the beginning of the line again.
"NOITACINUMMOC REISAE"   Push the code points of "EASIER COMMUNICATION" in reverse.
d                        Push the stack depth.
&o                       Print that many bytes from the top of the stack.
                         Afterwards the IP wraps around to the first column and the
                         program starts over.
\$\endgroup\$
2
\$\begingroup\$

C#, 102 bytes

_=>{for(;;)System.Console.Write("EASIER COMMUNICATION{0}FASTER CODING{0}FEWER CODERS{0}"," MEANS ");};
\$\endgroup\$
1
\$\begingroup\$

Pyth, 69 bytes

Wp"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS 

Try it online!

How it works

Wp"...
W       while the following is true: (do nothing)
 p      print the following and return the following
  "...
\$\endgroup\$
1
\$\begingroup\$

Lua, 92 bytes

while 1 do io.write("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ")end

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Java (OpenJDK 9), 114 bytes

static void f(){while(1>0)System.out.print("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ");}

Try it online! Stop the execution after a few seconds because it does not know when to stop.

\$\endgroup\$
  • \$\begingroup\$ Submissions have to be full programs or functions. \$\endgroup\$ – Cows quack May 7 '17 at 9:53
  • \$\begingroup\$ @KritixiLithos Can it be an anonymous lambda? \$\endgroup\$ – totallyhuman May 7 '17 at 10:04
  • \$\begingroup\$ @totallyhuman Yes. In other languages that's allowed; I don't see why Java should be an exception. \$\endgroup\$ – wizzwizz4 May 7 '17 at 10:40
  • \$\begingroup\$ Why stop execution? Just untick disable output cache. \$\endgroup\$ – Adám May 7 '17 at 15:46
  • 3
    \$\begingroup\$ But you can do for(;;) \$\endgroup\$ – Brian McCutchon May 8 '17 at 4:52
1
\$\begingroup\$

C, 86 bytes

f(){printf("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ");f();}

See it work online.

\$\endgroup\$
  • \$\begingroup\$ This depends upon the compiler doing tail-call optimization, but I guess most do. \$\endgroup\$ – Wayne Conrad May 8 '17 at 17:14
  • \$\begingroup\$ @WayneConrad It is a valid answer without that optimization. Infinite recursion satisfies the requirement: Produce infinitely repeating output \$\endgroup\$ – 2501 May 8 '17 at 17:24
  • \$\begingroup\$ Without tail call optimization, the stack will overflow eventually. Try compiling it with gcc (use default options, so no tail call optimization), and when you run it, redirect output to /dev/null in order to speed up the process. It'll seg fault. With the '-O2' option, which enables tail call optimization, it runs forever as intended. \$\endgroup\$ – Wayne Conrad May 8 '17 at 21:38
  • \$\begingroup\$ @WayneConrad Infinite recursion is conceptually, infinite. The question doesn't constrain to a practical definition of infinite. By common consensus, infinite recursion is infinitely repeating, in other words, no logic within the program will stop it.. \$\endgroup\$ – 2501 May 8 '17 at 22:47
  • \$\begingroup\$ I am not declaring that your solution is invalid. All I meant to point out is that, in order to execute properly, a little cooperation is needed from the compiler. \$\endgroup\$ – Wayne Conrad May 9 '17 at 0:08
1
\$\begingroup\$

bc, 76 bytes

while(1)"EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "
\$\endgroup\$
1
\$\begingroup\$

Perl 6,  81 80  79 bytes

print ('EASIER COMMUNICATION','FASTER CODING','FEWER CODERS'X'MEANS'),' 'for ^Inf

Try it

loop {print ('EASIER COMMUNICATION','FASTER CODING','FEWER CODERS'X'MEANS'),' '}

Try it

loop {print [~] 'EASIER COMMUNICATION','FASTER CODING','FEWER CODERS'X'MEANS '}

Try it

\$\endgroup\$
1
\$\begingroup\$

MATL, 68 bytes

`'EASIER COMMUNICATION*FASTER CODING*FEWER CODERS*'42' MEANS 'Zt&YDT

Try it online!

Explanation

`                                                     % Do...while
  'EASIER COMMUNICATION*FASTER CODING*FEWER CODERS*'  %   Push this string
  42                                                  %   Push 42 (ASCII for '*')
  ' MEANS '                                           %   Push this string  
  Zt                                                  %   String replacement
  &YD                                                 %   printf to STDOUT
  T                                                   %   Push true as loop condition
                                                      % End (implicit)
\$\endgroup\$
1
\$\begingroup\$

Axiom, 92 89 bytes

repeat fortranLiteral"EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "

insert in one line to Axiom window. Possible there is one function shorter than "fortranLiteral" that not write "\n"

\$\endgroup\$
1
\$\begingroup\$

Braingolf, 78 bytes

"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "[!@66<1+>]

or

Braingolf, 77 bytes [non-competing]

"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "[!&@<1+>]

This one's non-competing as I had to fix 2 bugs regarding using the greedy modifier (&) with the char print operator (@)

\$\endgroup\$
1
\$\begingroup\$

Blank, 267 bytes

[70][69][87][69][82][32][67][79][68][69][82][83][32][77][69][65][78][83][32][69][65][83][73][69][82][32][67][79][77][77][85][78][73][67][65][84][73][79][78][32][77][69][65][78][83][32][70][65][83][84][69][82][32][67][79][68][73][78][71][32][77][69][65][78][83][32]{p}

Pushes FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS to the stack, then prints it. Never terminates as no {@}

Also fun fact, I used the following Braingolf script to generate this code

"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "l>[<$_<91+2^9-@_ 91+2^7-@l>]"{p}"@3
\$\endgroup\$
1
\$\begingroup\$

Groovy 79 bytes

m=" MEANS";for(;;)print"EASIER COMMUNICATION$m FASTER CODING$m FEWER CODERS$m "

Uses groovy's string interpolation.

\$\endgroup\$
1
\$\begingroup\$

PowerShell, 100 97 bytes

for(){"EASIER COMMUNICATION","FASTER CODING","FEWER CODERS"|%{Write-Host -NoNewLine "$_ MEANS "}}

Try it online!


Older answer:

PowerShell, 100 bytes

while(1){"EASIER COMMUNICATION","FASTER CODING","FEWER CODERS"|%{Write-Host -NoNewLine "$_ MEANS "}}

Try it online!

PowerShell is a little tricky for this because most dignified ways of outputting to the console also insert a new line. Write-Host is required because of this. However, it still demonstrates how pipelining can shorten the coding footprint.

You will need to stop the execution after a short time because it will not return as it is an infinite loop.

Edit: shaved off 3 bytes by changing a while loop to a for loop.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.