Snakes all around

Question

Challenge

The challenge is simple: print a snake.
You will get the length of the snake as input.
A snake of length 2 looks like this:

==(:)-

A snake of length 7 looks like this:

=======(:)-

In other words, the length of a snake is how many equal signs are before the head.

Usage

Let's say I made a C++ implementation and compiled it to ./getsnake.
I could run it like so:

$ ./getsnake 10
==========(:)-

Clarifications

• Standard loopholes are disallowed.
• You can get input and output in any acceptable way.
• You can assume all inputs given are positive integers.
• You may write a function instead of a regular program.

Answer 1

Hexagony, 33 bytes

Not gonna win, but still cool. Might be able to get golfed more.

Try it online!

Golfed:

61}?.$)@$j;(3<./;.}l/.400;5\j;.'\

Formatted:

    6 1 } ?
   . $ ) @ $
  j ; ( 3 < .
 / ; . } l / .
  4 0 0 ; 5 \
   j ; . ' \
    . . . .

Colored (Made using Timwi's Hexagony Colorer)

Explanation:

Loop, print out "=" until the counter reaches 0.

    6 1 } ?
   . $ . . $
  . . ( . . .
 / . . } . . .
  . . . ; . .
   . . . ' .
    . . . .

Print "("

    . . . .
   . . . . .
  . . . . . .
 / ; . . . . .
  4 . . . . .
   j . . . .
    . . . .

Print ":"

    . . . .
   . . . . .
  . ; ( 3 < .
 . . . } l / .
  . . . . . .
   . . . . .
    . . . .

Print ")"

    . . . .
   . . . . .
  j . . . . .
 . . . . . . .
  . . . ; 5 \
   . . . . \
    . . . .

The above values were generated using a simple python script. However, I kind of ran out of room for the "-". So, I had to resort to more advanced tricks.

When the program prints out ")", the value of the cell isn't 41, it's 1065. Hexagony just mods the value when printing. As it turns out, (1065*1000+4)%256=44, just one away from 45, the ascii value for "-". Then, I just increment, print, and insert a @ somewhere after printing.

    . . . .
   . $ ) @ $
  j . . 3 . .
 / . . } . . .
  4 0 0 . 5 \
   . ; . . \
    . . . .

Answer 2

Cinnamon Gum, 7 bytes

0000000: 7043 dc95 6d4f ce                        pC..mO.

Try it online.

Would have been 6 bytes with the old p syntax :/

Explanation

Decompresses to p~=~(:)-, the p stage then simply reads input and repeats the = n times.

Answer 3

Brian & Chuck, 31 bytes

,{-?>}-):(=?
#}<<.{?_<.<.<.<.<.

Input in the form of a byte value, so e.g. input ! gives a snake of length 33.

Try it online!

It's been a while...

Explanation

A quick Brian & Chuck primer:

• The first line of the program is Brian, the second is Chuck.
• Brian and Chuck are two Brainfuck-like instances. The main catch is that Chuck's program is Brian's tape and vice versa. The tape heads/instruction pointers start on the first cell of each tape and execution starts on Brian.
• As for the commands, there are a few differences. Only Brian can use , (input) and only Chuck can use . (output). In addition to < and > there are { and } which move the tape head up to the next zero cell (or in the case of { to the left end of the tape if there is no zero cell on the way). Instead of [...], the only control flow is ? which switches control to the other instance if the current cell is non-zero. The first executed instruction on the other cell is the one after the condition. And finally, _ is just an alias for null-bytes, for convenience.

Now the code. Brian starts with this:

,{-?

This reads the input into Chuck's first cell, then moves the tape head to the left with { (does nothing right now) and decrements the input with - before switching control for Chuck if the value is still non-zero. This begins the main loop. Chuck then runs this bit:

}<<.{?

This moves the tape head on Brian to the very end, moves two cells left onto the = and prints it before the tape head all the way to the left and switching control back to Brian. This is how loops generally work in B&C.

Once the input has been reduced to zero, the ? on Brian's tape will do nothing. Then Brian executes this part:

>}-):(=?

The ):(= are no-ops, so the actual code is just >}-?. We move off the zero cell with >, move up to _ with }, decrement it to make it non-zero and switch to Chuck with ?. Then the last bit on Chuck is run:

<.<.<.<.<.

This simply prints the five characters in front of Chuck, i.e. =(:)-. Note that we need to print another = since the main loop is only executed N-1 times for input N.

Answer 4

V, 8 bytes

Àé=A(:)-

Try it online!

V uses the "Latin1" encoding.

Explanation:

À        "Arg1 times:
 é=      "Insert an '='
   A(:)- "Append the head

Answer 5

Retina, 10 bytes

.+
$*=(:)-

Try it online!

This is a simple regex substitution.

It matches .+ which matches the whole input, and then substitutes it with $*=(;)-.

The $* is a feature unique in Retina: it is the character-repetition special operator.

For example, 5$*x would become xxxxx.

In the case that the previous argument is absent, the whole match is used as the default argument.

Answer 6

Python, 21 bytes

lambda n:"="*n+"(:)-"

Ideone it!

Answer 7

Haskell, 25 bytes

f n=('='<$[1..n])++"(:)-"

'='<$[1..n] is equivalent to replicate n '='.

Answer 8

Java 8, 52 bytes

n->new String(new char[n]).replace("\0","=")+"(:)-";

Test suite. (Compile > Execute)

Credits.

teh traditional way, 61 54 53 bytes

7 bytes thanks to Kevin Cruijssen.

1 byte thanks to Dom Hastings.

n->{String s="";for(;n-->0;)s+="=";return s+"(:)-";};

Answer 9

Jelly, 9 bytes

”=x;“(:)-

Try it online!

”=x;“(:)-
”=          '='
  x         repeat (argument) that many times
   ;        append
    “(:)-   "(:)-"

Answer 10

C, 38

f(n){for(;n--;printf(n?"=":"=(:)-"));}

Try it on ideone.

Answer 11

05AB1E, 10 9 bytes

'=×"ÿ(:)-

Explanation

'=         # push equal-sign
  ×        # repeat input nr of times
   "ÿ(:)-  # interpolate snake body with head as a string
           # implicitly display

Try it online

1 byte saved thanks to Adnan.

Answer 12

Javascript, 23 bytes

n=>"=".repeat(n)+"(:)-"

Answer 13

C#, 28 bytes

n=>new string('=',n)+"(:)-";

Answer 14

Python, 24 bytes.

print"="*input()+"(:)-"

input() gets input from user

*, when used on strings and an integer, creates a new string, which is made of joined copies of the original. For example: "hello "*3 outputs hello hello hello.

By multiplying = and input(), you get a string of = the length that the user specifies.

Using + joins two strings, in this case, our body "=…=" with our head, "(:)-" to make the snake.

print outputs the result.

Answer 15

GolfScript, 11 10 bytes

~"="*"(:)-"

Multiplies "=" by input, and adds head.

-1 thanks to Leaky Nun

Answer 16

Mathematica, 21 20 bytes

"="~Table~#<>"(:)-"&

Anonymous function. Takes a number n as input, and returns a snake of length n as output. "="~Table~# generates a list {"=", "=", ..., "="} of length n, and <>"(:)-" concatenates the list's elements and appends "(:)-" to the resulting string.

Answer 17

R, 32 27 bytes

This solution is pretty straightforward, rep function repeats the first element ("=") scan() times, which is in fact the user's input.

a=scan();cat(rep("=",a),"(:)-")

EDIT:

cat(rep("=",scan()),"(:)-")

Slighly shorter answer, using scan() directly.

Alternatively,

cat(rep("=",scan()),"(:)-",sep="")

for a non-chopped snake (34 bytes)

Answer 18

Batch, 68 bytes

@set h=(:)-
@for /l %%i in (1,1,%1)do @call set h==%%h%%
@echo %h%

Answer 19

CJam, 13 11 bytes

qi'=*"(:)-"

Test it here.

-2 bytes thanks to quartata

Answer 20

Perl 6,  16 15  12 bytes

{"{'='x$_}(:)-"}
{'='x$_~'(:)-'}
'='x*~'(:)-'

Explanation:

'=' x * # ｢=｣ string repeated by the only parameter ｢*｣
~        # concatenated with
'(:)-'   # the head

Usage:

# store it in the lexical namespace
my &snake = '='x*~'(:)-';

put snake 10;

# put ^5 .map: &snake;
put ^5 .map: '='x*~'(:)-';

==========(:)-
(:)- =(:)- ==(:)- ===(:)- ====(:)- =====(:)-

Answer 21

JAISBaL, 9 bytes

t=*Qb(:)-

Verbose:

# \# enable verbose parsing #\
push1 =        \# push = onto the stack #\
mul            \# multiply the top two values of the stack #\
popout         \# pop the top value of a stack and print it #\
print4 (:)-    \# print (:)- #\

Tested with JAISBaL-0.0.7 (The compiled .jar was just pushed, but the source has been up on git for a while)

Answer 22

PowerShell v2+, 19 bytes

'='*$args[0]+'(:)-'

Full program. Takes input $args[0], uses string multiplication to construct the body, then string concatenation to tack on the head.

PS C:\Tools\Scripts\golfing> .\snakes-all-around.ps1 7
=======(:)-

PS C:\Tools\Scripts\golfing> .\snakes-all-around.ps1 77
=============================================================================(:)-

Answer 23

C, 46 45 43 bytes

saved 2 bytes thanks to owacoder! saved 3 bytes thanks to rici!

f(n){while(4-printf("=\0(:)-"+2*!n--));}

Try it on Ideone!

Answer 24

Cheddar, 15 bytes (noncompeting)

n->'='*n+'(:)-'

A straightforward answer.

Answer 25

Sesos, 11 bytes

Hexdump:

0000000: aaaa5e a0f7b4 ed4cee 5d3b                         ..^....L.];

Try it online!

Assembler:

set numin
add 61
fwd 1
get
jmp,sub 1,rwd 1,put,fwd 1,jnz
add 40,put
rwd 1,sub 3,put
fwd 1,add 1,put
add 4,put

Answer 26

K, 17 Bytes

{,[x#"=";"(:)-"]}

Example;

f:{,[x#"=";"(:)-"]}
-1(f'!10);          /print out the result of calling f where x is 0 1 2 3 4 5....
(:)-
=(:)-
==(:)-
===(:)-
====(:)-
=====(:)-
======(:)-
=======(:)-
========(:)-
=========(:)-

Explanation;

{}                 /function x is implicit and is an int
x#"="              /take (#) x of "=" --> so 3#"=" gives "==="
,[x#"=";"(:)-"]    /comma is a join that takes 2 args --> ,[x;y] gives the concatination of x and y --> "a","abc" is the same as ,["a";"abc"] and gives "aabc"

Answer 27

Perl, 16 + 1 (-p flag) = 17 bytes

$_="="x$_."(:)-"

Needs -p flag, so run with :

perl -pe '$_="="x$_."(:)-"'

Answer 28

Minkolang 0.15, 12 bytes

"=(:)-"nD$O.

Try it here!

Explanation

"=(:)-"         Push this to the stack in reverse order - ["-",")",":","(","="]
       n        Take number from input
        D       Pop k and duplicate top of stack (the "=") k times
         $O.    Output whole stack as characters and stop.

Answer 29

Befunge-98, 24 bytes

Takes numerical input from the user, then prints the snake.

'=&:00pk:00gk,"-):("4k,@

Answer 30

Matlab / Octave, 22 bytes

@(n)[~(1:n)+61 '(:)-']

This is an anonymous function.

Try it on Ideone.

Explanation

Assume n= 5.

1:n produces the row vector [1 2 3 4 5].

~(1:n) negates each entry, so it gives [0 0 0 0 0].

...+61 adds 61 to each entry, so it gives [61 61 61 61 61]. 61 is the ASCII value of character =.

[... '(:)-'] concatenates that with the string '(:)-'. This automatically converts [61 61 61 61 61] into the string '=====' before the concatenation.