我父亲是一个非常出色的APL 专家，曾教过我APL的所有基础知识（以及更多），五年前的这一天就去世了。在准备APL 50年的过程中，我发现了这封专利信函（为不读丹麦语的人提供了便利），以作为手写徽标。它解释了APL从未赢得大量用户的主要原因-当然也适用于该社区所有令人惊叹的高尔夫语言的原因：

3497/77要求 1977年8月29 ^日下午13点

工程咨询公司Henri Brudzewsky，位于索堡的Mindevej 28，

第9类，包括计算机，尤其是APL编码的计算机，
第42类： IT服务代理公司，尤其是在使用APL编码的计算机期间。

任务

产生无重复EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS 行的文本的无限重复输出。您可以以EASIER或FASTER或开头文本FEWER。

05AB1E，25个字节

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

在线尝试！

说明：

[‘æƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂ ‘?
[                         Start infinite loop
 ‘æƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂ ‘   Push the compressed string in uppercase, starting from FEWER, with a trailing space
                        ?  Print without trailing newline

SVG（HTML5），336个字节

<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>

编辑：有些人发现字体不太适合他们，因此这里是一个允许您调整几个像素的版本：

<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>

PHP，76字节

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

在线尝试！

Vim 69字节

qqAFEWER CODERS MEANS EASIER COMMUNICATION M<C-n> FASTER CODING M<C-n> <esc>@qq@q

HTML，122个字节。

抱歉，不能帮助自己。

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

Python 2中，82 81个字节

-1个字节感谢Leaky Nun。

我可能做错了，但是真的很晚了。请注意尾随逗号。

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

在线尝试！

另一种解决方案，85字节

我可能可以进一步打高尔夫球。

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

在线尝试！

果冻，33 29字节

多亏了Erik the Outgolfer 4个字节。

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

在线尝试！

Brachylog，70个字节

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

在线尝试！

怎么运行的

"..."w↰
"..."     generate the string "..."
     w    print to STDOUT without trailing newline
      ↰   do the whole thing all over again

HTML / CSS（仅限Firefox浏览器），179个 177 183 176 173字节

<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)}

毫无疑问，最低分数并不高，我只是认为在不涉及任何JS的情况下获得无限的HTML / CSS替换会很有趣：)

变更日志：

• 删除id属性周围的引号
• 添加了“圆形”背景重复以拉伸文本，以便正确换行
• 更改为单行输出
• 替换width:100%样式right:0以节省3个字节

Python 3, 87 bytes

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

Try it online!

C (gcc), 92 bytes

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

Try it online!

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!

Ruby, 77 bytes

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

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

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)

Befunge, 73 bytes

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

Try it online!

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 :)

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.

C#, 102 bytes

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

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
  "...

Lua, 92 bytes

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

Try it online!

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.

C, 86 bytes

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

See it work online.

bc, 76 bytes

while(1)"EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "

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

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)

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"

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 (@)

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

Groovy 79 bytes

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

Uses groovy's string interpolation.

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.