48
\$\begingroup\$

A current internet meme is to type 2spooky4me, with a second person typing 3spooky5me, following the (n)spooky(n+2)me pattern.

Your mission is to implement this pattern in your chosen language. You should write a program or function that takes a value n (from standard input, as a function argument, or closest alternative), and outputs the string (n)spooky(n+2)me (without the parentheses; to standard output, as a return value for a function, or closest alternative).

Your solution should work for all inputs, from 1 up to 2 below your language's maximum representable integer value (2^32-3 for C on a 32-bit machine, for example).

Example implementation in Python:

def spooky(n):
    return "%dspooky%dme"%(n,n+2)

spooky(2) -> "2spooky4me"

This is , so standard loopholes are forbidden, and the shortest answer in bytes wins!

Leaderboard

The Stack Snippet at the bottom of this post generates the leaderboard from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:

## Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:

## Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:

## Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><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="language-list"> <h2>Shortest Solution 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> <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> <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><script>var QUESTION_ID = 62350; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 45941; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

\$\endgroup\$
6
  • 3
    \$\begingroup\$ For bonus points: Input %dspooky%dme, validate and return next in series. \$\endgroup\$
    – clapp
    Oct 31, 2015 at 6:13
  • 27
    \$\begingroup\$ True, but Dennis would still win \$\endgroup\$
    – clapp
    Oct 31, 2015 at 6:19
  • 10
    \$\begingroup\$ Who is Dennis? :O \$\endgroup\$
    – NuWin
    Feb 15, 2016 at 20:39
  • 17
    \$\begingroup\$ @NuWin Dennis is the way. Dennis is the light. \$\endgroup\$
    – Alex A.
    Feb 15, 2016 at 23:02
  • 2
    \$\begingroup\$ @NuWin Dennis is love, Dennis is life \$\endgroup\$
    – user63571
    Jan 25, 2017 at 19:40

120 Answers 120

1
\$\begingroup\$

Jolf, 16 bytes

"%spooky%me"J+2J

Try it online.

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

Retina, 17 bytes

This assumes that the integer n may be expressed in unary in the output. Each line would go in its own file, with one byte added per additional file.

1+
$_spooky$_11me

If the input is 11, the output is 11spooky1111me.

For non-unary output (but still unary input), use this (27 bytes):

1+
$_spooky$_11me
(\d)+
$#1

Try it online

\$\endgroup\$
1
  • \$\begingroup\$ Is unary the standard way of expressing numbers in retina? \$\endgroup\$
    – Cyoce
    Feb 23, 2016 at 6:14
1
\$\begingroup\$

Applesoft BASIC, 28 bytes

0input n:?n;"spooky";n+2;"me

The question mark expands to PRINT and the missing final double quotation mark is implied.

Tested with Joshua Bell's online emulator.

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

R, 38 bytes

n=scan();sprintf("%dspooky%dme",n,n+2)

or (same length)

sprintf("%dspooky%dme",n<<-scan(),n+2)

Example:

n=scan();sprintf("%dspooky%dme",n,n+2)
1: 999
999spooky1001me
\$\endgroup\$
1
  • 1
    \$\begingroup\$ paste0(n<-scan(),"spooky",n+2,"me") for 35 :-) \$\endgroup\$
    – J.Doe
    Oct 9, 2018 at 11:48
1
\$\begingroup\$

Groovy, 24 22 bytes

{it+"spooky${it+2}me"}
\$\endgroup\$
1
  • \$\begingroup\$ At string's ends is shorter to concatenate: {it+"spooky${it+2}me"}. \$\endgroup\$
    – manatwork
    Mar 23, 2016 at 7:45
1
\$\begingroup\$

Pylongolf, 20 bytes  

_:AA"spooky"A2+"me"~

_ asks for input and :A puts it into the variable A.
A"spooky" pushes A, and spooky then A2+ adds the input + 2.
After that we push "me" into the stack and print it with ~.

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

Stacked, 21 bytes

[:2+,'spooky'#`'me'+]

Try it online!

Function returning the string.

Explanation

[:2+,'spooky'#`'me'+]
[                   ]  function                stack: (y)
 :                     duplicate               stack: (y y)
  2+                   add 2                   stack: (y y+2)
    ,                  pair                    stack: ((y y+2))
     'spooky'#`        join by "spooky"        stack: ("{y}spooky{y+2}")
               'me'+   append the string "me"  stack: ("{y}spooky{y+2}me")
\$\endgroup\$
1
\$\begingroup\$

LOLCODE, 100 99 bytes

HAI 1.3
I HAS A J
GIMMEH J
VISIBLE J!
VISIBLE "spooky"!
VISIBLE SUM OF J AN 2!
VISIBLE "me"
KTHXBYE

Try it online!

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

Kotlin, 24 bytes

{"${it}spooky${it+2}me"}

Try it online!

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

Forth (gforth), 39 bytes

: f 0 2dup .r ." spooky"2 m+ .r ." me";

Try it online!

Code Explanation

: f            \ start a new word definition
  0 2dup       \ add 0 to the top of the stack and duplicate the top two stack values
  .r           \ print the input with no following space
  ." spooky"   \ print "spooky"
  2 m+ .r      \ add 2 to the input and print with no following space
  ." me"       \ print "me"
;              \ end the word definition
\$\endgroup\$
1
\$\begingroup\$

Stax, 12 bytes

ïöeO¬‼3ì╡☻↔G

Run and debug it

Uses an unterminated template literal to embed instructions in an output string.

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

Assembly (MIPS, SPIM), 221 bytes

.data
a: .asciiz "spooky"
c: .asciiz "me"
.text
.globl main
main:
li $2 5
syscall
la $9 a
la $10 a
move $8 $2
l:
move $4 $8
li $2 1
syscall
li $2 4
move $4 $9
syscall
bne $10 $9 e
la $9 c
addi $8 2
j l
e:
li $2 10
syscall

Try it online!

Couldn't get SPIM and TIO to play nice with argc/argv, so had to take it via input. String formatting in Assembly isn't pleasant.

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

Keg, -no 13 bytes

:&spooky&2+me

This was way too spooky. It's not even October!

Pushes the evaluated input and stores it in the register, pushes the sequence spooky, adds two to the value in the register and then pushes the sequence me.

Uses the latest version of the interpreter which hasn't been updated on TIO thus far.

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

tq, 16 bytes

?"spooky"?+2"me"

Explanation

# Define an array with 4 items
?                # First item: input
 "spooky"        # Second item: "spooky"
         ?+2     # Third item: input + 2
            "me" # Fourth item: "me"

# Print without a separator
```
\$\endgroup\$
1
  • \$\begingroup\$ I may start trying to make it a golfing language as well. I am thinking about adding increment-by-2 and length-2 strings. \$\endgroup\$
    – user85052
    Jan 18, 2020 at 7:34
1
\$\begingroup\$

W d, 14 bytes

♠╚z[·7♦÷U# 1╘╖

Explanation

Uncompressed:

"a"spooky"a2+"me"
""                 % Push an empty string for the first operand to render
  a                % The 1st operand
   "spooky"        % Push "spooky"
           a2+     % The 1st operand + 2
              "me" % Push me
\$\endgroup\$
1
\$\begingroup\$

BRASCA, 27 bytes

ig:an`ykoops`[o]A}}n`em`[o]

Try it online!

Explanation

<implicit input>             - Push STDIN on the stack
ig                           - Turn the codepoints of 0-9 into 0-9, and concatenate stack
  :a                         - Store a copy into register A
    n                        - Print the original (this disables implicit output)
     `ykoops`[o]             - Push and print "spooky"
                A}}          - Get the copy from register A and increment twice
                   n         - Print the incremented copy.
                    `em`[o]  - Push and print "me"
\$\endgroup\$
1
\$\begingroup\$

Swift, 26 bytes

{n in"\(n)spooky\(n+2)me"}

TIO link

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

Python 3, 28 bytes

lambda n:f'{n}spooky{n+2}me'

Try it online!

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

QBasic, 52 bytes

INPUT n
?MID$(STR$(n),2)"spooky"MID$(STR$(n+2),2)"me

Try it at Archive.org.

Explanation

QBasic's annoying number-to-string formatting is on full display here. Printing a number directly adds a leading and trailing space, so that's out. PRINT USING seems tailored for fixed-width columns and doesn't do well with numbers of different lengths. STR$(n) is a little better: it only adds a leading space, which we can remove by taking a substring starting at the second character with MID$.

INPUT n                                       Get a number from the user
?                                             Print
 MID$(STR$(n),2)                              The number w/o leading space
                "spooky"                      That string
                        MID$(STR$(n+2),2)     The number + 2 w/o leading space
                                         "me  That string (close-quote implied)
\$\endgroup\$
1
\$\begingroup\$

Rust, 37 33 bytes

Thanks @xigoi for tip on removing i32 type signature for n

|n|{print!("{}spooky{}me",n,n+2)}

Try it Online!

\$\endgroup\$
2
  • \$\begingroup\$ You don't need the :i32. \$\endgroup\$
    – xigoi
    Nov 3, 2021 at 14:41
  • \$\begingroup\$ cool i added it \$\endgroup\$
    – Hydrazer
    Nov 3, 2021 at 22:45
1
\$\begingroup\$

Zsh, 21 20 bytes

<<<$1spooky$[$1+2]me

try it online!

\$\endgroup\$
2
  • \$\begingroup\$ What's the \​ for? \$\endgroup\$
    – pxeger
    Nov 2, 2021 at 16:27
  • \$\begingroup\$ Huh. I thought the shell needed it. Thanks \$\endgroup\$
    – roblogic
    Nov 4, 2021 at 2:58
1
\$\begingroup\$

Seriously, 20 bytes

"me",;⌐@"spooky"@kεj

Since this challenge partially inspired this language, I figured I should go ahead and add a solution. Try it online!

\$\endgroup\$
2
  • \$\begingroup\$ A golfing language partially based on this challenge got 20 whole bytes? \$\endgroup\$
    – Cyoce
    Feb 23, 2016 at 6:31
  • \$\begingroup\$ @Cyoce I still haven't implemented the parts of the language that were inspired by this challenge (raw strings mode). \$\endgroup\$
    – user45941
    Feb 23, 2016 at 6:36
1
\$\begingroup\$

Whitespace, 142 bytes

[S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][T  N
S T _Print_as_integer][S S S T  T   T   N
_Push_7_y][S S T    T   T   T   N
_Push_-7_k][S S T   T   T   N
_Push_-3_o][S N
S _Duplicate__o][S S T  T   S N
_Push_-2_p][S S S T N
_Push_1_s][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_top][N
T   S S N
_Jump_to_Label_DONE_if_0][S S S T   T   T   S S T   S N
_Push_constant_114][T   S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_DONE][T   T   T   _Retrieve_input][S S S T    S N
_Push_2][T  S S S _Add][T   N
S T _Print_as_integer][S S S T  T   S T T   S T N
_Push_109_m][T  N
S S _Print_as_character][S S S T    T   S S T   S T N
_Push_101_e][T  N
S S _Print_as_character]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.

Try it online (with raw spaces, tabs and new-lines only).

Explanation in pseudo-code:

Push 0
Integer n = STDIN as number
Print n as integer to STDOUT
Push codepoint-integers c for "ykoops", each lowered by 114
Start LOOP:
  If top == 0: Go to function DONE
  Add 114 to the top c
  Print c as character to STDOUT
  Go to next iteration of LOOP

function DONE:
  Print n as integer to STDOUT
  Print "me" as characters to STDOUT
  (stop the program implicitly with an error: no exit defined)

The constant 114 is generated by this Java program, based on this Whitespace tip of mine.

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

Fig, \$17\log_{256}(96)\approx\$ 13.993 bytes

%"%spooky%me"$w}}

Try it online!

Sadly, "%spooky%me" is incompressible in Fig.

%"%spooky%me"$w}}
               }} # Increment twice
              w   # Wrap it in a list with the original number
             $    # Reverse the list
%"%spooky%me"     # Replace all '%' in "%spooky%me" with the elements in ^ 
\$\endgroup\$
1
\$\begingroup\$

Rattle, 23 bytes

\&spooky&me|Ig0bb1+2bb2

Try it Online!

Explanation

           |                 everything before this is input
\                            as input, take an input string
 &spooky                     ...and "spooky" (hard-coded)
        &me                  ...and "me" (hard-coded)
            I                split input list and store in consecutive memory slots
             g0              get the first element
               b             add this to the print buffer
                b1           add the element in memory slot 1 ("spooky")     
                  +2         add 2 to the top of the stack
                    b        add the top of the stack to the print buffer
                     b2      add "me" to the print buffer (buffer output implicitly)           
\$\endgroup\$
1
\$\begingroup\$

Arturo, 25 bytes

$[n]->~"|n|spooky|n+2|me"

Try it

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

Thunno J, \$ 19 \log_{256}(96) \approx \$ 16 bytes

(actually 15.64 bytes but the leaderboard doesn't take floats)

D2+"spooky"s"me"ZMr

Attempt This Online!

Explanation:

D2+"spooky"s"me"ZMr   # Implicit input
D2+                   # Duplicate and add 2
   "spooky"s          # Push "spooky" and swap
            "me"      # Push "me"
                ZMr   # Push the stack, reversed
                      # J flag joins by ""
                      # Implicit output
\$\endgroup\$
1
\$\begingroup\$

Thunno 2 j, 10 bytes

ƙ`me+‘ọṣ‘$

Attempt This Online!

Explanation

ƙ`me+‘ọṣ‘$  # Implicit input
ƙ           # Increment the input twice
 `me+       # Append the string "me"
     ‘ọṣ‘   # Push compressed string "spooky"
         $  # Push the input again
            # Implicit output of joined stack
\$\endgroup\$
1
\$\begingroup\$

Uiua, 17 bytes

$"_spooky_me"∶+2.

Try it!

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

MATLAB, 33 bytes

@(x)fprintf('%dspooky%dme',x,x+2)

Pretty self explanatory. Tried a few ways and this was the shortest I could find.

You should be able to run this with the Octave online interpreter.

\$\endgroup\$

Your Answer

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