12
\$\begingroup\$

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.
\$\endgroup\$
  • 8
    \$\begingroup\$ It's kinda useless to leave a challenge in the Sandbox for only half an hour. You did get some feedback, but it's usually best to leave it in the Sandbox for 24-72 hours. (Also, you should either flesh out the "Origins" part or remove it.) \$\endgroup\$ – El'endia Starman Jul 31 '16 at 20:15
  • \$\begingroup\$ Is a function enough or do you want a full program? \$\endgroup\$ – betseg Jul 31 '16 at 20:17
  • \$\begingroup\$ @betseg function is enough \$\endgroup\$ – InitializeSahib Jul 31 '16 at 20:17
  • 4
    \$\begingroup\$ I'm afraid all My Squiggly Lamp answers are effortlessly portable to this. \$\endgroup\$ – manatwork Aug 1 '16 at 12:49
  • 3
    \$\begingroup\$ Negative integers should cause the snake to swallow itself. \$\endgroup\$ – GuitarPicker Aug 2 '16 at 12:35

89 Answers 89

18
\$\begingroup\$

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)

u found da secret snek! =======(:)-

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 \
   . ; . . \
    . . . .
\$\endgroup\$
  • \$\begingroup\$ How can it be called a programming language when .j4/; is ... Print "("??? Which part of .j4/; is the print and which part is the string to print? \$\endgroup\$ – Fogmeister Aug 1 '16 at 23:36
  • 2
    \$\begingroup\$ @Fogmeister [Part 1/2] In Hexagony, any alphabetical character sets the value of the current memory cell to the ascii value of that character. "j" has an ascii value of 106, so that is what the memory is set to. Also, and numerical characters multiply the value of the current cell by 10, then add themselves to it (this allows for easy construction of numbers, like the 61 at the beginning. \$\endgroup\$ – Blue Aug 2 '16 at 0:23
  • 3
    \$\begingroup\$ [Part 2/2] So, j4 sets the memory cell to 1064. When the IP reaches the "/", it gets reflected into ";", which prints out the ascii character corresponding to the current memory cell % 256. 1064%256=40, the ascii value for "(". I hope this answers your question. \$\endgroup\$ – Blue Aug 2 '16 at 0:25
  • \$\begingroup\$ thanks. Yeah it does. I guess this is more of a language to use as a way of testing your brain. Rather than a way to write programmes then? Interesting. \$\endgroup\$ – Fogmeister Aug 2 '16 at 0:27
  • \$\begingroup\$ @Fogmeister there are many esoteric programming languages that are more brain twisting exercises than useful for doing real work, although they CAN do real work if you try hard enough. \$\endgroup\$ – Sparr Aug 9 '16 at 1:53
12
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ Can you link to language spec for this? \$\endgroup\$ – Robert Fraser Aug 1 '16 at 5:07
  • \$\begingroup\$ @RobertFraser I don't have a formal specification or any documentation currently, but you can check out the source at the GitHub repo: github.com/quartata/cinnamon-gum \$\endgroup\$ – a spaghetto Aug 1 '16 at 12:52
12
\$\begingroup\$

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.

\$\endgroup\$
  • 10
    \$\begingroup\$ Congrats on 100k \$\endgroup\$ – Insane Aug 1 '16 at 10:47
10
\$\begingroup\$

V, 8 bytes

Àé=A(:)-

Try it online!

V uses the "Latin1" encoding.

Explanation:

À        "Arg1 times:
 é=      "Insert an '='
   A(:)- "Append the head
\$\endgroup\$
  • \$\begingroup\$ I count 10 bytes \$\endgroup\$ – Zwei Aug 1 '16 at 6:32
  • 2
    \$\begingroup\$ @zwei see my edit. \$\endgroup\$ – DJMcMayhem Aug 1 '16 at 6:37
  • \$\begingroup\$ Got it! That's better. \$\endgroup\$ – Zwei Aug 1 '16 at 6:39
6
\$\begingroup\$

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.

\$\endgroup\$
5
\$\begingroup\$

Python, 21 bytes

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

Ideone it!

\$\endgroup\$
  • \$\begingroup\$ You can cut 3 bytes by doing: "="*input()+"(:)-" \$\endgroup\$ – gowrath Aug 29 '16 at 16:57
  • \$\begingroup\$ @gowrath Then it won't be printing anything \$\endgroup\$ – Leaky Nun Aug 29 '16 at 18:31
  • \$\begingroup\$ It'll output it if you're in the interpreter no? Op said you can get output in any way. \$\endgroup\$ – gowrath Aug 29 '16 at 18:59
  • \$\begingroup\$ @gowrath You can't assume that we're in REPL \$\endgroup\$ – Leaky Nun Aug 29 '16 at 19:00
  • \$\begingroup\$ Is that a general rule for code golfing? New here :) \$\endgroup\$ – gowrath Aug 29 '16 at 19:02
5
\$\begingroup\$

Haskell, 25 bytes

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

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

\$\endgroup\$
5
\$\begingroup\$

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+"(:)-";};
\$\endgroup\$
  • \$\begingroup\$ +1 Oh, and for the traditional one: for(int i=0;i<n;i++) can be golfed to for(;n>0;n--), since you don't need the input for anything else than the for-loop anyway. \$\endgroup\$ – Kevin Cruijssen Aug 1 '16 at 7:00
  • \$\begingroup\$ @KevinCruijssen Thanks, edited \$\endgroup\$ – Leaky Nun Aug 1 '16 at 7:04
  • \$\begingroup\$ Testing via the link you provided it looks like you can change the for loop to: for(;n-->0;) to save another byte! \$\endgroup\$ – Dom Hastings Aug 1 '16 at 15:58
  • \$\begingroup\$ @DomHastings edited with thanks \$\endgroup\$ – Leaky Nun Aug 1 '16 at 16:18
4
\$\begingroup\$

Jelly, 9 bytes

”=x;“(:)-

Try it online!

”=x;“(:)-
”=          '='
  x         repeat (argument) that many times
   ;        append
    “(:)-   "(:)-"
\$\endgroup\$
4
\$\begingroup\$

C, 38

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

Try it on ideone.

\$\endgroup\$
  • 1
    \$\begingroup\$ Not shorter, but cooler: f(n){~-printf(n?"=":"=(:)-")||f(~-n);}. \$\endgroup\$ – orlp Aug 1 '16 at 0:45
  • \$\begingroup\$ f(n){for(;n;printf(n--?"=":"(:)-"));} for -1. \$\endgroup\$ – Erik the Outgolfer Aug 1 '16 at 17:59
  • \$\begingroup\$ @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ - That doesn't output the head. \$\endgroup\$ – owacoder Aug 1 '16 at 18:20
  • \$\begingroup\$ @owacoder Well, C is not my primary language... \$\endgroup\$ – Erik the Outgolfer Aug 1 '16 at 18:33
  • 1
    \$\begingroup\$ @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ And that's why you shouldn't post untested golfing suggestions (especially if it would have taken you 5 seconds to test your suggestion with the link provided in the answer). \$\endgroup\$ – Martin Ender Aug 1 '16 at 18:40
4
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ '=×"ÿ(:)- for 9 bytes :). This uses string interpolation. \$\endgroup\$ – Adnan Jul 31 '16 at 20:30
  • 1
    \$\begingroup\$ @Adnan: Aaah, so that's what ÿ does :) \$\endgroup\$ – Emigna Jul 31 '16 at 20:31
4
\$\begingroup\$

Javascript, 23 bytes

n=>"=".repeat(n)+"(:)-"
\$\endgroup\$
  • 1
    \$\begingroup\$ I was just about to post exactly that code! Beat me to it! Have an upvote \$\endgroup\$ – MayorMonty Jul 31 '16 at 22:18
  • \$\begingroup\$ Today I learned about arrow functions. Thank you. Didn't know that was a thing \$\endgroup\$ – bobkingof12vs Aug 2 '16 at 21:55
  • \$\begingroup\$ How do you call that instance of the function? I just tried n(3) and received a Uncaught ReferenceError: n is not defined error... \$\endgroup\$ – WallyWest Aug 9 '16 at 0:46
  • \$\begingroup\$ @WallyWest - try x=n=>"=".repeat(n)+"(:)-"; x(7); \$\endgroup\$ – eithed Aug 9 '16 at 6:11
  • \$\begingroup\$ @eithedog Then shouldn't the answer have the initial x= and changed to 25 chars? \$\endgroup\$ – WallyWest Aug 9 '16 at 6:36
4
\$\begingroup\$

C#, 28 bytes

n=>new string('=',n)+"(:)-";
\$\endgroup\$
  • \$\begingroup\$ im always interested by the lambda snippets. how can you even run this? \$\endgroup\$ – downrep_nation Aug 1 '16 at 19:54
  • \$\begingroup\$ @downrep_nation it takes in an int and automatically returns the string because it is only one statement \$\endgroup\$ – TheLethalCoder Aug 2 '16 at 7:58
  • \$\begingroup\$ The answer should be a full program or a function, not just a snippet. So this answer seems incomplete. \$\endgroup\$ – raznagul Aug 2 '16 at 14:57
  • \$\begingroup\$ @raznagul This is an anonymous function therefore it is complete \$\endgroup\$ – TheLethalCoder Aug 2 '16 at 14:59
  • \$\begingroup\$ @TheLethalCoder: Maybe try online link would help to understand it. (csharppad.com) \$\endgroup\$ – raznagul Aug 2 '16 at 15:12
4
\$\begingroup\$

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.

\$\endgroup\$
3
\$\begingroup\$

GolfScript, 11 10 bytes

~"="*"(:)-"

Multiplies "=" by input, and adds head.

-1 thanks to Leaky Nun

\$\endgroup\$
3
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ golfable by one more byte: "="~Table~#<>"(:)-"& \$\endgroup\$ – LLlAMnYP Aug 2 '16 at 7:43
3
\$\begingroup\$

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)

\$\endgroup\$
  • \$\begingroup\$ I would say the sep="" is needed here, otherwise your snake looks like the one that traversed the railway: = = = (:)-. \$\endgroup\$ – manatwork Aug 2 '16 at 11:09
  • \$\begingroup\$ The snake produced here is indeed a bit minced, but OP's consigns only state that the length of the snake is the number of equal signs before the head. I will add the sep as a side note nonetheless ;) \$\endgroup\$ – Frédéric Aug 2 '16 at 11:13
3
\$\begingroup\$

Batch, 68 bytes

@set h=(:)-
@for /l %%i in (1,1,%1)do @call set h==%%h%%
@echo %h%
\$\endgroup\$
2
\$\begingroup\$

CJam, 13 11 bytes

qi'=*"(:)-"

Test it here.

-2 bytes thanks to quartata

\$\endgroup\$
  • \$\begingroup\$ You can do '=* instead of {'=}*. \$\endgroup\$ – a spaghetto Jul 31 '16 at 20:46
2
\$\begingroup\$

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*~'(:)-';
==========(:)-
(:)- =(:)- ==(:)- ===(:)- ====(:)- =====(:)-
\$\endgroup\$
2
\$\begingroup\$

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)

\$\endgroup\$
  • \$\begingroup\$ Use a # before the language name to make it look like everybody else's. \$\endgroup\$ – Michael Klein Jul 31 '16 at 22:42
  • \$\begingroup\$ @MichaelKlein okay \$\endgroup\$ – Socratic Phoenix Jul 31 '16 at 22:57
2
\$\begingroup\$

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
=============================================================================(:)-
\$\endgroup\$
  • \$\begingroup\$ Kudos to you, I got as far as 26: "$("="*[int]$args[0])(:)-" \$\endgroup\$ – Chirishman Aug 29 '16 at 21:33
2
\$\begingroup\$

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!

\$\endgroup\$
  • 3
    \$\begingroup\$ The mysterious --> operator strikes again. \$\endgroup\$ – Leaky Nun Jul 31 '16 at 20:37
  • \$\begingroup\$ @LeakyNun 46 bytes version was without the goes to operator, than I remembered the goes to operator ;) \$\endgroup\$ – betseg Jul 31 '16 at 20:41
  • 1
    \$\begingroup\$ You can remove the >0 and save two bytes. \$\endgroup\$ – owacoder Jul 31 '16 at 20:47
  • \$\begingroup\$ Slightly shorter: f(n){while(4-printf("=\0(:)-"+2*!n--));} \$\endgroup\$ – rici Aug 2 '16 at 2:38
2
\$\begingroup\$

Cheddar, 15 bytes (noncompeting)

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

A straightforward answer.

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

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

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"
\$\endgroup\$
  • \$\begingroup\$ What is -1(...);? \$\endgroup\$ – Adám Aug 1 '16 at 16:04
  • \$\begingroup\$ Save a byte: {(x#"="),"(:)-"} \$\endgroup\$ – Adám Aug 1 '16 at 16:06
  • \$\begingroup\$ Thanks Adam. -1 Prints to the console. -1"Hello"; will print Hello \$\endgroup\$ – Chromozorz Aug 1 '16 at 16:09
  • \$\begingroup\$ But isn't printing implicit? \$\endgroup\$ – Adám Aug 1 '16 at 16:11
  • \$\begingroup\$ Yes but it includes the double quotes... "====(:)-" rather than; =====(:)- \$\endgroup\$ – Chromozorz Aug 1 '16 at 17:22
1
\$\begingroup\$

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

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

Needs -p flag, so run with :

perl -pe '$_="="x$_."(:)-"'
\$\endgroup\$
1
\$\begingroup\$

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

Befunge-98, 24 bytes

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

'=&:00pk:00gk,"-):("4k,@
\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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