29
\$\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\$
4
  • 2
    \$\begingroup\$ I misinterpreted your challenge and what I did was i.imgur.com/qKnTj3q.png ! \$\endgroup\$
    – sergiol
    Nov 12, 2017 at 0:14
  • \$\begingroup\$ @sergiol Almost valid over here. \$\endgroup\$
    – Adám
    Nov 12, 2017 at 0:23
  • \$\begingroup\$ Link to patent letter is dead. \$\endgroup\$ Oct 20, 2019 at 4:24
  • \$\begingroup\$ @pppery Thanks. Updated. \$\endgroup\$
    – Adám
    Oct 20, 2019 at 12:32

46 Answers 46

1
2
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\$
1
\$\begingroup\$

Ly, 75 bytes

1[p"EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "&o1]

Try it online!

Explanation:

1[p                                                                      1] # infinitely
   "EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "&o   # print the string
\$\endgroup\$
1
\$\begingroup\$

C# (.NET Core), 125 bytes

class c{static void Main(){for(;;)System.Console.Write("EASIER COMMUNICATION{0}FASTER CODING{0}FEWER CODERS{0}"," MEANS ");}}

This is a full program rather than just a function like the other C# answer.

Test online

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

Keg, 69 bytes

{ SNAEM GNIDOC RETSAF SNAEM NOITACINUMMOC REISAE SNAEM SREDOC REWEF(,

Explanation:

{#                                                                     Infinite loop
  SNAEM GNIDOC RETSAF SNAEM NOITACINUMMOC REISAE SNAEM SREDOC REWEF#   Pushing the string reversed
                                                                   (, #And outputting it reversed

TIO

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

Hexadecimal Stacking Pseudo-Assembly Language, 810 bytes

00000020002040000020005340000020004E40000020004140000020004540000020004D40000020002040000020005340000020005240000020004540000020004440000020004F40000020004340000020002040000020005240000020004540000020005740000020004540000020004640000020002040000020005340000020004E40000020004140000020004540000020004D40000020002040000020004740000020004E40000020004940000020004440000020004F40000020004340000020002040000020005240000020004540000020005440000020005340000020004140000020004640000020002040000020005340000020004E40000020004140000020004540000020004D40000020002040000020004E40000020004F40000020004940000020005440000020004140000020004340000020004940000020004E40000020005540000020004D40000020004D40000020004F400000200043400000200020400000200052400000200045400000200049400000200053400000200041400000200045400000140000010000

Try it online!

000000  Label Start:
200020
400000
.
.
.       push letters
140000  print string
010000  jump to start
\$\endgroup\$
1
\$\begingroup\$

Whitespace, 415 bytes

(much whitespace)

Try it online!

lssl        label start:
sssttssssstsststtsttstsststttsstttsstsstttssstsssttttsttttsttttsttttsststttsstssststtssssstttsttttsstssttsttssttsttsstsssstssttssssssttttttstttsttsttsttstsstssssssttssststttssttttttstttstssssssttsssttsssssttssttsststttstttttttstststsstsssstttstsstsssstsssstttstttsststsssstssssttttstttssstttssttssstsssstssl
            push base 24 sentence "EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "
lsssl       label print:
sssttsssl   24
stsstl      copy 1
stsstl      copy 1
tstt        mod
ssststttl   23
tsst        sub
lsl         dup
ltstl       jz space
ssstttsssl  push 56
tsss        add
lsstl       label space:
ssstsssssl  push 32
tsss        add
tlss        printc
tsts        div
sls         dup
ltsl        jz start
lslsl       jump print
\$\endgroup\$
4
  • 1
    \$\begingroup\$ Would zero as space be shorter since you wouldn't need the 23 sub dup part? \$\endgroup\$
    – Jo King
    Oct 21, 2019 at 12:15
  • \$\begingroup\$ It also works with a zero for space (I did that in my 99 bootles of beer answer.) The problem is, the string must not end with a space. It only works with a leading space which is not allowed afaik. \$\endgroup\$
    – Dorian
    Oct 21, 2019 at 12:42
  • \$\begingroup\$ That makes sense. How about duping the 24 rather than pushing 23 and then subtracting the mod from the duped value and jumping if negative? \$\endgroup\$
    – Jo King
    Oct 21, 2019 at 12:58
  • 1
    \$\begingroup\$ I don't know if I'm understanding something wrong. The mod values are in the range 0-23. If you subtract 24 from that, every value will be negative. If you swap it before subtraction, none of the values will be negative or zero. \$\endgroup\$
    – Dorian
    Oct 21, 2019 at 13:37
1
\$\begingroup\$

Husk, 30 bytes

¢ma¨ÿȦ3ċṀÏ₁ÄẋΩƒ'ŸċḋÄẋḟω≡¢oΔ₅ṁż

Try it online!

The battle of which language has better builtin compression.

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

convey, 69 bytes

}'EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS '

Try it online!

convey outputs strings forever, which is usually annoying but sometimes helpful.

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

BRASCA, 76 bytes

I should add string compression to BRASCA...

1[x` SNAEM SREDOC REWEF SNAEM GNIDOC RETSAF SNAEM NOITACINUMMOC REISAE`[o]1]

Try it online!

Explanation

1[x                                                                       1]  - Infinite loop 
   ` SNAEM SREDOC REWEF SNAEM GNIDOC RETSAF SNAEM NOITACINUMMOC REISAE`       - Push the string
                                                                       [o]    - Output each character
\$\endgroup\$
1
\$\begingroup\$

Braingolf, 77 bytes

"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "[!&@<1+>]
\$\endgroup\$
0
\$\begingroup\$

Tcl, 94 bytes

while 1 {puts -nonewline "EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "}

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Bash 68 bytes

f()(printf "%sER CO%s MEANS " EASI MMUNICATION FAST DING FEW DERS;f)

Try it online

\$\endgroup\$
0
\$\begingroup\$

brainfuck, 657 bytes

+[++++[++++>---<]>++.----.>-[--->+<]>--.----------.----.+++++++++++++.--[----->++<]>.+[->++<]>+.[->+++++<]>.--..++++++++.-------.-----.------.--.>-[--->+<]>-.-----------.++++++.-.++[----->++<]>.++++++[->++<]>+.--------.----.+++++++++++++.+++++.+[--->+<]>++++.+++[->++<]>.-----.>-[--->+<]>--.+.[----->+<]>+.+++++++++++++.--[----->++<]>.+[->++<]>+.[->+++++<]>.-----------.+++++.+++++.-------.+[->++++<]>.++++++[->++<]>+.--------.----.+++++++++++++.+++++.+[--->+<]>++++.+++[->++<]>.-.>+[--->++<]>+.++[----->+<]>.+++++++++++++.--[----->++<]>.+[->++<]>+.[->+++++<]>.-----------.+.+++++++++++++.+.+[--->+<]>++++.++++++[->++<]>+.--------.----.+++++++++++++.+++++.]

Try it online!

\$\endgroup\$
0
\$\begingroup\$

APL NARS, 152 bytes, 76 chars

f
A:⍞←'EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS '⋄→A

I don't know if there are some leak or the buffer for output is buffered in a way increase its size. Possible i see it wrong but it seems that the size mem in NARS increase, and afther some second the output of the line disappear.

\$\endgroup\$
4
  • \$\begingroup\$ You don't need to count the f (or the newline, which you didn't count anyway), by every character is two bytes in NARS, so 75 chars=150 bytes. \$\endgroup\$
    – Adám
    Jan 11, 2018 at 18:45
  • 1
    \$\begingroup\$ Shorter: →≡⍞←'EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS ' \$\endgroup\$
    – Adám
    Jan 11, 2018 at 18:46
  • \$\begingroup\$ →⍞←'EASIER.... Why not this? \$\endgroup\$
    – user58988
    Jan 11, 2018 at 20:38
  • \$\begingroup\$ Because needs a line number to go to. Text is not a line number, but its depth (1) is the number you need. \$\endgroup\$
    – Adám
    Jan 12, 2018 at 8:14
0
\$\begingroup\$

MathGolf, 74 bytes

1{"EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "_q}∟

Try it online!

Explantion:

1                                                                          Loop condition
 {                                                                         Start block
  "EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "_q   Output the string
                                                                        }∟ Do without popping
\$\endgroup\$
5
  • \$\begingroup\$ Mathgolf does have both a compressed string literal command as well as a dictionary lookup, either of which should shorten this somewhat (though I have no experience with them) \$\endgroup\$
    – Jo King
    Oct 13, 2019 at 9:20
  • \$\begingroup\$ None of those methods (compressed string literals (they only support lowercase letters) and dictionary lookups (none of those words are completely upper-case)) can compress capital lettters. In addition, there isn't a built-in in MathGolf that will capitalize a whole string. \$\endgroup\$
    – user85052
    Oct 13, 2019 at 9:22
  • \$\begingroup\$ Huh, that's weird, though you could use (map capitalise) to do so \$\endgroup\$
    – Jo King
    Oct 13, 2019 at 9:45
  • \$\begingroup\$ Huh, this is weird, dictionary compression is actually longer than an uncompressed string. \$\endgroup\$
    – user85052
    Oct 13, 2019 at 9:53
  • \$\begingroup\$ @JoKing Sorry, my compressed string is as long as the program. \$\endgroup\$
    – user85052
    Oct 13, 2019 at 10:25
0
\$\begingroup\$

Batch 116 bytes

@echo off&Set M= MEANS &Set C=ER CO
For /L %%i in ()Do <nul Set/P =EASI%C%MMUNICATION%M%FAST%C%DING%M%FEW%C%DERS%M%

How:

  • For /L %%i in ()Do enacts an infinite loop
  • nul set/p = prints the trailing string without a newline.
\$\endgroup\$
1
2

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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