[Question]
      [
## Challenge
A [repdigit](https://oeis.org/wiki/Repdigit_numbers) is a non-negative integer whose digits are all equal.
Create a function or complete program that takes a single integer as input and outputs a truthy value if the input number is a repdigit in base 10 and falsy value otherwise.
The input is guaranteed to be a *positive* integer.
You may take and use input as a string representation in base 10 with impunity.
## Test cases
These are all repdigits below 1000.
```
1
2
3
4
5
6
7
8
9
11
22
33
44
55
66
77
88
99
111
222
333
444
555
666
777
888
999
```
A larger list can be found [on OEIS](https://oeis.org/A010785).
## Winning
The shortest code in bytes wins. That is not to say that clever answers in verbose languages will not be welcome.

[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 1 byte
```
=
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/3/b/f0NDQwA "Brachylog ‚Äì Try It Online")
This acts on integers.
From [`src/predicates.pl#L1151`](https://github.com/JCumin/Brachylog/blob/master/src/predicates.pl#L1151):
```
brachylog_equal('integer':0, 'integer':0, 'integer':0).
brachylog_equal('integer':0, 'integer':I, 'integer':I) :-
    H #\= 0,
    integer_value('integer':_:[H|T], I),
    brachylog_equal('integer':0, [H|T], [H|T]).
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~33~~ ~~30~~ 29 bytes
```
f(n){n=n%100%11?9/n:f(n/10);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI0@zOs82T9XQwEDV0NDeUj/PCiimb2igaV37PzcxM09Dk6uaizMtv0gjM69EIU/BVsHQGkjZKAB1GABZ2tqaXJycIHMU1NQUCoqAqtI0lFRLY/KUdBTyNK25av8DAA "C (gcc) ‚Äì Try It Online")
[Answer]
# [COBOL](https://en.wikipedia.org/wiki/COBOL), 139 BYTES
I feel like COBOL doesn't get any love in code golfing (probably because there is no way it could win) but here goes:
```
IF A = ALL '1' OR ALL '2' OR ALL '3' OR ALL '4' OR ALL '5' OR
ALL '6' OR ALL '7' OR ALL '8' OR ALL '9' DISPLAY "TRUE" ELSE
DISPLAY "FALSE".
```
A is defined as a PIC 9(4).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 1 byte
```
√ã
```
Checks if all digits are equal
[Try it online!](https://tio.run/##MzBNTDJM/f//cPf//yYmJgA "05AB1E ‚Äì Try It Online")
[Answer]
# Python 3, 25, 24 19 bytes.
```
len({*input()})>1>t
```
A stdin => error code variant.
Returns error code 0 if it's a repdigit - or an error on failure.
Thanks to Dennis for helping me in the comments.
[Answer]
# [Haskell](https://www.haskell.org/), 15 bytes
```
all=<<(==).head
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P802MSfH1sZGw9ZWUy8jNTHlf25iZp6CrUJBUWZeiYKKQm5igUKaQrSSoZKOgpIhmDQ2NgZzjCBiRmAxICf2PwA "Haskell ‚Äì Try It Online") Takes string input.
Equivalent to `\s->all(==head s)s`. Narrowly beats out alternatives:
```
f s=all(==s!!0)s
f s=s==(s!!0<$s)
f(h:t)=all(==h)t
f(h:t)=(h<$t)==t
f s=(s<*s)==(s*>s)
f(h:t)=h:t==t++[h]
```
[Answer]
## Mathematica, 27 bytes
```
AtomQ@Log10[9#/#~Mod~10+1]&
```
It doesn't beat `Equal@@IntegerDigits@#&`, but it beats the other arithmetic-based Mathematica solution.
Repdigits are of the form **n = d (10m-1) / 9** where **m** is the number of digits and **d** is the repeated digit. We can recover **d** from **n** by taking it modulo 10 (because if it's a rep digit, it's last digit will be **d**). So we can just rearrange this as **m = log10(9 n / (n % 10) + 1)** and check whether **m** is an integer.
[Answer]
# [Slashalash](https://esolangs.org/wiki/Slashalash), 110 bytes
```
/11/1//22/2//33/3//44/4//55/5//66/6//77/7//88/8//99/9//1/.//2/.//3/.//4/.//5/.//6/.//7/.//8/.//9/.//T..///.//T
```
[Try it online!](https://tio.run/##HcuxDYAwDAXRjTglThxnDxagQKKgy/4y@TRP19x6r/XcK5NSKFArFcwwaI0GvdPBHYcxGBBBwJxM9nLsSZhoogsXQ4SY4jw2f2R@ "/// ‚Äì Try It Online")
The /// language doesn't have any concept of truthy and falsey, so this outputs "T" if the input is a repdigit, and does not output any characters if the input is not a repdigit.
[Answer]
## C (gcc), 41 bytes
```
f(char*s){s=!s[strspn(s,s+strlen(s)-1)];}
```
This is a function that takes input as a string and returns `1` if it is a repdigit and `0` otherwise.
It does this by making use of the `strspn` function, which takes two strings and returns the length of the longest prefix of the first string consisting of only characters from the second string. Here, the first string is the input, and the second string is the last digit of the input, obtained by passing a pointer to the last character of the input string.
Iff the input is a repdigit, then the result of the call to `strspn` will be `strlen(s)`. Then, indexing into `s` will return a null byte if this is the case (`str[strlen(str)]` is always `\0`) or the first digit that doesn't match the last digit otherwise. Negating this with `!` results in whether `s` represents a repdigit.
[Try it online!](https://tio.run/##TYzBDoIwEETvfMVKYrILJSkHT8iXqIdarTaBQrp4Inx7XQgmzmUmmTdjq5e1KTm0bxMLppnbA194ijwGZMWlxO4pkaqabs2SeuMDEswZiNYRFPePgxZ603WDxRM1W@WGCOjDBF463YidodZaUln6334Vj1Ewh/KiID8@cgV@/1jlHeBWEsFOCnQNf9gC2ZK@ "C (gcc) ‚Äì Try It Online")
Thanks to @Dennis for indirectly reminding me of the assign-instead-of-return trick via his [insanely impressive answer](https://codegolf.stackexchange.com/a/125150/3808), saving 4 bytes!
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~2~~ 1 byte
```
E
```
[Try it online!](https://tio.run/##AVsApP9qZWxsef//Rf/It@G5vuKCrCDDh8OQZiBZIOG4t@KAnCBHZW5lcmF0ZSBbIjEiLCAuLi4sICIxMDAwIl0sIGZpbHRlciBieSB0aGUgY29kZSwgZGlzcGxheS7/ "Jelly ‚Äì Try It Online")
[Answer]
## PHP, ~~25~~ ~~28~~ 25
```
<?=!chop($argn,$argn[0]);
```
remove all chars from the right that are equal to the first and print `1` if all chars were removed.
[Answer]
## R, 31 bytes
```
function(x)grepl("^(.)\\1*$",x)
```
This functions works with string inputs and uses a regular expression to determine whether the input is a repdigit.
### Example
```
> f <- function(x)grepl("^(.)\\1*$",x)
> x <- c("1", "2", "11", "12", "100", "121", "333")
> f(x)
[1]  TRUE  TRUE  TRUE FALSE FALSE FALSE  TRUE
```
[Answer]
## Regex (ECMAScript), 31 bytes
```
^(x{0,9})((x+)\3{8}(?=\3$)\1)*$
```
[Try it online!](https://tio.run/##Tc3NTsJAFEDhV8GGhHspHVowRqkDKxdsWOhSNJmUy/TqMNPMjFD5efaKCxO351ucD7VXofLcxCw0vCG/c/aTvjsvLR16z6Sf2gbgKOfjYfcO7SkfPVwQoE1xPT3dX2Ah19M@rgsc9rvh@Igiupfo2WpAEQxXBHej7BaxPNRsCMBIT2pj2BIg3kj7ZQyetDQiNIYjDLIBlrwFsFILQ1bHGueT85nDSq2AZaN8oKWNoF/zN8Q/oP9g58WimP0yxtq7Q7K0e2V40/PKapr1ktSUW@eh5EdJJacpXodJmwhPDakIjGKnYlWDR6ycDc6QME5fe3np8mwyzfMf)
Takes input in unary, as usual for math regexes (note that the problem is trivial with decimal input: just `^(.)\1*$`).
Explanation:
```
^(x{0,9})           # \1 = candidate digit, N -= \1
(                   # Loop the following:
  (x+)\3{8}(?=\3$)  # N /= 10 (fails and backtracks if N isn‚Äôt a multiple of 10)
  \1                # N -= \1
)* $                # End loop, assert N = 0
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 11 bytes
```
@(s)s==s(1)
```
[Try it online!](https://tio.run/##y08uSSxL/Z9mq6en999Bo1iz2Na2WMNQ83@ahrqhuiYXkDIBAgjLFCpiaGQMROqa/wE "Octave ‚Äì Try It Online")
Takes the input as a string.
It checks all characters for equality with the first characters. If all are equal, the result will be a vector with only `1` (true in Octave), otherwise there will be at least one `0` (false in Octave).
Here's a [proof](https://tio.run/##y08uSSxL/f8/M00h2lABCGN1UjKLCzTUoTyFzGKFkqLSkoxKdU2d1JziVAW4tAFUOi0xpxgsm5fCBTHGAMUYA5KN@f8fAA).
[Answer]
# grep, 17 bytes
```
grep -xP '(.)\1*'
```
Matches any string that's a repetition of its first character.
[Answer]
# APL, 5 bytes
*2 bytes saved thanks to @KritixiLithos*
```
‚çï‚â°1‚åΩ‚çï
```
[Try it online!](http://tryapl.org/?a=f%25u2190%25u2355%25u22611%25u233D%25u2355%20%25u22C4%20f%20445%20%25u22C4%20f%20444%20%25u22C4%20f%20%27445%27%20%25u22C4%20f%20%27444%27&run)
[Answer]
# C#, 42 33  28 bytes
```
i=>i.Replace(i[0]+"","")==""
```
`i` has to be a string.
Shaved down a lot thanks to @LethalCoder
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), 6 bytes
```
iul1-n
```
[Try it online!](https://tio.run/##SypKzMxLz89J@/8/szTHUDfv/38TExNTAA "Braingolf ‚Äì Try It Online")
Unfortunately, Braingolf's implicit input from commandline args can't accept an all-digits input as a string, it will always cast it to a number, so instead the solution is to pass it via STDIN, which adds 1 byte for reading STDIN (`i`)
## Explanation:
```
iul1-n
i       Read from STDIN as string, push each codepoint to stack
 u      Remove duplicates from stack
  l     Push length of stack
   1-   Subtract 1
     n  Boolean negate, replace each item on stack with 1 if it is a python falsey value
        replace each item on stack with 0 if it is a python truthy value
        Implicit output of last item on stack
```
After `u`, the length of the stack equals the number of unique characters in the input, subtracting 1 means it will be `0` if and only if there is exactly 1 unique character in the input, `0` is the only falsey number in Python, so `n` will replace `0` with `1`, and everything else with `0`.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 4 bytes
```
¬•√ßUg
```
[Try it online!](https://tio.run/##y0osKPn//9DSw8tD0///VzIxMVH6DwA "Japt ‚Äì Try It Online")
[Answer]
## JavaScript (ES6), ~~23~~ 21 bytes
*Saved 2 bytes thanks to Neil*
Takes input as either an integer or a string. Returns a boolean.
```
n=>/^(.)\1*$/.test(n)
```
### Demo
```
let f =
n=>/^(.)\1*$/.test(n)
console.log(f(444))
console.log(f(12))
```
[Answer]
# [Ohm](https://github.com/MiningPotatoes/Ohm), 4 bytes
```
Ul2<
```
[Try it online!](https://tio.run/##y8/I/f8/NMfI5v9/ExNjAA "Ohm ‚Äì Try It Online")
### Explanation
```
 Ul2<
 U    # Push uniquified input
  l   # Length
   2< # Is it smaller than 2?
```
[Answer]
# Java, ~~38~~ ~~33~~ 23 bytes
```
n->n.matches("(.)\\1*")
```
`n` is a `String`, naturally.
Note that there is no need for `^...$` in the regex since it's automatically used for exact matching (such as the `match` method), compared to finding in the string.
[Try it!](http://ideone.com/KxyRJ9)
## Saves
* -5 bytes: used `String` since "You may take and use input as a string with impunity."
* -10 bytes: regex is apparently a good fit.
[Answer]
# Java, 21 bytes:
```
l->l.toSet().size()<2
```
`l` is a `MutableList<Character>` from eclipse collections.
[Answer]
# [Kotlin](https://kotlinlang.org), ~~28~~ 19 bytes
```
{it.toSet().size<2}
```
[Try it online!](https://tio.run/##JYyxDoIwFEV3vuKGqW@QWMcGMDi78QVNbEljeTWlmCjh22vVs95zzz0k7zg/tYdVEGOKjifCocclBG80o8ubS00Ko0mCmsW9TXvas10Zs3YsdJwWhSFG/Wr/756wVSh8o7zO6BCNvl0dG0E4K9TH@rc/ip2EFcUhqvYspfwA "Kotlin ‚Äì Try It Online")
Takes input as a `String` because
>
> You may take and use input as a string representation in base 10 with impunity.
>
>
>
## Explanation
```
{
    it.toSet()     // create a Set (collection with only unique entries)
                   // out of the characters of this string
        .size < 2  // not a repdigit if the set only has one entry
}
```
If you don't like the fact it takes a `String`, you can have one that takes an `Int` for **24 bytes**.
```
{(""+it).toSet().size<2}
```
[Answer]
# PHP, 30 bytes
```
<?=($a=$argn).$a[0]==$a[0].$a;
```
[Answer]
# [Neim](https://github.com/okx-code/Neim), 1 byte
```
ùêê
```
Simply checks that all elements are equal.
Without builtin, 2 bytes:
```
ùêÆùê•
```
Explanation:
```
ùêÆ     Calculate unique digits
 ùê•    Get the length
```
This works because only `1` is considered truthy in Neim, and everything else is falsy.
Alternatively, for 4 bytes:
```
ùêÆùê£ŒºùïÉ
```
Explanation:
```
ùêÆ      Calculate unique digits
 ùê£      Join list into an integer
   ùïÉ   Check that is is less than
  Œº    Ten.
```
[Try it!](http://178.62.56.56:80/neim?code=%F0%9D%90%90&input=12)
[Answer]
# C, 38 bytes
```
f(char*s){return*s^s[1]?!s[1]:f(s+1);}
```
Recursively walks a string. If the first two characters differ (`*s^s[1]`) then we succeed only if we're at the end of the string (`!s[1]`) otherwise we repeat the test at the next position (`f(s+1)`).
## Test program
```
#include <stdio.h>
int main(int argc, char **argv)
{
    while (*++argv)
        printf("%s: %s\n", *argv, f(*argv)?"yes":"no");
}
```
[Answer]
# R, 25 bytes
```
grepl("^(.)\\1*$",scan())
```
[Try it online](https://tio.run/##K/r/P70otSBHQylOQ08zJsZQS0VJpzg5MU9DU/O/paUllwmXhSGXpYW5mfF/AA)
Best non-regex solution I could come up with was 36 bytes:
```
is.na(unique(el(strsplit(x,"")))[2])
```
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), 15 bytes
```
uOn@ii?-?;.$@<_
```
[Try it online!](https://tio.run/##Sy5Nyqz4/7/UP88hM9Ne195aT8XBJv7/f1MQAAA "Cubix ‚Äì Try It Online")
```
    u O
    n @
i i ? - ? ; . $
@ < _ . . . . .
    . .
    . .
```
[Watch It Run](https://ethproductions.github.io/cubix/?code=ICAgIHUgTwogICAgbiBACmkgaSA/IC0gPyA7IC4gJApAIDwgXyAuIC4gLiAuIC4KICAgIC4gLgogICAgLiAuCg==&input=MjIzMjI=&speed=20)
Outputs 1 for truthy and nothing for falsey
Very simply read reads in the input one character at a time. It takes the current character away from the previous. If a non zero result then it halts immediately. Otherwise it continues inputting and comparing until the EOI. On EOI (-1), negate and exit
[Answer]
# QBasic 4.5, 55 bytes
```
INPUT a
FOR x=1TO LEN(STR$(a))
c=c*10+1
NEXT
?a MOD c=0
```
I've mathed it! The FOR-loop checks the number of digits in the input, then creates `c`, which is a series of 1's of length equal to the input. A number then is repdigit if it modulo the one-string == 0.
[Try it online!](https://repl.it/IcSt/0) Note that the online interpreter is a bit quirky and I had to write out a couple of statements that the DOS-based QBasic IDE would expand automatically.
]


[Question]
      [
In this challenge, you should write a program or function which takes no input and prints or returns a string with the same number of bytes as the program itself. There are a few rules:
* You may only output bytes in the printable ASCII range (0x20 to 0x7E, inclusive), or newlines (0x0A or 0x0D).
* Your code must not be a quine, so the code and the output must differ in at least one byte.
* Your code must be at least one byte long.
* If your output contains trailing newlines, those are part of the byte count.
* If your code requires non-standard command-line flags, count them as usual (i.e. by adding the difference to a standard invocation of your language's implementation to the byte count), and the output's length must match your solution's score. E.g. if your program is `ab` and requires the non-standard flag `-n` (we'll assume it can't be combined with standard flags, so it's 3 bytes), you should output 5 bytes in total.
* The output doesn't always have to be the same, as long as you can show that every possible output satisfies the above requirements.
* Usual quine rules *don't* apply. You may read the source code or its size, but I doubt this will be shorter than hardcoding it in most languages.
You may write a [program or a function](https://codegolf.meta.stackexchange.com/q/2419) and use any of the [standard methods](https://codegolf.meta.stackexchange.com/q/2447) of providing output. Note that if you print the result, you may choose to print it either to the standard output or the standard error stream, but only one of them counts.
You may use any [programming language](https://codegolf.meta.stackexchange.com/q/2028), but note that [these loopholes](https://codegolf.meta.stackexchange.com/q/1061/) are forbidden by default.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest valid answer – measured in *bytes* – wins.
### Leaderboard
```
var QUESTION_ID=121056,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){var F=function(a){return a.lang.replace(/<\/?a.*?>/g,"").toLowerCase()},el=F(e),sl=F(s);return el>sl?1:el<sl?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>
```

[Answer]
# [><>](https://esolangs.org/wiki/Fish), 3 bytes
```
"nh
```
[Try It Online](https://tio.run/##S8sszvj/XykPSAAA)
Prints "104" and exits with an error.
[Answer]
# [Dash](https://wiki.debian.org/Shell)/[Bash](https://www.gnu.org/software/bash/)/[ksh](http://www.kornshell.com/)/[fish](https://fishshell.com/), 5 bytes
```
umask
```
[Try it online (Dash)](https://tio.run/##HcpBCoAgEEbhvaf4V1kLNy0jukJnkGlEiFR0JILubtju8fEOW3wbW71sOduEF8IMp@RJjB@xDbNi8rEHTIDeq6QqIG@zJeEMijXIAq1ugiGscP1tHw "Dash – Try It Online") |
[Try it online (Bash)](https://tio.run/##HcpBCoAgEEbhvaf4V1kLNy0jukJnsGFEiFR0JILubtju8fEOW3wbW71sOduEF8IMp@RJjB@xDbNi8rEHTIDeq6QqIG@zJeEMijXIAq1ugiGscP1tHw "Bash – Try It Online") |
[Try it online (Ksh)](https://tio.run/##HcpBCoAgEEbhvaf4V1kLNy0jukJnkGFEkFR0JILubtju8fFC9X3u7bI19AUvhBlOyZMZP@KYVsXk0wiYCH02yU1A3hZLwgWUWpQNWt0EQ9jhxts/ "ksh – Try It Online") |
[Try it online (Fish)](https://tio.run/##Hco7CoAwEEXRPqt4lVYptBRxC64hjBNG/GImiKhrj5/ucri@D2KD8DimM8XJhSHduKDM8EaPlfHjS8Kug50LNFlpmGT54gXkbdQ1Kkjc5kh5Ay1x1gq52QmWUMN/b3oA "fish – Try It Online")
`umask` is a **builtin** in most unix shells, *not* an external command! It prints the 4-octal-digit umask followed by a newline for a total of 5 bytes.
Does not work in Zsh or Tcsh: Zsh will only print one leading zero (e.g.: `02` instead of `0002`), and Tcsh will print no leading zeroes (`2` instead of `0002`)
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 14 bytes
```
_=>new[]{1}+""
```
Found interesting way to shave some bytes. Outputs: `System.Int32[]`
[Try it online!](https://tio.run/##Sy7WTS7O/O9Wmpdsk5lXoqNQXFKUmZdup5AGFFGw/R9va5eXWh4dW21Yq62k9N@aiyu8KLMk1SczL1UDpETDQFPPJzUvvSRD0xpJSglZX4xSjJISXNV/AA "C# (Visual C# Interactive Compiler) – Try It Online")
First way:
23 bytes
```
()=>new string('@',23);
```
Creates a new string consisting of 23 `@` characters
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), ~~19~~ 16 bytes
```
END{print 69**8}
```
[Try it online!](https://tio.run/##SyzP/v/f1c@luqAoM69EwcxSS8ui9v9/AA "AWK – Try It Online")
*Thanks to Jo King for the pointer that cut 3 chars...*
AWK is a bit of a pain for this one since the minimum code required to run without any input and print something is `END{print }`. So this one just prints a number that's enough digits to match the program size less one, since the `print` adds a linefeed. The output is `513798374428641\n`.
[Answer]
# [Python 3](https://www.python.org/), ~~13~~ 12 bytes
```
print(2**-9)
```
[Try it here!](https://tio.run/##K6gsycjPM/7/v6AoM69Ew0hLS9dS8/9/AA)
**Output:**
```
0.001953125
```
---
**Old:**
```
print([1]*4);
```
[Try it here!](https://tio.run/##K6gsycjPM/7/v6AoM69EI9owVstE0/r/fwA)
**Output:**
```
[1, 1, 1, 1]
```
-1 Thanks to aeh5040! With this, the unneeded semi-colon could be removed as the output is 11 bytes + white space
~~A list printed in python would have the length of 2 + 3 for each extra element plus the new-line, thus with [1](https://www.python.org/)\*n we can have any multiple of 2+3n. A semi-colon is added because unfortunately print adds a new-line character, and I've yet to find a better solution~~
[Answer]
# [Desmos](https://desmos.com/calculator), 2 bytes
```
4!
```
Outputs
```
24
```
[Answer]
## Powershell, 3 bytes
```
1E2
```
Prints `100`
[Answer]
# PHP, ~~216~~ ~~68~~ 7 bytes
```
<?=1e6;
```
[Try it online!](https://tio.run/nexus/php#@29jb2uYamb9/z8A "PHP – TIO Nexus")
Thanks to [Jörg](https://codegolf.stackexchange.com/users/59107/j%C3%B6rg-h%C3%BClsermann) I'm beating [Okx](https://codegolf.stackexchange.com/users/26600/okx) again :D
[Answer]
# [TAESGL](https://github.com/tomdevs/taesgl), 1 byte
```
S
```
[**Interpreter**](https://tomdevs.github.io/TAESGL/v/1.2.1/index.html?code=Uw==)
Outputs a single space character
**Other solutions**
```
"≠        2 bytes, "≠" converted to "!="
«Ā»       3 bytes, decompresses "Ā" which is equal to "the"
SŔ4)      4 bytes, " " repeated 4 times
5ē)ĴT     5 bytes, first 5 Fibonacci numbers joined
G→6,"A    6 bytes, draws a line to the right of "A" for 6 characters
```
[Answer]
## [Stack Cats](https://github.com/m-ender/stackcats), 1 + 3 = 4 bytes
```
+
```
[Try it online!](https://tio.run/nexus/stackcats#@6/9//9/3XwA "Stack Cats – TIO Nexus")
Requires either the `-o` or `-n` flag for numeric output. Prints two zeros, with a linefeed each.
### Explanation
Stack Cats has a tape of stacks which are all initialised to an infinite wells of zeros, but the starting stack has a `-1` on top (which acts as a terminator when input is given). The `+` command swaps the first and third element on the current stack. So:
```
-1           0
 0           0
 0     +    -1
 0   ---->   0
 .           .
 .           .
 .           .
```
At the end of the program, the current stack is printed from top to bottom. Since the `-1` is again treated as a terminator, it's not printed itself. Due to the `-o` flag, the values are printed as decimal integers with trailing linefeeds.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 7 bytes
```
[['']]'
```
[Try it online!](https://tio.run/nexus/octave#@x8dra4eG6v@/z8A "Octave – TIO Nexus")
[Answer]
# TI-Basic (TI-84 Plus CE OS 5.2+), 4 bytes
```
toString(10^(3
```
`tostring(` is a two-byte token, `10^(` is a one-byte token. This returns the string "1000" which is 4 bytes long.
[Answer]
## [Fission](https://github.com/C0deH4cker/Fission), 4 bytes
```
R"N;
```
[Try it online!](https://tio.run/nexus/fission2#@x@k5Gf9/z8A "Fission 2 – TIO Nexus")
Prints `N;R` with a trailing linefeed.
The `R` creates a right-going atom. `"` toggles string mode which traverses an immediately prints `N;R` (wrapping at the end of the line). Then `N` prints a linefeed and `;` destroys the atom, terminating the program.
[Answer]
# [Somme](https://github.com/ConorOBrien-Foxx/Somme), 2 bytes
```
:.
```
[Try it online!](https://tio.run/nexus/somme#@2@l9/8/AA "Somme – TIO Nexus")
Outputs `42`. Explanation:
```
:.
:    duplicate; no input, so popping from an empty stack pushes `42`
 .   output as a number
```
[Answer]
# [OCaml](https://ocaml.org/), 22 bytes
```
List.find ((=) "") []
```
Outputs
```
Exception: Not_found.
```
It search for `""` (empty string) in the empty list `[]`
[Answer]
# Ruby, 3 bytes
```
p""
```
Prints this, plus a newline
```
""
```
Here's another 3 byte one:
```
p:a
```
Prints this, plus a newline
```
:a
```
[Answer]
# R, 7 bytes
`stop( )`
Prints `Error:` (with a trailing space)
---
16 bytes (only works in version 3.3.1)
`version$nickname`
Prints `Bug in Your Hair`.
Not nearly as good but I like it anyway.
[Answer]
# charcoal, 1
```
⎚
```
[Try it online!](https://tio.run/nexus/charcoal#@/@ob9b//wA "Charcoal – TIO Nexus")
## Explanation:
```
⎚ Clears the empty screen
[implicitly print nothing plus a trailing newline]
```
[Answer]
## Mathematica, 2 bytes
Code:
```
.0
```
Output:
```
0.
```
This is the output of Wolfram kernel from command line, and the plaintext output from the front end. If you must argue about the extra number tick added when copying directly from the front end, then `0.0` will do.
[Answer]
## [><>](https://esolangs.org/wiki/Fish), 11 bytes
```
01+:b=?;:n!
```
Prints numbers from 1-10 (12345678910)
[Answer]
# [Whitespace](https://web.archive.org/web/20150618184706/http://compsoc.dur.ac.uk/whitespace/tutorial.php), 36 bytes
```

```
[Try it online!](https://tio.run/nexus/whitespace#FYmxDQAADIJmvYL/n7RUDQMOQkwLtXEo@3zjtR0 "Whitespace – TIO Nexus")
Generates the output "-15-14-13-12-11-10-9-8-7-6-5-4-3-2-1" (36 characters without quotes, no trailing newline)
# Explanation
Pushes the number -15 onto the stack (encoded in binary as 01111, with a leading 0 for padding to match the output) then counts toward 0 outputting the current number each iteration.
Starting from a negative number gives an extra byte of output per iteration and also allows me to use a jump while negative instruction to fall through the loop and exit implicitly. That single padding byte in the code is a downer though but solutions without it are longer.
[Answer]
## **Python 3, 13 bytes**
```
print("a"*13)
```
Outputs "aaaaaaaaaaaaa"
[Answer]
# [C#](https://visualstudio.microsoft.com/), 84 bytes
```
public class P{public static void Main(){System.Console.Write(new string('_',84));}}
```
[Try Online](https://dotnetfiddle.net/jgigU2)
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 6 bytes
```
(arch)
```
[Try it online!](https://tio.run/##S0oszvj/XyOxKDlD8/9/AA "Bash – Try It Online")
The architecture needs to be `x86_64`
[Answer]
# [Klein](https://github.com/Wheatwizard/Klein) 110, ~~7~~ 5 bytes
*Thanks to Martin Ender for saving two bytes!*
```
1.
2@
```
[Try it online!](https://tio.run/##y85Jzcz7/99Qj8vI4T@QNjQAAA "Klein – Try It Online")
If we unfold the topology here we get
```
1.122@
```
This outputs `1 1 2 2` with a trailing newline.
[Answer]
# Lean Mean Bean Machine, 28 bytes
```
 /O
)O4
?7/
 *
_~
 o
~ :
  u
```
[Try it Online!](https://tio.run/##xVltb9s2EP6uX8G9ZJIS2YnRAQO8esWwJRiwDSm6bF9UzVMsOmYriwIlOxYw9K9ndyT1QklMXTTIWqAVyePdc@8knVflhmcvHtaCb0lRFYRtcy5KEou7vaO/RZwlfFuPst02r@oBL6Z5XG4cZ5XGRUFyzrKSirlD4E9C12S5ZBkrl0uvoOk6ICvORVIEhCW@osE/@1zALs/9SdC4ZNldzYWcFCQu9R4SnsC@kyJyyQnxWFLzCmdR83kR@X7DFQVOD2TR0plLVbt00Vs67GkKqxe9DWp2Zs6yBOZYYk7GKdtTmL8RO2qubGiKG67itOit7ON0R4dSi5xlI7OlQEN1GSlrC5oLbe2OhQUtdyIjsMsLQ6VioJUC64WN0kGraRT5joM8WbGU6njaK8uUFaXmfct5WgCKkGmV11wQRgBxl1hZt/byj0g4B0@iIyUD5TONMc4qT89K8WuWJUu02lKzLAwgAQFNKg1HswjZOA7CQBsMiQU5gJwEBhUOKj2QvlGfUptIIdjyPR0XrsXepfw2Tsk2PvxGMznTiIfMuaPeRUBSmplbO97JwYLdtZC18QiQcwUMWGa8hFGsDLjiGSRLJ75yUO1sgf@B@zqzlZqturO1M37nezPh5k2eBSSj97ACFaGXfPkU0y/XEaM4y7EcdFJQgj@QHxbaNqgDTrwkF@qzwjU0zYon1K/nYLk1Thft67YubOKiXxgC8p6lKahjguyDUkapM1Tlj/TzBlyf0iXPqYhLLmTQ9WJNj7TvjKgEXh8NVT2SmPRn5RvJQcgV30EEoobo9JoRqoR2MrhrpcDKGBjG0rC4EvILT5OOs93WJDUYXZyMqqVzqq0zFD4GlcUQ3tQNFFxoY5WianephT6TRi49rGhekr@wIl4KwcV8HI6UoxXkt@/MdNxTccs1ZjCRHs6JIsdSiFt0lRG77NEU/18SerWJhWxSCQ0hhiP45xA5jyQFU/0St6ny6rFADlFNA4DqH@NZRsgftDT6cMk1P8g3T/Mz06luXg1Bb32kX6lYYk2gyG1zC9@GwNyqLLQg7p@uTZdfVU1odMH6LhdxUrHHUgKM3MdrhLEmFCDhaYh@QGiWLFzXBnD3GQA/GZgG9TFM51ZMvbaQ0nU5AHEgk@5hSPu5f1oxJb59e6xIwe42YzLPrDJnFpn/WkW@oeuUroxIT5jAGZ71RKukAUEmL6slLNYY1s9HdTtKv73bT5rB8dXcwK0GaQ7g2Pm3sbhN@7EHC7LetAXOw9IUKCsQb9ZaSipKJjM/GiuWo1wbg/W5XIyT19VBx7tpho64aZznkApevfGTfDvwit2BE7uXvrQa/RJhotF1jdxCuXet9dPozaaIL6wiXh9V7z65pn19pMBRQUfWqL97MsCFPzPsiupOOl1tOFtRL4SOPIv8UThvJCVeW28hw6FHql6mOPnjxUQtjlUfDQAPXepLh7kF/6sefhlsUvNhCHXsp8uR8peEHJD7DVttcFCKXbmBnEOsGVpZFsspKlW77pgyYo/lY4Gssf90gWCjOBKHrTotxww2np1DmJI3AJMGCfDm1pjH9T8nu@2iUOVG0kijPKI2fLDm0Y2ItzmH40HvNFbyfFAi8D3DGobMKuKKlqsNsmdZvuuDNw7t7eE9lycyIPeGuuKBLsuHu@o1ddgDEn@cZnjuQ9pR0nFXjR9KgQk@D5muVteMy@ur3iVjyKLfYUzrnvWsq@9Rx1woB60IiexIIFyRAFQZaXm1aFwdPyKasE@fDfbpU8KePBvsyVPC/ubZYJ8/Jeyvng32og2X0ydU4OTZFDg53u67j8L@x1KxbzaC32O9plizevVaxAwOI5eyrsElxnNlYZNM45X55mNK@35wiTjGtJ47fl8/s/c637LlkfY4d22vAupg4DhAjTcM/MnCxy0v1Ab95AOEcimczCJVQPZgh7Z5tGT6VQkfXGDkuu4DOb92/OtvnVffnTvk1Fl@cAh3PhDcuHsAgoa4@@aMU4AsZSV0blp4fuTo90/12AkD@eAZkPe0WsAMXIfGH5jks6hulFpJ@RrEIp@81I@qrXH0Eprfhb@nxNNiJ8ZO39GxJLnXCshfdaaxEHHlhSGc79YycBDSu0gO3tW6RT0OHA5YLCtaJoVio0b3Gyqop6QAsGvX96c3NQO91Xc6z6hhZLFGTawNUm@pb3f1hVSTgaoBYa22zaup48ABNqWDHzbql8rR9/76R4qRd0LkqJPT9R/@Aw)
Outputs 27 `1`s followed by a trailing newline.
Unfortunately I had to fix a bug in LMBM with the `o` peg for this answer to work. The link above links to the entire LMBM interpreter, with the fix, contained in TIO's header/footer, with the LMBM code in the code section.
## Explanation
The code is a loop. Here's the setup:
```
 /O
 O4
 7/
 *
 ~
```
This creates 2 marbles, sets one to 4 and the other to 7, then multiplies them into a single marble with a value of 28. Finally the `~` pushes the marble up to the top of that column, where the top `/` pushes it into the loop.
```
)
?
_
 o
~ :
  u
```
This is the loop. `?` is a conditional that sets the marble's spin to right if its value is truthy (non-zero), and 0 otherwise.
`)` decrements the marble's value. We do this *before* the conditional to account for LMBM's trailing newline.
`_` pushes the marble in the direction of its spin. This is the exit condition for the loop. If the marble's value was not truthy, ie 0, this pushes the marble to the left, out of bounds. Out of bounds marbles are automatically destroyed. When all marbles are destroyed, the program terminates.
`o` is a split. It splits the marble, pushing one copy left and the other right.
The left marble hits ~, which pushes it back up to the top of the loop.
The right marble hits `:`, which sets its value to its spin (1 for right, 0 for left), then it falls into `u`, which prints the marble's value and destroys it.
[Answer]
# [`experimental-type-lang`](https://github.com/Merlin04/experimental-type-lang) (63 bytes)
Here's a solution in a weird (and not very good) language I made:
```
type R<E,C>=C extends63?E:R<[...E,32],[...C,_]>;[51224,R<[],0>]
```
Output:
```
0> "                                                               "
```
I'm not counting the `0>`  output prefix and quotes as part of the program output in this case (the quotes appear whenever the output is a string, and the output prefix is added for every evaluated expression), but if I wanted to count that I could just adjust the value `63` to be the desired output string length.
### Explanation
Here's an expanded version:
```
type Loop<Result = [], Counter = 0> = Counter extends 63
    ? Result
    : Loop<[...Result, 32], [...Counter, _]>;
// The evaluated expression
[51224, Loop<>];
```
In this language, strings are arrays where the first item is a magic number indicating to the evaluator that it should be displayed as a string, and the second item is an array of character codes. The `Loop` function (called a `type` because I wanted to make the syntax resemble the TypeScript type system) is responsible for generating this array of characters. It does this by recursively calling itself, adding `32` (the code for a space) to a result array with the spread operator, until a counter reaches the desired output length. In `experimental-type-lang`, numbers are just arrays of "items" (represented by a `_`) with the length being the numerical value; because there is no language-level add operator and importing the `Add` type from the standard library would take too many characters, I increment the counter by spreading it into an array and adding an `_`.
[Answer]
# Cjam, 1 byte
```
N
```
## Explanation
```
N e#Push '\n' and implicit print
```
[Answer]
# [J](http://jsoftware.com/), 6 bytes
```
echo!4
```
[Try it online!](https://tio.run/nexus/j#@5@anJGvaPL/PwA "J – TIO Nexus")
Output:
```
24

```
Notice the three spaces on the second line.
[Answer]
## JavaScript (ES6), 17 bytes
*Edit: I overlooked the rules. This is now returning a string, but is much longer than initially intended.*
Returns `"Infinity,Infinity"`.
```
let f =
_=>`${[1/0,1/0]}`
console.log(f())
```
]


[Question]
      [
My father who [was a really good APLer](https://youtu.be/pL8OQIR5cB4?t=3m16s) 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](http://www.dyalog.com/50-years-of-apl.htm), I found [this patent letter](https://tidsskrift.dk/plugins/generic/pdfJsViewer/pdf.js/web/viewer.html?file=https%3A%2F%2Ftidsskrift.dk%2Fregistreringstidende-varemaerker%2Farticle%2Fdownload%2F95152%2F143241%2F#page=8) (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 …](https://i.stack.imgur.com/pEzT8.png)](https://i.stack.imgur.com/pEzT8.png)
**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`.

[Answer]
## 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>
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 25 bytes
```
[‘Ã¦ƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂïˆ¾ ‘?
```
[Try it online!](https://tio.run/nexus/05ab1e#@x/9qGHG4eZDy45NOtwdFHy67dC@Q0uPTTq693AjmL3w6I7DTYfXg9gKQJX2//8DAA "05AB1E – TIO Nexus")
Explanation:
```
[‘Ã¦ƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂïˆ¾ ‘?
[                         Start infinite loop
 ‘Ã¦ƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂïˆ¾ ‘   Push the compressed string in uppercase, starting from FEWER, with a trailing space
                        ?  Print without trailing newline
```
[Answer]
# PHP, 76 Bytes
```
for(;;)echo strtr(EASI0MMUNICATION1FAST0DING1FEW0DERS1,["ER CO"," MEANS "]);
```
[Try it online!](https://tio.run/nexus/php#s7EvyCjgSi0qyi@KL0otyC8qycxL16hzjffzD/F0dtW0/p@WX6Rhba2ZmpyRr1BcUlRSpOHqGOxp4Osb6ufp7Bji6e9n6OYYHGLg4unnbujmGm7g4hoUbKgTreQapODsr6SjpODr6ugXrKAUCzTsPwA "PHP – TIO Nexus")
[Answer]
# Vim 69 bytes
```
qqAFEWER CODERS MEANS EASIER COMMUNICATION M<C-n> FASTER CODING M<C-n> <esc>@qq@q
```
[Answer]
## 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>
```
[Answer]
# [Python 2](https://docs.python.org/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!](https://tio.run/nexus/python2#@1@ekZmTqmBoVVCUmVei7uYa7hqk4Ozv4hoUrODr6ugXrODqGOwJFvP1DfXzdHYM8fT3g0q5OQaHQJR7@rlDxNR1/v//mpevm5yYnJEKAA "Python 2 – TIO Nexus")
## 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!](https://tio.run/nexus/python2#@1@ekZmTqmBoVVCUmVeirlrsGqTg7K9arODr6ugXrK5lrKqh7uYarq6j7uIaFAykFFwdgz2BtK9vqJ@ns2OIp78fSNTNMTgEpMjTz11dU@f/fwA "Python 2 – TIO Nexus")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~33~~ 29 bytes
4 bytes thanks to Erik the Outgolfer.
```
“©%5ÐƬwȮh¬Þ6.⁷ḷḊḥṫɠlḶṀġß»Œu⁶¢
```
[Try it online!](https://tio.run/nexus/jelly#AT4Awf//4oCcwqklNcOQxqx3yK5owqzDnjYu4oG34bi34biK4bil4bmryaBs4bi24bmAxKHDn8K7xZJ14oG2wqL//w "Jelly – TIO Nexus")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 70 bytes
```
"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "w↰
```
[Try it online!](https://tio.run/nexus/brachylog2#@6/k5hruGqTg7O/iGhSs4Ovq6Bes4OoY7AkW8/UN9fN0dgzx9PeDSrk5BodAlHv6uUPFlMoftW34/x8A "Brachylog – TIO Nexus")
## How it works
```
"..."w↰
"..."     generate the string "..."
     w    print to STDOUT without trailing newline
      ↰   do the whole thing all over again
```
[Answer]
# 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
[Answer]
# [Python 3](https://docs.python.org/3/), 87 bytes
```
while 1:print(end="FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ")
```
[Try it online!](https://tio.run/nexus/python3#@1@ekZmTqmBoVVCUmVeikZqXYqvk5hruGqTg7O/iGhSs4Ovq6Bes4OoY7AkW8/UN9fN0dgzx9PeDSrk5BodAlHv6uUPFlDT//wcA "Python 3 – TIO Nexus")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 92 bytes
```
main(){for(;printf("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "););}
```
[Try it online!](https://tio.run/nexus/c-gcc#@5@bmJmnoVmdll@kYV1QlJlXkqah5OYa7hqk4Ozv4hoUrODr6ugXrODqGOwJFvP1DfXzdHYM8fT3g0q5OQaHQJR7@rlDxZQ0rTWta///BwA "C (gcc) – TIO Nexus")
[Answer]
# [LOLCODE](http://lolcode.org/), 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!](https://tio.run/nexus/lolcode#LYzLDYAwDMXunSKwASMECPAETaUmfLr/IEV8rrblujCoC4gEpZIphQOGfhNqJzkl05BGyUZRWI2EDS@LcVcM7Ej6q4nNvxw6/6xtnnHa3fl7r75cfZFabw "LOLCODE – TIO Nexus")
[Answer]
# Ruby, 77 bytes
assigning `" MEANS "` to a variable saved all of 1 byte :-)
```
loop{$><<"EASIER COMMUNICATION#{m=" MEANS "}FASTER CODING#{m}FEWER CODERS"+m}
```
[Answer]
# 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)
```
[Answer]
# [Befunge](https://github.com/catseye/Befunge-93), 73 bytes
```
" SNAEM GNIDOC RETSAF SNAEM NOITACINUMMOC REISAE SNAEM SREDOC REWEF">:#,_
```
[Try it online!](https://tio.run/nexus/befunge#@6@kEOzn6Oqr4O7n6eLvrBDkGhLs6AYV8/P3DHF09vQL9fUFS3kGO7pCpYKDXCHKw13dlOyslHXi//8HAA "Befunge – TIO Nexus")
[Answer]
# 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 :)
[Answer]
## [Alice](https://github.com/m-ender/alice), 70 bytes
```
" SNAEM "k"SREDOC REWEF"e0j"GNIDOC RETSAF"e0j"NOITACINUMMOC REISAE"d&o
```
[Try it online!](https://tio.run/nexus/alice#@6@kEOzn6OqroJStFBzk6uLvrBDkGu7qppRqkKXk7ucJEQgJdoSI@Pl7hjg6e/qF@vqCJTyDHV2VUtTy//8HAA "Alice – TIO Nexus")
### 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.
```
[Answer]
## C#, 102 bytes
```
_=>{for(;;)System.Console.Write("EASIER COMMUNICATION{0}FASTER CODING{0}FEWER CODERS{0}"," MEANS ");};
```
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 85 bytes
```
BEGIN{for(c=" MEANS ";;)printf"EASIER COMMUNICATION"c"FASTER CODING"c"FEWER CODERS"c}
```
[Try it online!](https://tio.run/nexus/awk#@@/k6u7pV52WX6SRbKuk4Ovq6BesoGRtrVlQlJlXkqbk6hjs6Rqk4Ozv6xvq5@nsGOLp76eUrOTmGBwCFnbx9HMH8V3DIVzXoGCl5Nr//wE "AWK – TIO Nexus")
Apparently I came up with the same shortcut as others. All other substitutions take up too much space. :(
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~64~~ 60 bytes
```
+>(`$
EASI_MMUNICATION@FAST_DING@FEW_DERS@
@
 MEANS
_
ER CO
```
[Try it online!](https://tio.run/##K0otycxLNPz/X9tOI0GFy9Ux2DPe1zfUz9PZMcTT38/BzTE4JN7F08/dwc01PN7FNSjYgcuBS8HX1dEvWIErnss1SMHZ//9/AA "Retina – Try It Online")
### Explanation
The program consists of three grouped replacement stages. The group as a whole is applied repeatedly until the output stops changing (which it never will) and the output is printed after each time (rather than just at the end, because there will be no end)
The first stage adds the string `EASI_MMUNICATION@FAST_DING@FEW_DERS@` at the end of the input. The input starts out empty, but keeps growing.
The second stage replaces each of those `@`s with the string `MEANS` (surrounded by a space on each side).
The third stage replaces the `_`s with the string `ER CO`.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 69 bytes
```
Wp"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS
```
[Try it online!](https://tio.run/nexus/pyth#@x9eoOTmGu4apODs7@IaFKzg6@roF6zg6hjsCRbz9Q3183R2DPH094NKuTkGh0CUe/q5Q8X@/wcA "Pyth – TIO Nexus")
## How it works
```
Wp"...
W       while the following is true: (do nothing)
 p      print the following and return the following
  "...
```
[Answer]
# [Lua](https://www.lua.org), 92 bytes
```
while 1 do io.write("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ")end
```
[Try it online!](https://tio.run/nexus/lua#@1@ekZmTqmCokJKvkJmvV16UWZKqoeTmGu4apODs7@IaFKzg6@roF6zg6hjsCRbz9Q3183R2DPH094NKuTkGh0CUe/q5Q8WUNFPzUv7/BwA "Lua – TIO Nexus")
[Answer]
# [Java (OpenJDK 9)](http://openjdk.java.net/projects/jdk9/), 114 bytes
```
static void f(){while(1>0)System.out.print("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ");}
```
[Try it online!](https://tio.run/nexus/java-openjdk9#S85JLC5W8E3MzFOo5lIAgoLSpJzMZIXiksQSIFWWn5mikAuU1QguKcrMS4@OVUgsSi/WhCoGgTQNTWswp/Y/siagcHV5RmZOqoahnYFmcGVxSWquXn5piV4B0JwSDSU313DXIAVnfxfXoGAFX1dHv2AFV8dgT7CYr2@on6ezY4invx9Uys0xOASi3NPPHSqmpGld@5@r9v/XvHzd5MTkjFQA "Java (OpenJDK 9) – TIO Nexus") Stop the execution after a few seconds because it does not know when to stop.
[Answer]
## C, 86 bytes
```
f(){printf("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ");f();}
```
See it [work online](https://tio.run/nexus/c-gcc#@5@moVldUJSZV5KmoeTmGu4apODs7@IaFKzg6@roF6zg6hjsCRbz9Q3183R2DPH094NKuTkGh0CUe/q5Q8WUNK2BBlrX/gcaqJCbmJmnoVCWn5mioMlVzcUJkuGq/f81L183OTE5IxUA).
[Answer]
# [bc](https://www.gnu.org/software/bc/manual/html_mono/bc.html), 76 bytes
```
while(1)"EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "
```
[Answer]
# [Perl 6](https://perl6.org), ~~81 80~~ 79 bytes
```
print ('EASIER COMMUNICATION','FASTER CODING','FEWER CODERS'X'MEANS'),' 'for ^Inf
```
[Try it](https://tio.run/nexus/perl6#Ky1OVSgz00u2/l9QlJlXoqCh7uoY7OkapODs7@sb6ufp7Bji6e@nrqPu5hgcAhZ28fRzB/FdwyFc16Bg9Qh1X1dHv2B1TR11BfW0/CKFOM@8tP//AQ "Perl 6 – TIO Nexus")
```
loop {print ('EASIER COMMUNICATION','FASTER CODING','FEWER CODERS'X'MEANS'),' '}
```
[Try it](https://tio.run/nexus/perl6#Ky1OVSgz00u2/p@Tn1@gUF1QlJlXoqCh7uoY7OkapODs7@sb6ufp7Bji6e@nrqPu5hgcAhZ28fRzB/FdwyFc16Bg9Qh1X1dHv2B1TR11BfXa//8B "Perl 6 – TIO Nexus")
```
loop {print [~] 'EASIER COMMUNICATION','FASTER CODING','FEWER CODERS'X'MEANS '}
```
[Try it](https://tio.run/nexus/perl6#Ky1OVSgz00u2/p@Tn1@gUF1QlJlXohBdF6ug7uoY7OkapODs7@sb6ufp7Bji6e@nrqPu5hgcAhZ28fRzB/FdwyFc16Bg9Qh1X1dHv2AF9dr//wE "Perl 6 – TIO Nexus")
[Answer]
# [MATL](https://github.com/lmendo/MATL), 68 bytes
```
`'EASIER COMMUNICATION*FASTER CODING*FEWER CODERS*'42' MEANS 'Zt&YDT
```
[Try it online!](https://tio.run/nexus/matl#@5@g7uoY7OkapODs7@sb6ufp7Bji6e@n5eYYHAIWdPH0c9dycw2HcFyDgrXUTYzUFXxdHf2CFdSjStQiXUL@/wcA "MATL – TIO Nexus")
### 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)
```
[Answer]
# 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"
[Answer]
# [Blank](https://esolangs.org/wiki/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](https://esolangs.org/wiki/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
```
[Answer]
# Groovy 79 bytes
```
m=" MEANS";for(;;)print"EASIER COMMUNICATION$m FASTER CODING$m FEWER CODERS$m "
```
Uses groovy's string interpolation.
]


[Question]
      []


[Question]
      [
The dealer has been sloppy and lost track of what cards his/her deck contains and what cards are missing, can you help him/her?
---
A complete deck consists of 52 playing cards, namely:
Each color in the deck (hearts, diamonds, spades, clubs) contains:
* The numbers [2 - 10]
* A Jack
* A Queen
* A King
* An Ace
---
**Task**
Your program will read the contents of the deck from STDIN until a newline is read.
You can assume that the input will be in the form of "nX nX nX nX" etc. where:
* n - any number between [2 - 10] **or** either 'J', 'Q', 'K' or 'A'.
(You can assume upper case only for non-numeric characters)
* X - any of the following : 'H', 'D', 'S', 'C' (You can assume upper
case only)
Where:
* 'J' = Jacks
* 'Q' = Queen
* 'K' = King
* 'A' = Ace
And
* 'H' = Hearts
* 'D' = Diamonds
* 'S' = Spades
* 'C' = Clubs
You can assume that there will be no duplicates in the input.
Your program must then print the missing cards in the deck to STDOUT in the same fashion as the input ("nX nX nX") or print 'No missing cards' if all 52 cards are supplied.
There is no constraint on the order of the output of the cards.
Example input:
```
9H AH 7C 3S 10S KD JS 9C 2H 8H 8C AC AS AD 7D 4D 2C JD 6S
```
Output:
```
3H 4H 5H 6H 7H 10H JH QH KH 2D 3D 5D 6D 8D 9D 10D QD 2S 4S 5S 7S 8S 9S QS KS 3C 4C 5C 6C 10C JC QC HC
```
Happy golfing!

[Answer]
## Windows Batch (CMD), ~~205~~ 204 bytes
```
@set/pc=
@set d=
@for %%s in (H D S C)do @for %%r in (2 3 4 5 6 7 8 9 10 J Q K A)do @call set d=%%d%% %%r%%s
@for %%c in (%c%)do @call set d=%%d: %%c=%%
@if "%d%"=="" set d= No missing cards
@echo%d%
```
Loops over the suits and ranks building a complete deck, then deletes the input cards. Save 1 byte if `T` is allowed instead of `10`. Save 11 bytes if command-line arguments are acceptable input. Edit: Saved 1 byte thanks to @user202729.
[Answer]
# Python, ~~147~~ ~~146~~ ~~145~~ ~~138~~ ~~131~~ ~~129~~ ~~127~~ ~~125~~ 120 bytes
```
print(' '.join(set(`x`+y for x in range(2,11)+list('JQKA')for y in'HDSC')-set(raw_input().split()))or'No missing cards')
```
Gets all possible cards as a set and subtracts the input cards.
-1 byte thanks to mbomb007 pointing out an extra space in my code.
-1 byte thanks to mbomb007 for pointing out some golfing that can be done with Python 2 (-5 bytes and +4 bytes for `raw_` in `raw_input`)
-7 bytes by switching to using sets and set subtraction instead of list comprehensions
-7 bytes thanks to ValueInk for pointing out that I don't need to `list` the suites
-2 bytes thanks to Datastream for pointing out that just writing out all of the values is more byte-effective than the weird thing I had earlier
-2 bytes thanks to ValueInk for pointing out that sets can take generators so I don't need to put it in a list comprehension
-2 bytes thanks to Datastream for pointing out that I can golf it down even more if I switch to Python 3 again... (+2 for parens after for print, -4 for `raw_`)
-5 bytes thanks to Lulhum and myself for pointing out that by switching back to Python 2 (!!!) can help me save bytes (using range again, using backticks instead of `str(`, and +4 due to `raw_`)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 39 bytes
```
ðIð¡YTŸ"JQKA"S«"CDHS"SâJsKðýDg>i“Noœ¶‡¶
```
[Try it online!](https://tio.run/nexus/05ab1e#DY49asNQEISv8qETJPqxpCYgdovNexB4bJqcIKRKkQv4DmnTOG0aVcaNGz18EV9EWfhmi2WYmb2uz3XdTm@vt0uTSl4a3/4aUfPG62/6ynWtV31/@rgff14@b9/b@X48bed9n43FGIXOORiPD05WkjMLrTEFwhI4izIqvdIKSTl4uCWkIaONv9NFkNIZvdDHdQZhUAYjBUJRilGcImQjR10YojsChTGmOJMyxQBl9n8 "05AB1E – TIO Nexus")
**Explanation**
```
ðI                                       # push space and input
  ð¡                                     # split on spaces
    YTŸ                                  # push the range [2 ... 10]
       "JQKA"S«                          # append ['J','Q','K','A']
               "CDHS"Sâ                  # cartesian product with suits
                       J                 # join each card with its suit
                        sK               # remove any cards in input from the list of all cards
                          ðýDg>i         # if the length of the resulting list is 0
                                “Noœ¶‡¶  # push the string "No missing cards"
                                         # output top of stack
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), ~~49~~ 47 bytes
```
B,2>"JQKA"+"HDSC"m*:slS/-S*"No missing cards"e|
```
[Try it online!](https://tio.run/nexus/cjam#DcJBCsIwEEDRq3xmWRU1irUuhDizCCkIMicQFSlYBbP17rGPV0/zcJR86aPMJJmrjM2hvHy58EbOH8ahlOH95Hb93os8frV2iZholY2zXjm9kZ1OCYn9VIlTJxqtsTWCko2d/wE "CJam – TIO Nexus")
**Explanation**
```
B,                    e# The range from 0 to 10
2>                    e# Slice after the first two elements, giving the range from 2 to 10
"JQKA"+               e# Concatenate with "JQKA", giving the array containing all ranks
"HDSC"                e# The string containing all suits
m*                    e# Take the Cartesian product
:s                    e# And cast each pair to a string. Now a full deck has been constructed
l                     e# Read a line of input
S/                    e# Split it on spaces
-                     e# Remove all cards from the deck that were in the input
S*                    e# Join the result with spaces
"No missing cards"    e# Push the string "No missing cards"
e|                    e# Take the logical OR of the result and the string, returning the
                      e#   first truthy value between the two. (empty arrays are falsy)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 39 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
9R‘Ṿ€;“JQKA”p“CDHS”F€œ-ɠḲ¤Kȯ“¡¢ıḍĖ9ṭƥw»
```
**[Try it online!](https://tio.run/nexus/jelly#FY29agJxEMR7n2JeQFDvm1THLrLcvzr3RdKlPdKnCoQUEVS0U0KsFMHi0JA8xt2LXCbN7uwMv9mhWPTNe3e@9s/7h775qOpQ9s3ykVLUnHLO5P46/l11p2O7DT@fjNp1u7l9daeX21vRnQ/fu6f2MgyJYiYoBLkhp@BpqBWRYjpxZILYEAQRM0cqSAwzR23IDKUgdQRHRUxR0xdUhsgICzICioSWI1bETpdLEAwVUUNC@v8RfzsKdipKR87JEkepoz8)**
### How?
```
9R‘Ṿ€;“JQKA”p“CDHS”F€œ-ɠḲ¤Kȯ“¡¢ıḍĖ9ṭƥw» - Main link: no arguments
9R                                      - range(1,9)    [1,2,3,4,5,6,7,8,9]
  ‘                                     - increment     [2,3,4,5,6,7,8,9,10]
   Ṿ€                                   - uneval each  [['2'],['3'],['4'],['5'],['6'],['7'],['8'],['9'],['10']]
     ;“JQKA”                            - concatenate with char-list "JQKA" [['2'],['3'],['4'],['5'],['6'],['7'],['8'],['9'],['10'],['J'],['Q'],['K'],['A']]
            p“CDHS”                     - Cartesian product with char-list "CDHS" [[['2'],['C']],[['2'],['D']],...]
                   F€                   - flatten each [['2','C'],['2','S'],...]
                         ¤              - nilad followed by link(s) as a nilad
                       ɠ                -     read a line from STDIN
                        Ḳ               -     split on spaces
                     œ-                 - multi-set difference
                          K             - join with spaces
                            “¡¢ıḍĖ9ṭƥw» - compressed string "No missing cards"
                           ȯ            - logical or
                                        - implicit print
```
[Answer]
# C#, 343 bytes
First time posting one of my golfs, not a very good contender though. I'm sure I can reduce this more.
The idea behind it is a sparse array storing occurrences of cards, with indexes calculated by the ASCII values of the different values and suits multiplied against each other (e.g. an ace of spades (AS) would be stored in the area at index (65 \* 83 = 5395)). This way, each type of card gets a unique index that can be checked later for existance in the "map" array.
```
void M(string[]a){var c=new int[]
{50,51,52,53,54,55,56,57,49,74,81,75,65,72,68,83,67};var e=new
int[9999];int i=0;int j=0;foreach(var s in a) e[s[0]*s[s.Length-
1]]++;int f=0;for(i=0;i<13;i++)for(j=13;j<17;j++)if(e[c[i]*c[j]]==0)
{f=1;Console.Write(((i<9)?(i+2)+"":(char)c[i]+"")+(char)c[j]+"
");}if(f==0) Console.WriteLine("No missing cards");}
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~114~~ ~~111~~ 110 bytes
```
param($n)('No missing cards',($a=(2..10+'JQKA'[0..3]|%{$i=$_;"CSHD"[0..3]|%{"$i$_"}}|?{$n-notmatch$_})))[!!$a]
```
[Try it online!](https://tio.run/nexus/powershell#PcjNaoNQEAbQ/fcUidxylbaSXv8pocjMYlAoyCxDkEsKiQtNidklPrvd9SzP@utvfgzNFIX2@7oZh3kepvPm5G8/s30Ljd@HLo4/dq@26draHnZxnByfLw8z7E3/GZAKB/8ZmMH0wbI8vx5mep@u99HfTxfTL1EUHbZb44/rulpHcAoncIyEkCgSQcJICakiFaSMjJApMkHGyAm5IhfkjIJQKApBwSgJpaIUlIyKUCkqQcVoCI2iETSMjtApOkHHaAmtohW0jJpQK2pBzfYP "PowerShell – TIO Nexus")
Takes input `$n` as either a space-delimited or newline-delimited string. Constructs an array from the range `2..10` concatenated with `JQKA` (indexed with `[0..3]` to make it a `char` array). That array is fed into a loop `|%{}` that sets helper `$i` then loops over the suits to concatenate the results together with `$i$_`. At the end of this loop, we have an array of strings like `("2C", "2S", "2H", ... "AH", "AD")`. That array is fed into a `Where-Object` (`|?{}`) with the filter as those elements `$_` that regex `-notmatch` the input `$n`. The result of that filtering is stored into `$a`.
Then, we use a pseudo-ternary `( , )[]` to select whether we output `'No missing cards'` or `$a`, based on whether `!!$a` turns to a Boolean `$false` or `$true`. If `$a` is empty (meaning every card in the deck is in the input), then `!!$a` is `0`, so the `"No missing cards"` is selected. Vice versa for `$a` being selected. In either case, that's left on the pipeline, and output is implicit.
[Answer]
# Bash + coreutils, 89
```
sort|comm -3 <(printf %s\\n {10,{2..9},A,J,K,Q}{C,D,H,S}) -|grep .||echo No missing cards
```
I/O as a newline-delimited list.
### Explanation
* `sort` reads newline-delimited input from STDIN and sorts it
* This is piped to `comm`
* `printf %s\\n {10,{2..9},A,J,K,Q}{C,D,H,S}` is a brace-expansion to generate the full deck of cards. The `printf` prints each card on its own line. The order is given such that the output is the same as if it had been piped to `sort`
* `comm` compares the full deck against the sorted input and outputs the difference. `-3` suppresses output of column 3 (the common ones)
* The whole output from `comm` is piped to `grep .`. If there was no output from `comm` (i.e. all cards were in the input), then the `||` "or" clause outputs the required message. Otherwise the `grep .` matches all lines output from `comm`.
[Try it online](https://tio.run/nexus/bash#DcK9CoMwFAbQ/XuKuxRauIo/pVboEpIhKBRKVpdirXXQSOJmfHbr4ezeuiW0dhwpyulxnt0wLV86@aaZaE0TXrM4LjcWXHHNr22VrFiz2S4Uhd51M8UhdO3P0tPSOHg/TD21b/fx@15qCI1CIjdIE4NaoTIoJTKN@1FCHA2EQqFwVcgkKoWb@QM).
[Answer]
# [Python 2](https://docs.python.org/2/),~~104,93,130~~,114 bytes
```
r=input()
print' '.join(n+x for n in list('23456789JQKA')+['10']for x in'HDSC'if n+x not in r)or'No missing cards'
```
[Try it online!](https://tio.run/nexus/python2#FY67asQwFET7fMXpZLMk7PrtIoWRiosNAaMypFi82UQhkRbbgf3x1I4Mc2GKM3dmm5@dv/2uSfpwm51fFerpKzif@MOda5jxOM@3W9ZEZXlRVnXT9uPQqfTwqk5H9bYz98goMVYrd2UP@rDusTkNs3oJ/Lhlcf6D6TxfFrVtqhU6odbkltPRMhh6S6vJhCZK00VZOkNtKAyZpjdUlix6Sy7khlxTCIWl0JRCaSgtpaYSqghr6thhaQxNfG5oLb3Qa0ZhNIyWUTMIQxyg4w6JZ9SfD4/Tefp8/wc "Python 2 – TIO Nexus")
* -10 bytes with hardcoding the list instead of using range!
* +37 bytes - missed printing 'No missing cards' if all cards are present in input!
* -16 bytes by modifying the code into a list comprehension!
[Answer]
# Ruby, 108 + 1 = 109 bytes
Uses the `-p` flag.
```
a=[*?2..'10',?J,?Q,?K,?A].map{|i|%w"H D S C".map{|c|i+c}}.flatten-$_.split;$_=a==[]?"No missing cards":a*' '
```
[Answer]
# PHP, 143 Bytes
```
foreach([H,D,S,C]as$c)foreach([2,3,4,5,6,7,8,9,10,J,Q,K,A]as$v)$r[]=$v.$c;echo join(" ",array_diff($r,explode(" ",$argn)))?:"No missing cards";
```
[Answer]
# [sed](https://www.gnu.org/software/sed/), 157 + 1 (`-r` flag) = ~~170~~ 158 bytes
```
x
s/$/;A2345678910JQK/
s/.+/&H&D&S&C;No missing cards/
:
s/(10|\w)(\w+)(.);/\1\3 \2\3;/
t
G
:s
s/(10.|[^ ;1]{2})(.*\n.*)\1/\2/
ts
s/[ ;]+/ /g
s/^ //
s/ N.+//
```
[Try it online!](https://tio.run/nexus/sed#Jc1Bi8IwFATge37FHJbSWuxrUrXWnEoCWyoIkqNPQRSkh20XI7iw@tftRhbmMAwfzPgjPH2QrlUxmy/KZSXzdrumMGYpRU1kIxcZvRnw1Xnf9RecjtezJ7EKIpb5g@9JzPc0ibNEE0suwIoLTeImPsXK/6vssTtAy/2vegY44T6bJCyJVWBvsoPepwS6hH4Avd@xCf80jlWDukFpUDjI3GFt0TpUBqrBMsSgDnGoLUqLmYUyaC0W7jV837qh9@P0@gc "sed – TIO Nexus")
This generates all possible cards and then remove each card in the input from the generated cards.
[Answer]
## [C#](http://csharppad.com/gist/0018fae00fc41bff1ac6681e4e5b2412), 282 bytes
---
**Golfed**
```
i=>{var o=new System.Collections.Generic.List<string>();string[] S={"H","D","S","C"},N="A 2 3 4 5 6 7 8 9 10 J Q K".Split(' ');foreach(var s in S){foreach(var n in N){if(!System.Linq.Enumerable.Contains(i,n+s)){o.Add(n+s);}}}return o.Count>0?string.Join(" ",o):"No missing cards";};
```
---
**Ungolfed**
```
i => {
    var o = new System.Collections.Generic.List<string>();
    string[] S = { "H", "D", "S", "C" }, N = "A 2 3 4 5 6 7 8 9 10 J Q K".Split(' ');
    foreach( var s in S ) {
        foreach( var n in N ) {
            if( !System.Linq.Enumerable.Contains( i, n + s ) ) {
                o.Add( n + s );
            }
        }
    }
    return o.Count > 0
        ? string.Join( " ", o )
        : "No missing cards";
};
```
---
[Answer]
## JavaScript (ES6), ~~117~~ ~~114~~ 111 bytes
```
s=>[...Array(52)].map((_,i)=>~s.search(c=('JQKA'[v=i>>2]||v-2)+'CDHS'[i&3])?_:c+' ').join``||'No missing cards'
```
This takes advantage of the fact that *undefined* entries in the array generated by `map()` are coerced to empty strings when `join()`'d.
### Demo
```
let f =
s=>[...Array(52)].map((_,i)=>~s.search(c=('JQKA'[v=i>>2]||v-2)+'CDHS'[i&3])?_:c+' ').join``||'No missing cards'
console.log(f('9H AH 7C 3S 10S KD JS 9C 2H 8H 8C AC AS AD 7D 4D 2C JD 6S'))
```
[Answer]
# [Retina](https://github.com/m-ender/retina), 76 bytes
```
^
A2345678910JQK¶
\G(10|.)
 $&H $&D $&S $&C
Dr` \S+
G1`
^$
No missing cards
```
Input/output is a list of space-separated cards. Output has a leading space.
[Try it online!](https://tio.run/nexus/retina#DcNBCsIwEAXQ/ZziL4oogiRpbZplyEBDCoLMtpQWBelChXbruTyAF6uB97aBvCmrc20bp1W6dr8vqG/3Wn1OB0KxiznnkgfiZUQvR2r1SENBlzee87rOrwdu03Jft81F@AgbUAq0EnSMJHABJqLJAnwm8AzLqBgmIDFq@QM "Retina – TIO Nexus")
### Explanation
Most of the code deals with building the full list of cards that should be in the deck:
```
^
A2345678910JQK¶
\G(10|.)
 $&H $&D $&S $&C
```
First, we prepend a newline to the input, with all possible values of cards, then for each character of this line (or the couple of characters `10`) we build the list of all possible suits of that card.
```
Dr` \S+
```
This is a deduplication stage, it splits the string into chunks consisting of a space plus some non-spaces and keeps only one occurrence of each chunk. The modifier `r` makes this operate from right to left, keeping then the *last* occurrence of each chunk.
```
G1`
```
We keep only the first line, which now contains the missing cards.
```
^$
No missing cards
```
If the result is empty we replace it with "No missing cards"
[Answer]
# Python 3, 106 bytes
Combination of the two previous python answers mixed with some string unpacking shenanigans.
```
print(' '.join({x+y for x in[*'23456789JQKA','10']for y in'HDSC'}-{*input().split()})or'No missing cards')
```
[Answer]
# [Julia](http://julialang.org/), 116 bytes
```
print(join(setdiff(["$x$y"for x=∪(2:10,"JQKA")for y="HDSC"],readline()|>split),' ')|>s->s>""?s:"No missing cards")
```
[Try it online!](https://tio.run/##FY5daoNQEIW3crgEomAh8S8aiEVmHi4KBZnH0odQtdxgNXgtJNAFdC1dVjdib@AbmDMc5pzL12DO6bpeZzMu3mUyo2e7pTV9772qzW1zV/0043b6@/n1wuN@F6iqqUvlP673k9IspN6CuTu3gxk7z/8u7HUwix9ssX2Ip8IWSj3bo3qZ8GmsNeMH3s9za5W/rrlGqXEgRIL9TlAzKkFOCDUyB6F0CErGgREzQkLFSAWh2wWRRsSICLFGLIgJiUbCSAQJIdVInZlwcBmCjJG554xcUGlUhEajYTSChlBr1K4AuR7aDf8D "Julia 0.6 – Try It Online")
Very similar to Kyle Gullions python solution. Setdiff instead of - and the lambda to test for the empty string make it worse though.
[Answer]
# Japt, 39 bytes
```
"JQKA"¬c9õÄ)ï+"CHSD"q)kU ¸ª`No ÚÍg Ößs
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=IkpRS0EirGM59cQp7ysiQ0hTRCJxKWtVILiqYE5vINrNiGcg1t9z&input=WyI5SCIsIkFIIiwiN0MiLCIzUyIsIjEwUyIsIktEIiwiSlMiLCI5QyIsIjJIIiwiOEgiLCI4QyIsIkFDIiwiQVMiLCJBRCIsIjdEIiwiNEQiLCIyQyIsIkpEIiwiNlMiXQo=)
[Answer]
# [Tcl](http://tcl.tk/), 270 228 chars
(Shortened with some help from Wît Wisarhd)
```
foreach s {H D S C} {foreach c {2 3 4 5 6 7 8 9 J Q K A} {dict set d $c$s 0}}
gets stdin l
foreach c $l {dict set d $c 1}
set m {}
dict for {c h} $d {if {!$h} {lappend m $c}}
if {![llength $m]} {set m "No missing cards"}
puts $m
```
[Try it online!](https://tio.run/##XY7BasMwEETv/orXoA9InDSOj8Y6GAcKRcfSQ5Ac2yA7JlJOQt/uqimlUJjD7s5jZr2263q93buLHnCEBomijoTfoybk7DnwypGCEyUt75ypEmRG7XGdxyC0cGxjzPrOO5w344zN/lKE/Yezi9n3PBFi9nQSTNAMEWEI45XwItIS7GVZutkkUuhU8DQ@rO3m3g@I6TMhP0GbtxvT6Nw49@jL3bhNzJZHekdM61o2VA1FzV6x2yrOklZR1uQNp6SaKklRSQrJQZLXtJKj@gI "Tcl – Try It Online")
Explanation:
This implementation builds a dictionary consisting of a boolean flag for
each of the cards represented by the cartesian product of H D S C and
2-through-A. It reads the line from stdin, which if given as the spec
as called for, is actually a well formed Tcl list. As each card is read,
a boolean true is input in the dictionary for that card.
At the end a parser loops through the dictionary, and adds any card that
did not have a true in the dictionary to a list of missing cards. If the
missing cards list length is zero, output "No missing cards", otherwise
output the list of missing cards.
[Answer]
# [PHP](https://php.net/), 138 bytes
Ran with `-n` and `-d error_reporting=0`
I reuse some code from an [old submition](https://codegolf.stackexchange.com/a/166666/77963) i made that asked for create a deck of cards
**Code**
```
<?$r=[];foreach([A,J,Q,K,2,3,4,5,6,7,8,9,10]as$t)array_push($r,$t.H,$t.S,$t.D,$t.C);
echo join(" ", array_diff($r,explode(" ",$argv[1])));
```
[Try it online!](https://tio.run/##JYtBa4NAFAbv/RUfYQ8KL0VNGiM2FNk9iDmVPYoEiWu0FHd52tL@@W5jC8NchnGD8/75RfCpbvLesmmvQ1AXVNErnSmhHe3piQ6U0pEyiqOmncUStszt98V9zEMgmMTyWK7Sq9QqGeYP5jpYvNlxCjbYEP6Xbuz7dTFf7t125i@Jlm@fddyEYZh777MSRYlUYqcRRxpnhUojk0hKHO9IFHc0CoVUYa@QSFQKB/1j3TLaafbbyW87GGbLFzbO8jJOt1P0Cw "PHP – Try It Online")
**Explanation**
```
<?$r=[];   # Declare the array that will contain the full deck
# the next line will generate the arry with the full deck
foreach([A,J,Q,K,2,3,4,5,6,7,8,9,10]as$t)array_push($r,$t.H,$t.S,$t.D,$t.C);
# explode the input string on each blank space and using array_diff to get the
# different elements withing both arrays. (and "echo" of course)
echo join(" ", array_diff($r,explode(" ",$argv[1])));
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 197 bytes
Without LINQ.
```
s=>{var w="";for(var j=0;j<52;){var u="";int t=j%13;u=t<1?"K":t<2?"A":t<11?t+"":t<12?"J":"Q";t=j++/13;u+=t<1?"H":t<2?"D":t<3?"S":"C";w+=s.IndexOf(u)<0?u+" ":"";}return w==""?"No missing cards":w;};
```
[Try it online!](https://tio.run/##XZBfb4IwFMXf@RQnTZZA2JzgNqcFCYEsTPefhz0jVFOjZWmLbjF@dlZwT0tvcm77O6e5uaW6KmvJ2kZxsUb@ozTbUavcFkrhTdZrWeyOFvDVLLe8hNKFNrKveYXnggvb6SDw0IgyUFqaPy5x1hmWCFsVzo77QuIQEkJXtbS7yyYc0k1w61OnZ03HuNDQ4ebCG9Em1IEXkQWZ6sCPSNyp50XaJX1nnuZkSt4JNX7Xve4S7jmS/UXSTkcRyY0vIfTghmrwKCr2/bqyGycYRo1LYBihJ8l0I4WZzwwRkZcaO676VZSFrBSZHuiJttQ6L2aQ1ELVWzb4lFyzJy6YvbT/oQ9WVD1xHIda1smcdpIhzjBOMMrhDXMsUsxzTBL4Ge5NJYhN5YhTjFPcpPATzFPcGWeGXw "C# (.NET Core) – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 73 bytes
```
put keys((<<{^9+2}J Q K A>>X~ <C S D H>)∖get.words)||"No missing cards"
```
[Try it online!](https://tio.run/##DchNCoJAAIDRq3y4UoIoC00QYZhZDApBzKZVECUi/SiOEZG17gQdsItMwlu9tuzOkXPtredUPqzvp@lzl0zCV86GApFl2zepxKDQWfD7fKuyn96b7miDYfDWDZfa2vpacdiP5zmXaIQmliwM85mhUOSGRBJqViOJGBmEIlYsFaEkV0TmDw "Perl 6 – Try It Online")
Some pretty simple set subtraction between the deck of cards and the input.
[Answer]
# [Python 3](https://docs.python.org/3/), 102 bytes
```
lambda s:' '.join(i+j for i in[*'A23456789JQK','10']for j in'HDSC'if(i+j)not in s)or'No missing cards'
```
[Try it online!](https://tio.run/##FYs7D4IwGEX/yt0@qsbwkoeJA2kHAomJ6agOKEFLpCUUB389luRM95w7/ua30dHSnW7LpxkebQN7JNC@N0p7atujMxMUlL5uqAij@JCkWV5datpR4NN9tb2zVArJSXXrhWkzuwmWmYnOBoOyVukXns3UWlrGSenZc6Uev7PHGFvyEkWJlCOSCHyJWqCSyDnCEpmDo3BIFAKpQCwQclQCifwD "Python 3 – Try It Online")
]


[Question]
      [
*Note: This is the **cops'** thread, where one should post the scrambled code. Here is the **[robbers' thread](https://codegolf.stackexchange.com/questions/115034/robbers-square-times-square-root)*** where the cracked source should be posted and linked to the cop's answer.
---
**Task:** Write the shortest *safe* program which multiplies the square root of an integer ***n*** by the square of ***n***
This is [cops-and-robbers](/questions/tagged/cops-and-robbers "show questions tagged 'cops-and-robbers'"), so the rules are:
* In your answer, post a scrambled version of your source code (the characters should be written in any order). The scrambled version **should not** work!
* You can take input in any standard way, the same goes for output. Hardcoding is forbidden
* After the code is cracked by the robbers (if this happens), you must mention that your code has been cracked in your title and add a ***[spoiler](https://meta.stackexchange.com/questions/1191/add-markdown-support-for-hidden-until-you-click-text-aka-spoilers)*** to your answer's body with your exact code
* The same applies to safe answers (mention that it's safe and add the ***[spoiler](https://meta.stackexchange.com/questions/1191/add-markdown-support-for-hidden-until-you-click-text-aka-spoilers)***)
* The code is considered *safe* if nobody has cracked it in 5 days after posting it and you can optionally specify that in the title
* You must specify your programming language
* You should specify your byte count
* You must state the rounding mechanism in your answer (see below)
---
You can assume that the result is lower than 232 and ***n*** is always positive. If the result is an integer, you must return the exact value with or without a decimal point; otherwise the minimum decimal precision will be 3 decimal places with any rounding mechanism of your choice, but can include more. **You must state the rounding mechanism in your answer.** You are not allowed to return as fractions (numerator, denominator pairs - sorry, Bash!)
### Examples:
```
In -> Out
4 -> 32.0 (or 32)
6 -> 88.18163074019441 (or 88.182 following the rules above)
9 -> 243.0
25 -> 3125.0
```
The shortest safe answer by the end of April will be considered the winner.

[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 35 bytes
```
√∂¬£=s‚Ä∞sr2x√∂R+RM0`.T"YVBYCD≈æ‚Äû¬®¬®"6¬£H-L
```
This one took me a while to make.
There's some double quotes in there, so you can surround as much of the code as you want in them.
No rounding, decimal point precision.
[Answer]
# [Fireball](https://github.com/okx-code/Fireball), 8 bytes ([Cracked by Roman Gr√§f](https://codegolf.stackexchange.com/a/115197/34718))
```
‚ô•1Z*^¬≤/‚ô•
```
Does not round, uses floating point precision.
Code surrounded with hearts ;)
Should pretty easy to crack, once you have a look into Fireball.
[Answer]
## C#, 112 bytes (cracked by [Emigna](https://codegolf.stackexchange.com/a/115178/67504))
```
     ((((())))),.....25;;;=CCLMMPPPRSWaaaaaaabbbccdddeeeeeeeeghiiiiiillllmnnnnnooooooorrrsssssssstttttuuvvwy{{}}
```
no rounding done
```
using System;
class P
{
    static void Main()
    {
        var b=double.Parse(Console.ReadLine());
        Console.Write(Math.Pow(b,2.5));
    }
}
```
[Answer]
# [NO!](https://github.com/ValyrioCode/NO), 41 bytes (Cracked by [Emigna](https://codegolf.stackexchange.com/a/115386/66833))
NOOO! NO! can finally compete! ~~Although no-one will be bothered to crack this anyway :(~~
Anyway *sigh* here's the code:
```
NNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO??
nnno!
```
Full list of commands [here](https://github.com/ValyrioCode/NO/blob/master/Doc/List%20of%20Commands.md).
Coded in Python so uses Python rounding.
NOOOOOOOOO!!!!!!!! Someone cracked it. (Curse you Emigna!) (just kidding!)
[Answer]
## C, 115 bytes, ([Cracked by @tehtmi](https://codegolf.stackexchange.com/a/115477/44706))
```
""%&&((((((()))))))******++++,..//01122233388;;;;;;<====>>   bbbdddeeeefffggillllllllllnnnnnnnnoooooooooooprrtuuu{}
```
Notice that it does include 3 spaces.
Always outputs 3 exact decimals, rounded to the closest thousandth.
Should be rather fun to crack as it doesn't involve any built-in to compute powers or square roots, as opposed to most (cracked) solutions so far.
Example run (which also gives you a few small hints):
```
int main() {
  int n[] = {4, 6, 9, 25};
  for (int i = 0; i < 4; i++) {
    printf("%i => ", n[i]);
    o(n[i]);
    printf("\n");
  }
}
```
outputs:
```
4 => 32.000
6 => 88.182
9 => 243.000
25 => 3125.000
```
Tested with both gcc and clang, with no compilation flag needed.
---
It's been cracked; the original solution was
```
o(double n){long o=2.303e18+(*(long*)&n>>1);double l=*(double*)&o;for(o=2;o++<8;)l=(l+n/l)/2;printf("%.3f",l*n*n);}
```
which uses a magic constant in the same spirit as [the infamous fast inverse square root algorithm](https://en.wikipedia.org/wiki/Fast_inverse_square_root#Overview_of_the_code) to do just a handful of Newton iterations (as opposed to several thousands in the cracked solution)
[Answer]
# 05AB1E, 23 bytes ([Cracked by Emigna](https://codegolf.stackexchange.com/questions/115034/robbers-square-times-square-root/115773#115773))
A totally different approach than my previous answers :)
```
$++/02;@DDDGHP\rrszz}¬π≈æ
```
No rounding.
**Example runs**
```
In   -> Out
0    -> 0
4    -> 32.0
6    -> 88.18163074019441
25   -> 3125.0
7131 -> 4294138928.8967724
```
[Answer]
## Excel VBA, 59 bytes (Safe)
```
?(())*..//11124AAAAFPSW[[]]^acceehiiiiklnnnnoooppqrrstttttu
```
No particular rounding.
Uses the Immediate Window.
[Answer]
# Octave, 42 bytes (Safe)
```
((((()))))+,,,-//01111111@[]^mnooorrssst~~
```
No rounding. Floating point accuracy.
### Intended solution
>
>  `@(s)norm(roots([-1,~1,s^(10/(1+1))]),1/~1)`
>
>
>
>
> [Try it online!](https://tio.run/nexus/octave#@@@gUayZl1@Uq1GUn19SrBGta6hTZ6hTHKdhaKCvYahtqKkZq6ljqF9nqPk/Ma9Yw0zzPwA)
>
>
>
[Answer]
# Lua 5.3, 110 bytes (safe)
```
((((()))))**,,,,,-....=====>~             aaaaaaaaacddddeeeffhhhiiiiiiilllmmnnnnnnooopppppprrrrrrrsssssssstttt
```
Calculations are standard using Lua numbers (ie double in common implementations). Tested using PUC-Rio interpreter. (I hope I didn't do anything bad, but I think it is reasonable...)
This is a full program with input from the command line.
Original solution:
>
>  `for a,r in pairs(math)do l,s=pcall(r,-math.pi)if s~=s and a>=(i or a)then i,p=a,r end end s=...print(s*s*p(s))`
>
>
>
Explanation:
>
>  `math.sqrt` is retrieved from the math library by looping through the `math` table and looking for functions that return NaN (and don't throw an error) when applied to negative pi. There are only a few functions like this, and `sqrt` is alphabetically last.
>
>
>
[Answer]
# Javascript, 15 17 bytes, [Cracked by @Emigna](https://codegolf.stackexchange.com/questions/115034/robbers-square-times-square-root/116237#116237)
```
(x=>x****-125*10)
```
Solution:
>
>  `x=>x**(25*10**-1)`
>
>
>
# Javascript, 18 bytes, Again, [Cracked.](https://codegolf.stackexchange.com/questions/115034/robbers-square-times-square-root/116240#116240)
```
x=>x**-(!3.5++)[];
```
Solution:
>
>  `x=>x**(3-!+[]+.5);`
>
>
>
[Answer]
# JavaScript + [paper.js](http://paperjs.org), 210 bytes (safe)
This one's fun. No comments for you, and no strings either.
paper.js is a vector graphics framework. This is a full program that takes input via a prompt and outputs graphically, because it's possible. There is no rounding and floating-point accuracy (I think).
[Reference](http://paperjs.org/reference/global/)
[Try code here](http://sketch.paperjs.org)
```
Math.tan(prompt(a,0));
leg Rave, ew(0,0),ectoPlasm = Real new qrt(;
marvin atTax M(en) in vr;tent * hat.o = Mat
nottet near(0a,a) w cgee;
brown.cern(lantern) ;( w 0,0.art;vict.o brace
r=v=,h.c.)an=.flClr= Cor0)
```
Edit: Just noticed (my fault for not reading properly)
>
> The shortest safe answer by the end of April will be considered the winner.
>
>
>
Well, oops.
Original solution:
```
var a = prompt(0,0);
var r = new Rectangle(0,0,a,a).area;
var t = new Rectangle(0,0,Math.cbrt(a),Math.sqrt(Math.cbrt(a))).area;
var n = new PointText(view.center);
n.content = r * t;
n.fillColor = new Color(0);
```
[Try code here](http://sketch.paperjs.org)
[Answer]
# [HODOR](https://github.com/ValyrioCode/Hodor/blob/master/English/List%20of%20Commands.md), 172 bytes, [Cracked by Emigna](https://codegolf.stackexchange.com/a/115331/67716)
```
Walder
Hodor Hodor Hodor Hodor Hodor Hodor
Hodor Hodor Hodor Hodor Hodor
Hodor Hodor Hodor Hodor
Hodor Hodor Hodor
Hodor Hodor
Hodor
hodor hodor
HODOR HODOR!!!!!!!,,,,,,..?
```
let me know if I missed anything
[Answer]
# Python 3.6 - 15 bytes ([Cracked by Kritixi Lithos](https://codegolf.stackexchange.com/questions/115034/robbers-square-times-square-root/115065#115065))
```
axx 2*d:b.*5mal
```
Standard rounding precision of Python
[Answer]
# C++, 100 bytes ([Cracked by @fergusq](https://codegolf.stackexchange.com/a/115073/66323))
```
#.leiha2dm"
tuchn"crmueie<linaatt#dso
fameng pcae sli;t>dt nnsiuno;s mnpti;ouic(<){n(a;>w<n>n)co.,5}
```
Standard C++ rounding precision
[Answer]
# Python 2, 44 Bytes ([Cracked by @f…ôÀàn…õt…™k](https://codegolf.stackexchange.com/a/115076/64505))
```
np5w***i0(0(0r0n0t+iarn00p0)_(0tu00i50.0)) t
```
Has accuracy up to 10 decimal digits (I think). No rounding involved and there is a space involved.
[Answer]
# Scala, 19 bytes [(Cracked by @math\_junkie)](https://codegolf.stackexchange.com/a/115101/65425)
```
)>,/2(=addd.hmoptw5
```
This is a function of type `Int=>Double`.
[Answer]
# 05AB1E, 4 bytes ([Cracked by @Mr. Xcoder](https://codegolf.stackexchange.com/questions/115034/robbers-square-times-square-root/115106#115106))
Must be really easy to crack, but I'll still post it here
```
n*t¬π
```
Normal rounding
[Answer]
# C, 60 bytes ([Cracked by @Dave](https://codegolf.stackexchange.com/a/115113/61405))
```
1(root, flat*fat bern**lotr);pw(f{bus(--q.b4/q0*1-2)})(b>1)b
```
Standard C float accuracy.
[Answer]
# 05AB1E, 23 bytes (Cracked by [Emigna](https://codegolf.stackexchange.com/a/115247/67702))
Another try
```
A9n*¬•="'q?:@->%t#[{¬π!.
```
Normal rounding
[Answer]
# [HODOR](https://github.com/ValyrioCode/Hodor), 198 bytes [(Cracked by wwj)](https://codegolf.stackexchange.com/a/115292/66833)
*NB: Had to correct the code!*
Uses the brand-new `hodor` command (Updated Saturday)! Yes, I know I'm not supposed to say but it's pretty obvious anyway and (as far as I know) I'm the only person who can code in Hodor so worth some help :)
This is the code: and the full list of commands is [here](https://github.com/ValyrioCode/Hodor/blob/master/Docs/List%20of%20Commands.md)
```
H!HDHrlrHrhoooo!h, oo!do ordoH!oHHd
dodHrodorooooHdddoooOOo ddro roorrro.r,H
ooO ooHr,
HdHo oo H!O?Hd, oo,, Hdodhd oor, dd!HHrDo aod
rdroHdH,HrRr
 o o RHrdHoo,oro Hr
oo
oHoer o r oddodo,rr
rdd!WrH d
```
[Answer]
# [Stacked](https://tio.run/nexus/stacked), 64 bytes
```
:u#{`E2t#tv',lnp~.iuP#2qr+t,'3m3em`,#9''.::mluls on\ts r:a\:+.S0
```
Good luck.
Result for `6`: `88.181630740194411535`.
[Answer]
# Javascript (ES6), 39 bytes ([Cracked](https://codegolf.stackexchange.com/a/115360/12474))
```
(((())))*....57===>Mabcefghlllloprttxxx
```
The rounding is normal floating point precision for Javascript.
[Answer]
# bash, 158 bytes
This program requires a 64 bit processor to function. Pass input number as argument; result on stdout. I believe rounding is floor function. This program actually does decimal output. If you got integer only keep trying.
```
^=======|       -!
///////......
''(((((((((((())))))))))))
[]$$$$$$$$$****
\\\\\\
#++
000000000000
111111222
bcdddeeeehhhiill
nn
NNNNNNoooOOOOOOO
sssSSSS
tw
```
[Answer]
# Python 2.7, 174 bytes
```
_cc*gnta(dkree_rtrto._i9kuc_ l5_r_cctbimWka(Wihlkeu_5_eur_rri_keeluc4clrp ..u_)(HohhH)ap5o(trbnord_ir9/*in)_clrikroap.ie.tg_obkfkseeeel*in2Hkdu*ffmo4lWlrncde_22);doodt a49 hu
```
[Answer]
# 05AB1E, 15 bytes, ([Cracked by Emigna](https://codegolf.stackexchange.com/questions/115034/robbers-square-times-square-root/115767#115767))
```
+/01;DDDFMPs}¬π≈æ
```
Normal rounding
**Example runs**
```
In   -> Out
0    -> 0
4    -> 32.0
6    -> 88.18163074019441
25   -> 3125.0
7131 -> 4294138928.896773
```
[Answer]
## C#, 135 bytes (cracked by [SLuck49](https://codegolf.stackexchange.com/a/115809/67504))
```
      (((((()))))),,-..../11;;;CCEILMMMPPPRRSSWaaaaaaacccdddeeeeeeeeggghiiiiiiiillllmmnnnnnnnnoooooooorrsssssssssssttttttttuuuvwyy{{}}
```
no rounding done
([First try](https://codegolf.stackexchange.com/a/115174/67504))
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 22 bytes, Cracked by [user4867444](https://codegolf.stackexchange.com/a/115760/47066)
```
+/;DDDFLPT_nz}¬©¬Æ¬π¬π¬π√è√®‚Ä∫
```
**Example runs**
```
In -> Out
0  -> 0
4  -> 32.0
6  -> 88.18163074019441
```
**Original solution**
>
> `LnD¬π‚Ä∫_√è¬Æ¬©√®TFD¬π/z+;}¬πDP`
>
>
>
[Answer]
# JavaScript (ES7), 24 bytes (Safe)
```
()+01488M``aabeiijlooqtv
```
Standard 64 bit floating point rounding.
---
### Solution
>
>  `eval(atob`8j0+8ioqMi41`)`
>
>
>
### Tests
```
console.log(eval(atob`8j0+8ioqMi41`)(0));    // 0
console.log(eval(atob`8j0+8ioqMi41`)(1));    // 1
console.log(eval(atob`8j0+8ioqMi41`)(2));    // 5.656854249492381
console.log(eval(atob`8j0+8ioqMi41`)(4));    // 32
console.log(eval(atob`8j0+8ioqMi41`)(10));   // 316.22776601683796
```
[Answer]
# Javascript (ES7), 53 bytes (safe)
```
(((())))*++++,,,/0233346=====>>[[]]aaaabbbccelootttuv
```
The rounding is normal floating point precision for Javascript.
Tested this in the latest Chrome and FF.
---
### Solution
>
>  `u=>(o=(t,c,a=o+c,b=a[t])=>eval(a[42]+b+b+3*30/t))(36)`
>
>
>
>
>  This works because `a=o+c` is `'(t,c,a=o+c,b=a[t])=>eval(a[42]+b+b+3*30/t)undefined'`.
>
>
>  So `a[42]='u', a[36]='*', 3*30/36=2.5`, making `eval('u**2.5')`.
>
>
>
### Tests
```
var f=u=>(o=(t,c,a=o+c,b=a[t])=>eval(a[42]+b+b+3*30/t))(36);
console.log(f(0));    // 0
console.log(f(1));    // 1
console.log(f(2));    // 5.656854249492381
console.log(f(4));    // 32
console.log(f(10));   // 316.22776601683796
```
[Answer]
# 05AB1E, 27 bytes - safe
Yet another totally different approach from my previous answers.
```
(/1DFFOOPT`ins}}¬©¬Æ¬π¬π√ê√®√´≈æ‚Äö‚Äö‚Äπ
```
No rounding.
**Example runs**
```
In   -> Out
0    -> 0
4    -> 32.0
6    -> 88.18163074019441
25   -> 3125.0
7131 -> 4294138928.896773
```
---
**Solution**
```
√ê(‚Äö≈æFFDO¬©n¬π‚Äπi`T/√´1√®¬Æs}‚Äö}O¬πP
```
This is simply computing the square root with a trivial (and very dumb) trial-and-error strategy...
**Detailed explanation**
```
√ê(‚Äö≈æFFDO¬©n¬π‚Äπi`T/√´1√®¬Æs}‚Äö}O¬πP
√ê(‚Äö                         # triplicate the input, reverse the sign of the last copy, and wrap the last 2 items in a list, which going forward is going to be the list of our current sqrt approximation and of the next decrement in our dumb search (so it starts at [x, -x])
   ≈æFF                      # 16384(!) times, do
      D                     # duplicate the current [value, decrement] list
       O¬©                   # compute the sum value + decrement, and also save it in the register
         n                  # compute the square of that potential new approximation of the square root
          ¬π‚Äπ                # and compare it with the input
            i               # if our new approximation is smaller than the actual square root, then
             `              # push the flattened [value, decrement] list to the stack as value, decrement
              T/            # and divide our decrement by 10
                √´           # else (our new approximation is still bigger than the actual square root, then)
                 1√®         # extract the current decrement from the list
                   ¬Æ        # retrieve the new approximation from the register
                    s       # and switch them to again have them in the value, decrement order
                     }      # end of the if
                      ‚Äö     # no matter which branch of the if we went into, the last 2 items of the stack are now the new approximation and the new decrement, in order: wrap them in a list for the next loop iteration
                       }    # end of the loop
                        O   # replaces the output of the loop (the final [value, decrement] list) by its sum, which given the very small value of the decrement at that point is pretty much the same as our final approximation of sqrt(x)
                         ¬π  # push another copy of x; the stack is now [x, sqrt(x), x] (where the first x comes from the very first copy of the initial √ê)
                          P # computes the product of the whole stack
```
[Try it online!](https://tio.run/nexus/05ab1e#@394gsajhllH97m5ufgfWpl3aOejhp2ZCSH6h1cbHl5xaF1xLVC21v/QzoD//80A)
]


[Question]
      [
On most [new-years](/questions/tagged/new-years "show questions tagged 'new-years'") challenges when it is currently not the corresponding year of the challenge, It says this in the front.
>
> It's [current year] already, folks, go home.
>
>
>
You have to output this text with the current year substituted.
---
# I/O
**Input:** None.
**Output**: `It's [current year] already, folks, go home.`

[Answer]
# bash + date, 40 bytes
```
date +"It's %Y already, folks, go home."
```
[Try it online!](https://tio.run/nexus/bash#@5@SWJKqoK3kWaJerKAaqZCYU5SamFKpo5CWn5NdrKOQnq@QkZ@bqqf0/z8A "Bash – TIO Nexus")
[Answer]
# C (gcc), 58 bytes
```
f(){printf("It's%s already, folks, go home.",__DATE__+6);}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~21~~ 20 bytes
Saved a byte thanks to *Erik the Outgolfer*
```
žg“It's ÿˆ§,¹Ò,‚œ€¨.
```
[Try it online!](https://tio.run/nexus/05ab1e#ASUA2v//xb5n4oCcSXQncyDDv8uGwqcswrnDkizigJrFk@KCrMKoLv// "05AB1E – TIO Nexus")
[Answer]
# TeX (44 bytes)
```
It's \the\year\ already, folks, go home.\bye
```
[Answer]
# PHP, 42 bytes
```
It's <?=date(Y)?> already, folks, go home.
```
[Answer]
# Bash, 45 characters
```
printf "It's %(%Y)T already, folks, go home."
```
Bash's built-in `printf` in version 4.2 got the `%(fmt)T` format specifier and since version 4.3 it defaults to current timestamp in absence of argument.
Sample run:
```
bash-4.3$ printf "It's %(%Y)T already, folks, go home."
It's 2017 already, folks, go home.
```
[Answer]
## Batch, 45 bytes
```
@echo It's %date:~6% already, folks, go home.
```
Batch is actually reasonably competitive for once.
[Answer]
## Mathematica, 53 bytes
```
Print["It's ",Now[[1,1]]," already, folks, go home."]
```
[Answer]
# [Python 2](https://docs.python.org/2/), 67 bytes
```
import time
print"It's",time.gmtime()[0],"already, folks, go home."
```
[Try it online!](https://tio.run/nexus/python2#@5@ZW5BfVKJQkpmbylVQlJlXouRZol6spAMS0EvPBVEamtEGsTpKiTlFqYkplToKafk52cU6Cun5Chn5QEVK//8DAA "Python 2 – TIO Nexus")
[Answer]
# x86 machine code on DOS - 62 bytes
```
00000000  b4 04 cd 1a bf 23 01 88  c8 24 0f 00 05 4f c1 e9  |.....#...$...O..|
00000010  04 75 f4 ba 1b 01 b4 09  cd 21 c3 49 74 27 73 20  |.u.......!.It's |
00000020  30 30 30 30 20 61 6c 72  65 61 64 79 2c 20 66 6f  |0000 already, fo|
00000030  6c 6b 73 2c 20 67 6f 20  68 6f 6d 65 2e 24        |lks, go home.$|
0000003e
```
Even though the input from the BIOS is in BCD (as opposed to the plain 16 bit value got from the equivalent DOS call), decoding it to ASCII turned out to be almost as long as base-10 printing a register. Oh well.
```
    org 100h
section .text
start:
    mov ah,4
    int 1ah             ; get the date from BIOS; cx now contains the year in packed BCD
    mov di,placeholder  ; put di on the last character of placeholder
lop:
    mov al,cl
    and al,0xf  ; get the low nibble of cx
    add [di],al ; add it to the digit
    dec di      ; previous character
    shr cx,4    ; next nibble
    jnz lop     ; loop as long as we have digits to unpack in cx
    mov dx,its
    mov ah,9
    int 21h     ; print the whole string
    ret
its:
    db "It's 000"
placeholder:
    db "0 already, folks, go home.$"
```
[Answer]
## Ruby, 52 bytes
```
puts"It's #{Time.now.year} already, folks, go home."
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 38 bytes
```
"It's "et0=" already, folks, go home."
```
[Try it online!](https://tio.run/nexus/cjam#@6/kWaJerKCUWmJgq6SQmFOUmphSqaOQlp@TXayjkJ6vkJGfm6qn9P8/AA "CJam – TIO Nexus")
[Answer]
# Mathematica, 58 bytes
```
"It's "<>ToString@#<>" already, folks, go home."&@@Date[]&
```
Anonymous function. Takes no input and returns a string as output. No, I'm not going to make a REPL submission, post it yourself if that one byte is so important.
[Answer]
# [Perl 6](https://perl6.org), ~~53~~ 51 bytes
```
say "It's {Date.today.year} already, folks, go home."
```
[Try it](https://tio.run/nexus/perl6#@1@cWKmg5FmiXqxQ7ZJYkqpXkp@SWKlXmZpYVKuQmFOUmphSqaOQlp@TXayjkJ6vkJGfm6qn9P8/AA "Perl 6 – TIO Nexus")
```
say "It's {now.Date.year} already, folks, go home."
```
[Try it](https://tio.run/nexus/perl6#@1@cWKmg5FmiXqxQnZdfrueSWJKqV5maWFSrkJhTlJqYUqmjkJafk12so5Cer5CRn5uqp/T/PwA "Perl 6 – TIO Nexus")
[Answer]
# TI-Basic (TI-84 Plus CE with OS 5.2+), 64 bytes
```
getDate
"It's "+toString(Ans(1))+" already, folks, go home.
```
TI-Basic is a tokenized language. Some commands (`getDate`, `toString(`, etc.), and all lowercase letters are two-bytes and everything else used here is one byte each.
Explanation:
```
getDate                                             # 3, store {Y,M,D} in Ans
"It's "+toString(Ans(1))+" already, folks, go home. # 61, implicitly return required string with Y from getDate
```
# TI-Basic (TI-84 Plus CE with OS 5.1), 108 bytes
```
{0,1→L1
getDate
Ans(1)L1→L2
LinReg(ax+b) Y1
Equ►String(Y1,Str0
sub(Str0,1,length(Str0)-3→Str0
"It's "+Str0+" already, folks, go home.
```
TI-Basic is a tokenized language. The more complicated user variables (`Y1`, `L1`, `L2`, `Str0`), some commands (`LinReg(ax+b` , `getDate`, `sub(`, `Equ►String(`, `length(`), and all lowercase letters are two-bytes and everything else used here is one byte each.
OS 5.2 added a `toString(` command, which obsolesces about half of this submission, which is based off of [this algorithm](http://tibasicdev.wikidot.com/number-to-string).
Explanation:
```
{0,1→L1                                  # 8 bytes
getDate                                  # 3 bytes, store {Y,M,D} list in Ans
Ans(1)L1→L2                              # 10 bytes, multiply L1 by the year and store in L2
LinReg(ax+b) Y1                          # 5 bytes, take a linear regression of the points specified by each pair of corresponding coordinates in L1 and L2 and store it in Y1
Equ►String(Y1,Str0                       # 8 bytes, convert Y1 to a string
sub(Str0,1,length(Str0)-3→Str0           # 18 bytes, remove the "X+0" from LinReg
"It's "+Str0+" already, folks, go home.  # 56 bytes, implicitly return the required output
```
[Answer]
# JavaScript ES6, 56 bytes
```
_=>`It's ${Date().split` `[3]} already, folks, go home.`
```
### Try it online!
```
const f = _=>`It's ${Date().split` `[3]} already, folks, go home.`
console.log(f())
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 31 bytes
```
`It's {Ki} alÎ%y, folks, go Êà.
```
[Try it online!](https://tio.run/nexus/japt#@5/gWaJerFDtnVmrkJhzuE@1UkchLT8nu1hHIT1f4XDX4QV6//8DAA "Japt – TIO Nexus")
[Answer]
## PowerShell 3.0, 44 bytes
```
"It's $(date|% y*) already, folks, go home."
```
PowerShell is competing quite well today!
[Answer]
# R, ~~62 59~~ 62 bytes
```
cat("It's",format(Sys.time(),"%Y"),"already, folks, go home.")
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~39~~ 27 bytes
```
`It's % ×ġ, ṗḊ, go λ∵.`kðt%
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgSXQncyAlIMOXxKEsIOG5l+G4iiwgZ28gzrviiLUuYGvDsHQlIiwiIiwiIl0=)
Surely golfable?
[Answer]
# C#, 58 bytes
```
()=>"It's "+DateTime.Now.Year+" already, folks, go home.";
```
Anonymous function which returns the required string.
Full program:
```
using System;

public class Program
{
    public static void Main()
    {
        Func<string> f=
        ()=>"It's "+DateTime.Now.Year+" already, folks, go home.";

        Console.WriteLine(f());
    }
}
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 38 bytes
```
s["It's ".d3" already, folks, go home.
```
[Online interpreter.](//pyth.herokuapp.com?code=s%5B%22It%27s+%22.d3%22+already%2C+folks%2C+go+home.)
[Answer]
# [Haskell](https://www.haskell.org/), 113 bytes
```
import Data.Time.Clock
f=do t<-getCurrentTime;putStr$"It's "++(fst.span(>'-').show)t++" already, folks, go home."
```
[Try it online!](https://tio.run/nexus/haskell#FcxBDoMgEADAe1@xISZoUD7Q2oteerYf2FRQIrAE1jR9PW3Pk0x1IVFmmJFRP10wevL0Oi52XAn4NmyGpzNnE/mP13TywrkRD5YFhFKtLaxLwtje5SA7XXZ6d6yUAPTZ4PrpwZI/Sg8bwU6/XtSALsIItn4B "Haskell – TIO Nexus") Replace `f` with `main` for a full program.
The function `getCurrentTime` returns a `UTCTime` object which looks something like `"2017-04-02 10:22:29.8550527 UTC"` when converted to a string by `show`. `fst.span(>'-')` takes the leading characters while they are larger than `'-'`, that is the current year. For the next 7972 years `take 4` would work for 8 bytes less, but we want our code to work correctly for ever and ever.
As far as I see build-in functions to get the current year require a `import Data.Time.Calendar`, so extracting the year from the string should be the shortest option.
[Answer]
# JavaScript, ~~77~~ ~~71~~ ~~67~~ 63 bytes
```
alert("It's "+Date().split(' ')[3]+" already, folks, go home.")
```
Thanks to @programmer5000 for the spaces!
# JavaScript ES6 ~~66~~ 60 bytes
```
alert(`It's ${Date().split` `[3]} already, folks, go home.`)
```
[Answer]
# [Befunge-98](https://github.com/catseye/FBBI), ~~57~~ 55 bytes
```
"emoh og ,sklof ,ydaerla@ s'tI"4k,y\4*:*/"&2"*+.f7+k,@
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/Xyk1Nz9DIT9dQac4Oyc/TUGnMiUxtSgn0UFEoVi9xFPJJFunMsZEy0pLX0nNSElLWy/NXDtbx@H/fwA "Befunge-98 (FBBI) – Try It Online")
Thanks to James Holderness for pointing out my mistake with the sysinfo instruction.
`"emoh og ,sklof ,ydaerla@ s'tI"` pushes the sentence to the stack where `4k,` prints the first word. `y` is the sysinfo instruction. When passed 20 (the unprintable in the string), it returns `256*256*(year-1900) + 256*month + day of month`. `\4*:*/"&2"*+.` takes just the year from the value and prints it and`f7+k,` prints the rest of the sentence.
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 48 bytes
```
"It's #{Time.new.year} already, folks, go home."
```
[Try it online!](https://tio.run/nexus/golfscript#@6/kWaJerKBcHZKZm6qXl1quV5maWFSrkJhTlJqYUqmjkJafk12so5Cer5CRD1Sh9P8/AA "GolfScript – TIO Nexus")
Yes, this is string interpolation.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 42 bytes
```
'It''s '1&Z'V' already, folks, go home.'&h
```
[Try it online!](https://tio.run/nexus/matl#@6/uWaKuXqygbqgWpR6mrpCYU5SamFKpo5CWn5NdrKOQnq@QkZ@bqqeulvH//9e8fN3kxOSMVAA "MATL – TIO Nexus")
```
'It''s '                      % Push this string
1&Z'                          % Push current year
V                             % Convert to string
' already, folks, go home.'   % Push this string
&h                            % Concatenate all stack contents horizontally
                              % Implicitly display
```
[Answer]
# Python 3, ~~73~~ 68 bytes
```
import time
print(time.strftime("It's %Y already, folks, go home."))
```
Very basic answer. The "%Y" gets the current year.
*Thanks to @ovs for removing 5 bytes*
[Answer]
## IBM/Lotus Notes Formula, 54 bytes
Not exactly challenging but here we go anyway...
```
"It's "+@Text(@Year(@Now))+" already, folks, go home."
```
[Answer]
**VBScript, 53 bytes**
```
msgbox"It's "&year(now())&" already, folks, go home."
```
]