Halloween Golf: The 2spooky4me Challenge!

Question

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 code-golf, 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>

Answer 1

gs2, 15 bytes

I outgolfed Dennis!

CP437:

spooky•me♣╨V↕0B

Hex dump:

73 70 6f 6f 6b 79 07 6d 65 05 d0 56 12 30 42

At the start of the program, STDIN is pushed (e.g. the string "3") and stored in variable A. The first ten bytes of the program push two strings, "spooky" and "me", to the stack. Then:

• d0 pushes variable A.
• 56 parses it as a number.
• 12 30 increments it by two.
• 42 swaps the top two elements on the stack, leaving "3" "spooky" 5 "me".

The final stack is printed as 3spooky5me.

Answer 2

GS2, 17 bytes

56 40 27 27 04 73 70 6F 6F 6B 79 05 42 04 6D 65 05

I CAN'T OUTGOLF DENNIS HELP

Answer 3

Stuck, 17 bytes

i_2+"spooky";"me"

EDIT: GUESS YOU COULD SAY I'M STUCK AT 17 BYTES

Answer 4

GolfScript, 17 bytes

~.2+"spooky"\"me"

Try it online on Web GolfScript.

How it works

~        # Evaluate the input.
.2+      # Push a copy and add 2.
"spooky" # Push that string.
\        # Swap it with the computed sum.
"me"     # Push that string.

Answer 5

Chef, 414 bytes

S.

Ingredients.
g i
2 g t
115 l s
112 l p
111 l o
107 l k
121 l y
109 l m
101 l e

Method.
Take i from refrigerator.Put e into mixing bowl.Put m into mixing bowl.Put i into mixing bowl.Add t.Put y into mixing bowl.Put k into mixing bowl.Put o into mixing bowl.Put o into mixing bowl.Put p into mixing bowl.Put s into mixing bowl.Put i into mixing bowl.Pour contents of mixing bowl into the baking dish.

Serves 1.

A recipe for disaster. Do not try this at home.

Answer 6

CJam, 18 bytes

ri_2+"spooky"\"me"

Try it online.

Answer 7

Pyth - 17 bytes

s[Q"spooky"hhQ"me

Try it online here.

Answer 8

TeaScript, 18 bytes

x+`spooky${x+2}me`

Unfortunately this string can't be compressed so this is basically as short as it will get

Answer 9

Pip, 18 bytes

Looks like I'm in the second tier of golfing languages here. :^P

[a"spooky"a+2"me"]

Takes the number as a command-line argument and puts the appropriate elements in an array, which is joined together and autoprinted at the end of the program.

Answer 10

dc, 20 bytes

?dn[spooky]P2+n[me]P

Answer 11

Japt, 17 16 bytes

U+"spooky{U+2}me

Japt (Javascript shortened) is a language of my invention. It is newer than this challenge; thus, this answer is non-competing. Unlike my other seven unpublished languages, this one has an actual interpreter that is currently being developed and is already partially working.

I wanted to post this because I like how it's the same length as all the existing first-place second-place answers. Here's how it works:

U+"spooky{U+2}me"    implicit: [U,V,W,X,Y,Z] = eval(input)
U+                   input +
  "spooky     me"     this string
         {U+2}         with input+2 inserted here
                     implicit: output last expression

And there you have it. The spec for all functionality used here was finalized on Oct 29th; nothing was changed to make this answer any shorter. Here's the interpreter, as promised.

Answer 12

Gol><>, 21 bytes

I:n"emykoops"6Ro{2+nH

I guess I'm... tied with Perl? Try it online.

I:n            Input n, output n
"emykoops"     Push chars
6Ro            Output top 6 chars (spooky)
{2+n           Output n+2
H              Output stack and halt (me)

Answer 13

Vitsy, 21 Bytes

Note: the Z command was made after this challenge began, but was not made for this challenge.

VVN"ykoops"ZV2+N"em"Z
V                      Grab the top item of the stack (the input) and make it a
                       global variable.
 V                     Call it up - push the global variable to the top of the stack.
  N                    Output it as a number.
   "ykoops"            Push 'spooky' to the stack.
           Z           Output it all.
            V2+N       Call the global variable again, add two, then output as num.
                "em"Z  Push 'me' to the stack and output it all.

More spoopy variation using multiple stacks (27 Bytes):

&"ykoops"&"em"?DN?Z??2+N??Z

&                           Make a new stack and move to it.
 "ykoops"                   Push 'spooky' to the current stack.
         &"em"              Do the last to things with 'me'.
              ?             Move over a stack.
               DN           Output the input.
                 ?Z         Move over a stack (the one with 'spooky') and print it.
                   ??       Move back to the original stack.
                     2+N    Add 2 to the input and output it as a number.
                        ??Z Move to the stack with 'me' in it and print it.

Try it online!

Answer 14

Julia, 23 bytes

n->"$(n)spooky$(n+2)me"

This creates an unnamed lambda function that accepts an integer and returns a string. The output is constructed using Julia's string interpolation.

Answer 15

05AB1E, 14 10 bytes

DÌs’ÿæªÿme

Try it online.

Non-competing since 05AB1E is newer than this challenge.

Explanation

DÌs’ÿæªÿme

D                get input n and duplicate it
 Ì               increment by 2
  s              Swap. Stack is now [n+2, n].
   ’ÿæªÿme       Compressed string that expands to "ÿspookyÿme". The first ÿ is then replaced by n and the second by n+2.

Answer 16

Javascript(ES6) 23 21 Bytes

A simple function that will be crushed by golfing lanqs:

_=>_+`spooky${_+2}me` 

_=>`${_}spooky${_+2}me`

Special thanks to ETHproductions for saving 2 bytes

Answer 17

Ruby, 25 bytes

->n{"#{n}spooky#{n+2}me"}

This creates an unnamed lambda that accepts an integer and returns a string. The string is constructed using Ruby's string interpolation.

Answer 18

APL, 25 22 bytes

⍕,'spooky','me',⍨∘⍕2+⊢

This creates an unnamed monadic function train that accepts an integer on the left and returns a string.

Numeric values are converted to strings using ⍕. The array of strings is joined into a single string using ∊.

Try it online

Saved 3 bytes thanks to Thomas Kwa!

Answer 19

PHP, 55 47 46 42 34 bytes

<?=($a=$argv[1]).spooky.($a+2).me;

Accepts the number as command line input.

Credits :)

Thanks to manatwork for saving 4 bytes!

Thanks to insertusernamehere for saving 8 bytes!

Answer 20

Chaîne, 15 bytes

noncompeting, language postdates question

{i~}:-,}:{2+}me
{i~}            | input duplicate write
    :   :       | access dictionary with inner base-93 key
     -,}        | entry for "spooky"
         {2+}   | push 2, add previous two, write
             me | write me

Implicit output.

Answer 21

Python, 31 bytes

lambda n:"%dspooky%dme"%(n,n+2)

Ask and you shall receive.

Answer 22

Perl 5, 20 19 bytes

$\=spooky.($_+2).me

The code requires the -p switch. Thanks to @Xcali for golfing off 1 byte!

Try it online!

Answer 23

Lua for windows, 41 bytes

n=io.read()print(n.."spooky"..n+2 .."me")

test with lua for windows

it takes the input through io.read then stored in variable n then on the same line prints the variable n then "spooky" then n+2 finally it prints "me"

Answer 24

Mathematica, 45 27 bytes

Print[#,"spooky",#+2,"me"]&

g=ToString[#]<>"spooky"<>ToString[#+2]<>"me"&

Thanks to Martin Büttner for the significant improvement (and the warm welcome).

Answer 25

Simplex v.0.7, 20 bytes

Simplex simply isn't feeling golfy today. >_<

i@R"spooky"&IIR"me"g
i@                   ~~ take input and copy to register
  R"spooky"          ~~ write that string to the strip (increment byte after every character)
           &II       ~~ write the register (incremented twice) to the strip
              R"me"  ~~ write that string to the strip
                   g ~~ output the strip

Answer 26

C, 58 bytes

main(a,b)char**b;{printf("%sspooky%dme",*++b,atoi(*b)+2);}

atoi() may be unnecessary.

Answer 27

Minkolang 0.10, 49 bytes

I have no way to convert integers to strings (yet!), so this is much longer.

"me"nd2+(dl%"0"+$rl:d)"spooky"2g(dl%"0"+$rl:d)$O.

Try it here.

Explanation

(dl%"0"+$rl:d) does the job of converting an int to a string. If this were replaced by a single character (like Z), then my solution would be just 23 bytes.

"me"nd2+Z"spooky"2gZ$O.

nd takes an integer from input and duplicates it. 2+ adds 2 and 2g later gets the initial input and puts it on top of stack. $O. outputs the whole stack as integers and stops.

Answer 28

Rotor, 15 bytes

&"spooky"~2+"me

Language was created after the challenge. Does not work in the online interpreter (uses input eval.)

Answer 29

Cookie, 16 bytes (non-competing)

Note that the recent changes to the Github page were not made for this challenge, Cookie is still in development.

wŕspooky[r+2]me"

Explanation:

wŕspooky[r+2]me"
w                 start write command
 ŕ                take input
  spooky          write spooky
        [r+2]     compute input + 2
             me   write me
               "  close write command.

Answer 30

Jelly, non-competing

13 bytes This answer is non-competing, since the challenge predates the creation of Jelly.

+0,2ż“×¥X“ŀ`»

^{I CAN'T OUTGOLF QUARTATA HELP}

Try it online!

How it works

+0,2ż“×¥X“ŀ`»  Main link. Input: n

+0,2           Add [0, 2] to n, resulting in [n, n + 2].
     “×¥X“ŀ`»  Yield ['spooky, 'me'] by indexing into a dictionary.
    ż          Zip the results to left and right with each other.
               This yields [[n, 'spooky'], [n + 2, 'me']], which is flattened
               before printing.

Answer 31

Java 8, 24 bytes

n->n+"spooky"+(n+2)+"me"

That moment when Java is actually competitive... (and by competitive I mean top 40 :P)

Try it online!

Answer 32

Groovy, 24 22 bytes

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

Answer 33

Java, 39 35 bytes

n->"".format("%dspooky%dme",n,n+2);

A lambda expression that takes an int and returns a string.

Answer 34

Mouse, 25 bytes

?N:N.!"spooky"2N.+!"me"$

Ungolfed:

? N:         ~ Read an integer N from STDIN
N. !         ~ Write N to STDOUT
"spooky"     ~ String literals go straight to STDOUT
2 N. + !     ~ Print N+2
"me"
$            ~ End of program

Answer 35

Gema, 21 characters

*=*spooky@add{$0;2}me

Sample run:

bash-4.3$ echo -n 42 | gema '*=*spooky@add{$0;2}me'
42spooky44me

Answer 36

jq, 21 characters

(20 characters code + 1 character command line option.)

"\(.)spooky\(.+2)me"

Sample run:

bash-4.3$ jq -r '"\(.)spooky\(.+2)me"' <<< 42
42spooky44me

On-line test (Passing -r through URL is not supported – check Raw Output yourself.)

Answer 37

PowerShell, 31 30 29 bytes

param($x)"$x`spooky$($x+2)me"

Try it online!

Takes input $x, constructs and leaves a string on the pipeline with implicit output. The string is formed from $x spooky $x+2 me, with the trick being the ` that allows the variable name to be escaped to be just $x instead of $xspooky.

-1 byte thanks to Veskah.

Answer 38

Scala, 30 bytes

(n:Int)=>s"${n}spooky${n+2}me"

Answer 39

Jolf, 15 bytes

Try it here! I forgot about inline string interpolation until after @quartata posted his solution.

"¦jspooky¦+2jme

Explanation

"¦jspooky¦+2jme
"               string containing
 ¦j              the input,
   spooky        "spooky"
         ¦+2j    2 + the input,
             me  and "me"
                implicitly printed.

Answer 40

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

Answer 41

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!

Answer 42

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

Answer 43

Kotlin, 24 bytes

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

Try it online!

Answer 44

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.

Answer 45

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.

Answer 46

Wren, 31 bytes

Not special, just uses some formatting

Fn.new{|n|"%(n)spooky%(n+2)me"}

Try it online!

Answer 47

MarioLANG, 221 bytes

;>+>+>+>+>.>)
:"+"+"+"+"-"-
)++++++++.-:-
+++++++++--+-"
+++++++++.-+-.
+++++++++-.(--
+++++++++-+.--
+++++++++-++--
+++++++++.++--
++++++++++++--
++++++++++++--
++++++++++++--
++++++++++++--
+!+!+!+!+!+!.!
=#=#=#=#=#=#=#

Try it online!

Answer 48

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

Answer 49

Burlesque, 21 bytes

J2?+Cl"~spooky~me"jf~

Needs fixed stack layout. Not usable except as a stand-alone program. Otherwise use one of the versions below that are more generic.

Alternative versions:

"~spooky~me"jbxJ2?+_+f~ [24 bytes]
J"spooky"?+j2?+"me"?+?+ [24 bytes, too]

Answer 50

O, 20 bytes

j.o"spooky"o))o"me"o

Kinda long Try it online

j          Get input as Number
.          Clone the number to add to later
o          Print the number
"spooky"o  Print spooky
))o        Increment the input by two and print
"me"o      Print me

Answer 51

Bash, 24 bytes

echo $1spooky$(($1+2))me

Takes input as command line argument

Answer 52

JS (ES5) 41

Oh, ES6...

function(a){alert(a+"spooky"+(a+2)+"me")}

Answer 53

Coffeescript, 23 bytes

(n)->n+"spooky#{n+2}me"

Anonymous function that takes int n and returns <n>spooky<n+2>me.

Answer 54

C++11, 142 130 108 bytes

Self-imposed challenge: no C headers

#include<sstream>
#include<string>
[](int x){std::stringstream q;q<<x<<"spooky"<<x+2<<"me";return q.str();}

Thanks to Mego for saving a few bytes with the return logic everything.

Answer 55

C# 33 bytes

string s(n)=>$"{n}spooky{n+2}me";

Answer 56

Dart, 27 Bytes

t(n)=>'${n}spooky${n+2}me';

Unremarkable but competitive.

Answer 57

Carrot (version ^3), 14 bytes

#spooky(#+2)me

Explanation:

Carets ^ have now been made optional if you do not want to use commands. The # is the variable representing the input. Every instance of # is replaced with the value of input. Going to the parentheses, the expression inside the parentheses is evaluated and a number is returned.

Test it online here. Please note that this is not permalinked.

Answer 58

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

Answer 59

><>, 25 (+2) = 27 bytes

:n'emykoops'oooooo{2+noo;

Starting with a value (n) on top of the stack from -v (2 byte penalty). Explanation:

:            Duplicates top item on stack
 n           Pops and outputs top value on stack as number -> n
  'emykoops' Pushes each character onto the stack
   o         x5 Pops and outputs top value on stack as character -> "spooky"
    {        Shift stack leftwards making input value top value
     2       Pushes 2 on the stack
      +      Pops top 2 elements, sums them and pushes result
       n     Pops and outputs top value on stack as number -> n+2
        o    x2 Pops and outputs top value on stack as character -> "me"
         ;   Ends execution

Answer 60

pl, 12 bytes

_spooky_2┼me

Try it online.

Non-competing since pl was invented after this challenge.

Answer 61

Seriously, 20 bytes (non-competing)

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

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

Answer 62

F#, 33 bytes

fun n->printf"%ispooky%ime"n<|n+2

Answer 63

Squirrel, 25 bytes

@(n)n+"spooky"+(n+2)+"me"

Answer 64

D, 71 bytes

import std.string;string s(int i){return format("%sspooky%sme",i,i+2);}

More verbose than Java...

Answer 65

Jolf, 16 bytes

"%spooky%me"J+2J

Try it online.

Answer 66

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.

Answer 67

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

Answer 68

,,,, 18 bytes

:↓2+"spooky"↓↓"me"

Answer 69

Acc!!, 99 bytes

N
Write _
Write 115
Write 112
Write 111
Write 111
Write 107
Write 121
Write _+2
Write 109
Write 101

Try it online!

Answer 70

Implicit, 20 17 16 bytes

ì¯spooky]ì..ìme"

Try it online!

ì¯spooky]ì..ìme"
ì                 « implicit integer input, convert to string     »;
 ¯                « copy input to memory                          »;
  spooky          « push the ASCII character codes for each letter in `spooky` individually »;
        ]         « copy memory to stack                          »;
         ì        « convert string to integer                     »;
          ..      « increment twice                               »;
            ì     « and back to string                            »;
             me   « push character codes for `me`                 »;
               "  « stringify the entire stack                    »;

Answer 71

Python ≥ 3.6, 28 bytes

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

Try it online!

Makes use of formatted string literals, a feature that was introduced in Python 3.6.

Answer 72

SmileBASIC, 26 bytes

INPUT N?N;"spooky";N+2;"me

Answer 73

T-SQL, 40 bytes

SELECT CONCAT(n,'spooky',n+2,'me')FROM t

Input taken via a pre-existing table t with integer column n, per our input standards.

CONCAT does an implicit type conversion, otherwise I'd have to do something like CONVERT(n,varchar(9)).

Answer 74

MATL, 18 bytes

'spooky'yUQQV'me'v

Try it on MATL Online

Answer 75

OCL, 52 46 bytes

Function a b Print b+"spooky"+(b + 2)+"me" End

This one is pretty straight forward, I just wanted to show off an obscure language.

Edit: I found out you can omit the spaces between the pluses when doing concatenation, but not addition. Weird.

Answer 76

Pip, 23 bytes

(a:q)."spooky".a+2."me"

Try it online!

Answer 77

Stax, 14 bytes

ü╫2┐╚╘Wö»§W╟╛╨

Run and debug it at staxlang.xyz!

Unpacked (16 bytes)

.me;2+`tNCrf`,Wp
.me                 Literal "me"
   ;2+              Peek from input stack, push to stack, and add 2
      `tNCrf`       Literal "spooky"
             ,      Pop from input stack; push to stack
              Wp    Pop and print everything from the stack with no additional newlines

Answer 78

Pyramid Scheme, 624 bytes

   ^      ^      ^      ^     ^      ^      ^      ^      ^
  / \    / \    / \    / \   / \    / \    / \    / \    / \
 /set\  /out\  /out\  /out\ /out\  /out\  /out\  /out\  /out\
^-----^^-----^ -----^ -----^----- ^----- ^-----^ -----^ -----^
-    ^--    / \    / \    / \    / \    / \   /+\    / \    / \
    /#\    /chr\  /chr\  /chr\  /chr\  /chr\ ^---^  /chr\  /chr\
   ^---   ^----- ^----- ^----- ^----- ^-----/2\  - ^----- ^-----
  /l\    / \    / \    / \    / \    / \    ---   / \    / \
 /ine\  /115\  /112\  /111\  /107\  /121\        /109\  /101\
 -----  -----  -----  -----  -----  -----        -----  -----

Try it online!

Very straightforward. Gets an integer from input and saves it to the blank variable. Prints it. Prints "spooky". Prints blank+2. Prints "me". Follows the same pattern as Hello, World, for the most part.

Answer 79

Excel, 22 bytes

=A1&"spooky"&A1+2&"me"

Answer 80

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

Answer 81

Runic Enchantments, 18 bytes

i:2+"me"S9´334E{@

Try it online!

Saves 1 byte by using 9´334E to pull "spooky" out of the word dictionary. 8b*E for "me" is the same length.

Answer 82

Stax, 12 bytes

ïöeO¬‼3ì╡☻↔G

Run and debug it

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

Answer 83

Japt, 14 bytes

`èï`ri@°+T°

Try it

Japt, 13 bytes

+`spooky{+2}´

Try it

Answer 84

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

Answer 85

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.

Answer 86

O, 20 characters

Q"spooky"Q2+"me"+++p

Sample run:

bash-4.3$ o.sh 'Q"spooky"Q2+"me"+++p' <<< 42
42spooky44me

Answer 87

Fourier, 32 bytes

I~zo115a-3avaa-4a121az+2o109a-8a

Still using @isaacg's golfing algorithm ;)

Answer 88

Haskell, 38 bytes

a n=show(n)++"spooky"++show(n+2)++"me"

Defines a function named a that takes a Num n. Returns <n>spooky<n+2>me.

Answer 89

Clojure, 26 bytes

#(str %"spooky"(+ 2%)"me")

First post. It's a function, as required. I think I took as many liberties with the tokenizer as possible, but I don't know. Here it is in action in the REPL:

user=> #(str %"spooky"(+ 2%)"me")
#<user$eval1176$fn__1177 user$eval1176$fn__1177@2d2d2f69>
user=> (*1 55)
"55spooky57me"

Answer 90

Factor, 79 bytes

: f ( x -- ) dup 2 + [ number>string ] bi@ "spooky" swap "me" 4array concat . ;

First stab at it, just did it the obvious way.

Answer 91

Lua, 41 Bytes

There's this other lua answer, but it doesn't work anymore since lua 5.3. It will now print 2spooky4.0me Here comes a code working under all versions of lua, and who's still in 41 Bytes:

print(("%dspooky%dme"):format(...,...+2))