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

x86 COM, 29 bytes

8A 0E 82 00 80 E9 30 B4
02 B2 3D CD 21 49 75 FB
BA 18 01 B4 09 CD 21 C3
28 3A 29 2D 24

aka

16DA:0100 8A0E8200      MOV     CL,[0082]
16DA:0104 80E930        SUB     CL,30
16DA:0107 B402          MOV     AH,02
16DA:0109 B23D          MOV     DL,3D
16DA:010B CD21          INT     21
16DA:010D 49            DEC     CX
16DA:010E 75FB          JNZ     010B
16DA:0110 BA1801        MOV     DX,0118
16DA:0113 B409          MOV     AH,09
16DA:0115 CD21          INT     21
16DA:0117 C3            RET
16DA:0118 283A          SUB     [BP+SI],BH // Snake Head
16DA:011A 292D          SUB     [DI],BP    // Snake Head
16DA:011C 2400          AND     AL,00      // Snake Head

Name it "snake.com"

Call it from cmd (tested with Win XP), parameters 1 to 9 supported:

snake 5

results in

=====(:)-

Answer 2

Brainfuck, 53 bytes

++++[->+++++<]>[->+++>++<<],>+<[->.<]>>.<---.>+.++++.

Explanation:

++++[->+++++<]    We build a 20 as 5*4
>[->+++>++<<]     We build a 60 and a 40 in two neighboring cells out of the 20, by multiplying the 20 with 3 and with 2
,>+<[->.<]        Read input, and print 61 ('=') as many times as the input idicates
>>.<---.>+.++++.  Print out the rest, "(:)-", noting how close each character is to either 60 or 40.

Answer 3

Lua, 28 Bytes

Takes input in the form of a command-line argument and outputs via its return value. Even if it uses a return statement, it is still a full program :).

return("="):rep(...).."(:)-"

Answer 4

LiveScript, 15 bytes

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

Answer 5

BASIC, 30 bytes

Let's keep it simple in BASIC. QB64 and TRS-80 Extended Color BASIC both tie, since TRS-80 needs a line number but doesn't need the space after INPUT, and it won't let you use INPUT in immediate mode. One liners are rare on a 32x16 screen.

TRS-80: (should also work on Microsoft GW-BASIC/BASICA)

0INPUTL:?STRING$(L,"=");"(:)-"

QB64:

INPUT L:?STRING$(L,"=");"(:)-"

Answer 6

C#, 42 bytes

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

Try it here!

Answer 7

Java 1.7, 46 bytes

A recursive (and shorter) alternative to the iterative and 'replace' versions.

String f(int n){return n>0?"="+f(--n):"(:)-";}

Run it here.

This function first builds the n tail elements recursively, then appends the head.

Answer 8

Dyalog APL, 13 bytes

'(:)-',⍨⍴∘'='

'(:)-',⍨ the snake head appended to
⍴∘'=' n repetitions of a body segment

TryAPL online!

A proper function. The equivalent program is '(:)-',⍨⎕⍴'='.

Answer 9

Brainfuck, 47 46 44 bytes

+[+<-[<]>->>++]<<++<,[->.<]<.>>---.<<+.++++.

Try it online! Takes input as a single byte value (e.g. space is 32). The program requires an interpreter with 8-bit cells and a tape not bounded on the left.

+[+<-[<]>->>++] (found by a bit of brute forcing) initialises the tape to

[253, 0, 0, 232, 0, 0, 40, 0, 59, 86, 0]
                                      ^

We then increment the 59 to 61 with <<++ and read the input char with <,. [->.<] then outputs the required number of =, and <.>>---.<<+.++++. outputs the (:)- portion, making use of the aforementioned 61 as well as the 40 two cells away.

Answer 10

Fish (><>), 33 bytes:

An upside down F cause ><>. Takes integer as command line argument by running ./fish.py snake.fish -v [number].

\
"
-
)
:
(!;!?lo<
=
"
>{1-:?!^}:

Try it here! The best explanation is to watch it with animation on the website.

Answer 11

Befunge 93, 25 bytes

Try it Online!

1+:&`#v_"=",
"(:)-"<@,,,,

Not compatible with '98, because the & character acts like r when there is no input, instead of repeating the last token

Answer 12

C++14, 59 bytes

As unnamed lambda:

#import<string>
[](int n){return std::string(n,61)+"(:)-";}

Usage:

#include<iostream>

#import<string>
auto f=
  [](int n){return std::string(n,61)+"(:)-";}
;

int main(){
  std::cout << f(2) << std::endl;
  std::cout << f(5) << std::endl;
  std::cout << f(10) << std::endl;
}

Answer 13

Turing machine code, 242 bytes

0 * * r 0
0 _ _ l A
A 0 9 l A
A 1 0 r 1
A 2 1 r 1
A 3 2 r 1
A 4 3 r 1
A 5 4 r 1
A 6 5 r 1
A 7 6 r 1
A 8 7 r 1
A 9 8 r 1
A _ _ r 3
1 _ = l 2
1 * * r 1
2 = = l 2
2 * * * A
3 = = r 4
3 * _ r 3
4 = = r 4
4 _ ( r 6
6 _ : r 7
7 _ ) r 8
8 _ - * halt

Try it online.

Answer 14

Common Lisp, 29 bytes

(format t"~v{=~}(:)-"(read)1)

Answer 15

Befunge-98 (FBBI), 22 18 bytes

Saved 4 bytes by putting the "-):(" at the beginning. This let me get rid of the separate printing of the head, and also the ' for pushing the =.

"-):(="&k:$$>:#,_@

Try it online!

Explanation

"-):(="                   Pushes '-):(=' to the stack - the head reversed
       &k:                Duplicates the = N+1 times (now there are N+2 '='s on the stack)
          $$              Discards 2 so that there are N '='s
            >:#,_         Prints all the top non-zero chars on the stack (the whole snake)
                 @        Exits

Answer 16

VBA Excel, 23 bytes

using Immediate window and cell [A1] as input

?string([A1],"=")"(:)-"

Answer 17

Vyxal, 11 9 bytes

\=*\:øb‹+

Try it Online!

Answer 18

Pyth, 10 bytes

+*\=Q"(:)-

Test suite.

+*\=Q"(:)-
    Q        get input
 *\=         repeat "=" that many times
+    "(:)-   append "(:)-"

Answer 19

C++, 106 103 bytes

#include <iostream>
void s(int n){for(int i=0;i<n;i++){std::cout<<"=";}std::cout<<"(:)-"<<std::endl;}

Usage

#include <string>
int main(int argc, char *argv[]) {
    int length = std::stoi(argv[1]);
    s(length);
    return 0;
}

Ungolfed

#include <iostream> // for printing
void outputSnake(int length) {
    for (int i = 0; i < length; i++) { // iterates over length of snake
        std::cout << "="; // prints an equals sign
    }
    std::cout << "(:)-" << std::endl; // prints rest of snake
}
    
    

---

Thanks @LeakyNun for shaving off 3 bytes.

Answer 20

Java, 133 bytes

public class Snake {
    public void s(int n){
        for(int i=0;i<n;i++){
            System.out.print("=");
        }
        System.out.println("(:)-");
    }
}

Answer 21

><>, 26 23 bytes

:?!v"="o1-
oo;>"-):("oo

-3 bytes thanks to Leaky Nun

Test it here. (you have to input the code manually)

Answer 22

Javascript (using external library) (39 bytes)

n=>_.Range(0,n).Write("=",x=>"")+"(:)-"

Link to lib: https://github.com/mvegh1/Enumerable

Code explanation: Create an array of n elements, and Write a concatenated string with "=" as the delimiter and an empty string as the current element. Then concatenate the head of the snake

Answer 23

Matricks, 24 bytes

Very simple, just wanted to show off the new matrix definition feature.

m61:1:n;;a<40,58,41,45>;

Run with python matricks.py snek.txt [[]] <input> --asciiprint

Answer 24

Nim, 46 bytes

import strutils,future
n=>repeat("=",n)&"(:)-"

This is an anonymous function that must be passed to a procedure to be used. To test, use the testing program below:

import strutils,future
proc test(f: int -> string) = echo f(#[Your input here]#)
test(n=>repeat("=",n)&"(:)-")

Answer 25

Clojure, 35 bytes

#(str(apply str(repeat %\=))"(:)-")

This is an anonymous/unnamed function that takes a single integer as an argument and returns a string.

Answer 26

PL/SQL: 28 bytes

rpad('=','&n','=')||'(:)-');

Answer 27

VBA, 37 bytes

Function S(L):S=String(L,"=")&"(:)-"

and enter gives the End Function. Immediate window of VBA editor:

?S(41)
=========================================(:)-

Answer 28

Brainfuck, 67 bytes

Code:

>++++++[>++++++++++<-]>+<,[->.<]<++++[>++++++++++<-]>.>---.<+.++++.

Explanation:

> At #1
++++++[>++++++++++<-]>+< Put '=' in #2
, Input into #1
[->.<] Output '=' #1 times thereby emptying #1
<++++[>++++++++++<-]>. Put '(' in #1 and output

> At #2
--- Change #2 to ':'
. Output

< At #1
+.++++. Change to '(' and 'minus' and output

Try it online!

Input works using the corresponding ASCII characters - that is, to input 33 you would type !. For convenience, you can use \d as the input in the interpreter linked, where d is any non-negative integer.

Answer 29

Julia, 15 bytes

x->"="^x*"(:)-"

Wow, this is short.

Answer 30

Racket, 46 bytes

(λ(n)(string-append(make-string n#\=)"(:)-"))

Pretty terrible golfing language :)))