[Question]
      [
...will you help me immortalize it?
[![enter image description here](https://i.stack.imgur.com/5KcWXm.png)](https://i.stack.imgur.com/5KcWXm.png)
I've had this pillow a few years now, and apparently it's time to get rid of it. Can you please write a function or program, that I can bring with me and use to recreate this pillow whenever I want to reminisce a bit.
It must work with no input arguments.
The output should look exactly like this (trailing newlines and spaces are OK).
```
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
```
This is code golf, so the shortest code in bytes win!
---
## Leaderboard
```
var QUESTION_ID=98701,OVERRIDE_USER=31516;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
```
```
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
```
```
<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="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><div id="language-list"> <h2>Winners 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><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>
```

[Answer]
# [///](http://esolangs.org/wiki////), 116 bytes
```
/a/\\\\\\\\\\\\\\\///b/\\\\\\\\\\\\\\\\//A/aaaaa//B/bbbbb//C/ABABABABABAB
//D/BABABABABABA
/CCCCDDDDCCCCDDDDCCCCDDDD
```
[Try it online!](http://slashes.tryitonline.net/#code=L2EvXFxcXFxcXFxcXFxcXFxcLy8vYi9cXFxcXFxcXFxcXFxcXFxcLy9BL2FhYWFhLy9CL2JiYmJiLy9DL0FCQUJBQkFCQUJBQgovL0QvQkFCQUJBQkFCQUJBCi9DQ0NDRERERENDQ0NEREREQ0NDQ0REREQ&input=)
**Edit**: the `\\\\\\\\\\\\\\\/` and `\\\\\\\\\\\\\\\\` are actually a *single* / and \, respectively.
**Edit**: -3 because I thought of removing `i`. I think this can't be further golfed.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~18~~ 15 bytes
Code:
```
„/\5×{4Å6×»6F=R
```
Explanation:
```
„/\               # Push the string "/\"
   5×             # Repeat 5 times: "/\/\/\/\/\"
     {            # Sort, resulting in: "/////\\\\\"
      4Å6         # Create a list of 6's with length 4: [6, 6, 6, 6]
         ×        # Vectorized string multiplication
          »       # Join by newlines
           6F     # Do the following six times..
             =    #   Print with a newline without popping
              R   #   Reverse the string
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=4oCeL1w1w5d7NMOFNsOXwrs2Rj1S&input=)
[Answer]
## Python 2, 49 bytes
```
b,a='\/';exec("print(a*5+b*5)*6;"*4+"a,b=b,a;")*6
```
Thanks to Mitch Schwartz for this clean method that saves a byte. The idea is to print four lines of `('\\'*5+'/'*5)*6`, swap the roles of slash and backslash, and then do that whole process 6 times. The two characters are stored in `a` and `b`, and swapped as `a,b=b,a`. The double-loop is double by generating the following code string, then executing it with `exec`:
```
print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;
```
---
**50 bytes:**
```
s='/'*5+'\\'*5;exec("print s*6;"*4+"s=s[::-1];")*6
```
Makes the line string, prints it four times and then reverses it, then does that 6 times. Does so by generating the following code, then executing it:
```
print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1]
```
Here are some of the iterations of my golfing:
```
for c in([1]*4+[-1]*4)*3:print('/'*5+'\\'*5)[::c]*6
for i in range(24):print('/\\'*5+'\/'*5)[i/4%2::2]*6
for c in range(24):print('\\'*5+'/'*5)[::(c&4)/2-1]*6
for i in range(24):print('/'*5+'\\'*5)[::1-i/4%2*2]*6
for c in([1]*4+[0]*4)*3:print('\/'*5+'/\\'*5)[c::2]*6
for c in([1]*4+[0]*4)*3:print('\/'[c]*5+'/\\'[c]*5)*6
for c in(['/\\']*4+['\/']*4)*3:print(c[0]*5+c[1]*5)*6
for c in([5]*4+[-5]*4)*3:print('/'*c+'\\'*5+'/'*-c)*6
print((('/'*5+'\\'*5)*6+'\n')*4+(('\\'*5+'/'*5)*6+'\n')*4)*3
for x in(['/'*5+'\\'*5]*4+['\\'*5+'/'*5]*4)*3:print x*6
a='/'*5;b='\\'*5
for x in([a+b]*4+[b+a]*4)*3:print x*6
s='/'*5+'\\'*5
for x in([s]*4+[s[::-1]]*4)*3:print x*6
s=('/'*5+'\\'*5)*9
exec("print s[:60];"*4+"s=s[5:];")*6
a='/'*5;b='\\'*5
for i in range(24):print[a+b,b+a][i/4%2]*6
```
[Answer]
# 05AB1E, 15 bytes
```
„/\5×{R6×6FR4F=
```
[Try it online!](http://05ab1e.tryitonline.net/#code=4oCeL1w1w5d7UjbDlzZGUjRGPQ&input=)
Explanation:
```
„/\             # Push "/\"
   5×           # Repeat string five times: "/\/\/\/\/\"
     {          # Sort: "/////\\\\\"
      R         # Reverse: "\\\\\/////
       6×       # Repeat string six times
         6F     # Repeat the following six times:
           R    #   Reverse
            4F  #   Repeat the following four times:
              = #     Print without popping
```
Uses the **CP-1252** encoding.
[Answer]
# [Bubblegum](http://esolangs.org/wiki/Bubblegum), 30 bytes
```
00000000: d307 8118 1020 9dc5 3544 3523 f8a4 b386  ..... ..5D5#....
00000010: aae6 e113 cfa3 f13c 1acf a3f1 0c00       .......<......
```
Obligatory Bubblegum answer.
[Answer]
## JavaScript (ES6), ~~68~~ ~~60~~ 58 bytes
A recursive function. Several optimizations inspired from [chocochaos answer](https://codegolf.stackexchange.com/a/98720/58563).
```
f=(n=1440)=>n--?'/\\'[n/240&1^n/5&1]+(n%60?'':`
`)+f(n):''
```
### Demo
```
f=(n=1440)=>n--?'/\\'[n/240&1^n/5&1]+(n%60?'':`
`)+f(n):''
console.log(f());
```
[Answer]
# Haskell, ~~77~~ ~~70~~ 57 bytes
```
a%b=(<*[1..a]).([1..b]>>)
unlines$4%3$5%6<$>["/\\","\\/"]
```
Boring `concat`s and `replicate`s instead of playing with sines. Old was:
```
unlines[["\\/"!!(ceiling$sin(pi*x/5)*sin(pi*y/4))|x<-[0.5..59]]|y<-[0.5..23]]
```
[Answer]
# Brainfuck, 140 bytes
```
>>>++++++++[>++++++>++++++++++++<<-]++++++++++>->----<<<<<+++[>++++[>++++++[>>.....>.....<<<-]>.<<-]++++[>++++++[>>>.....<.....<<-]>.<<-]<-]
```
:-D
[Answer]
## Pyke, 16 bytes
```
"/\"6*5m*n+4*sD3
```
After update today that allowed `"` in string literals, 17 bytes
```
"/\\"6*5m*n+4*sD3
```
[Try it here!](http://pyke.catbus.co.uk/?code=%22%2F%5C%5C%226%2a5m%2an%2B4%2asD3)
[Answer]
# Python 2, ~~86~~ ~~80~~ ~~76~~ ~~74~~ 73 bytes
```
for z in range(24):a=('/'*5+'\\'*5)*24;print((a+a[::-1])*3)[z*60:z*60+60]
```
Could probably golf a few more off it but it's a start.
**Edit**
Saved 6 by removing some unneeded brackets
Another 4 by using a single string and then reversing it
Thanks @Adnan. Had a late night last night and still not fully awake yet :p
-1 by moving the `*24` to the variable instead of using it twice
[Answer]
# Brainfuck, 149 bytes
```
++++++++++>++++++[>++++++++<-]>->+++++++++[>++++++++++<-]>++>+++[<<++++[<<++++++[>.....>>.....<<<-]<.>>>-]++++[<<++++++[>>>.....<<.....<-]<.>>>-]>>-]
```
[The best interpreter EVAR!](//copy.sh/brainfuck?c=KysrKysrKysrKz4rKysrKytbPisrKysrKysrPC1dPi0-KysrKysrKysrWz4rKysrKysrKysrPC1dPisrPisrK1s8PCsrKytbPDwrKysrKytbPi4uLi4uPj4uLi4uLjw8PC1dPC4-Pj4tXSsrKytbPDwrKysrKytbPj4-Li4uLi48PC4uLi4uPC1dPC4-Pj4tXT4-LV0$)
This uses 6 cells (no wrapping, no modulo). Here they are:
```
0A 00 2F 00 5C 00
```
The `00` cells are used for the loop counters. Here, the counters are filled in with initial values:
```
0A 06 2F 04 5C 03
```
The leftmost counter is for the innermost loop (yes, I use nested loops of depth 3). Please note that the 4th cell (`04` counter) is used twice, once for `/////\\\\\...`, and once for `\\\\\/////...` every time.
`0A`, `2F` and `5C` are the characters `\n`, `/` and `\`, respectively.
[Answer]
# Python 2.7 66 -> 56 -> 55 bytes
```
a="/"*5+"\\"*5;b=a[::-1];c=6*a+"\n";d=6*b+"\n";e=4*c+4*d;print e*3
```
new to code golfing
```
a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
```
Thanks Stewie Griffin
Forgot a silly whitespace ;)
[Answer]
# Brainfuck, 179 bytes
```
->++++++++[-<++++++>]++>+++++++++[-<++++++++++>]++++++++++>>>>+++[-<++++[-<++++++[-<+++++[-<<<.>>>]+++++[-<<.>>]>]<<.>>>]++++[-<++++++[-<+++++[-<<.>>]+++++[-<<<.>>>]>]<<.>>>]>]
```
I know this isn't the best score in the thread but I wanted to try out brainfuck and give this a try.
**Edit:**
I must've made an error while copypasting. This version should work
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~10~~ 9 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
/５４＊╬６×３＊
```
[Try it here!](https://dzaima.github.io/Canvas/?u=LyV1RkYxNSV1RkYxNCV1RkYwQSV1MjU2QyV1RkYxNiVENyV1RkYxMyV1RkYwQQ__,v=1)
Explanation:
```
/          push "/"
 54*       extend horizontally 5 times and vertically 4 times
    ╬      quad-palindromize with 0 overlap
     6×    repeat horizontally 6 times
       3*  and again vertically, 3 times
```
[Answer]
# [Dyalog APL](http://goo.gl/9KrKoM), 24 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
```
(60⍴5/0 4)⊖60/⍪∊3⍴⊂4/'/\'
```
[Answer]
# Ruby, 46 bytes
Creates the following string (70 characters, one set more than needed) then alternates between sampling characters `0..59` and `5..64`from it.
```
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
```
**code and output**
```
24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*5,60]}
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
```
**interesting mistake (a 7 instead of a 5)**
```
24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*7,60]}
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
```
[Answer]
# C, ~~66~~ 61 bytes
5 bytes saved thanks to orlp.
Straightforward character by character printing. 61 characters per row, last is newline (ASCII 10) and the others alternate between `/`47 and `\` 92.
```
i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}
//call like this
main(){f();}
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~18~~ 16 bytes
```
'\/'6:&+thK5&Y")
```
[Try it online!](http://matl.tryitonline.net/#code=J1wvJzY6Jit0aEs1JlkiKQ&input=)
### Explanation
```
'\/'   % Push this string
6:     % Push array [1 2 3 4 5 6]
&+     % 6×6 matrix with all pair-wise additions from that array
th     % Concatenate horizontally with itself. Gives a 6×12 matrix
K      % Push 4
5      % Push 5
&Y"    % Repeat each entry of the matrix 4 times vertically and 5 times horizontally
       % This gives a 24×60 matrix
)      % Index (modularly) into the string. This produces the desired 24×60 char array
```
[Answer]
# Pyth, 22 bytes
```
V6V4V12p*5?%+bN2\\\/)k
```
Try it [here](http://pyth.herokuapp.com/?code=V6V4V12p%2a5%3F%25%2BbN2%5C%5C%5C%2F%29k&debug=0).
Explanation:
```
V6                     Loop 6 times, with N from 0 to 5:
  V4                   Loop 4 times, with H from 0 to 3:
    V12                Loop 12 times, with b from 0 to 11:
      p                Print without newline
        *              The repetition
          5            5 times of
          ?            if
            %          the remainder
              + b N    when the sum of b and N
              2        is divided by 2
          \\           then the "\" character
          \/           else the "/" character
    )                  End
                       (implicitly print with newline)
  k                    k (empty string)
                       (implicit end)
                       (implicit end)
```
Sorry if the explanation is a little hard to understand, but it was kinda complicated.
[Answer]
# [V](http://github.com/DJMcMayhem/V),  ~~22~~  21 bytes
**Edit** One byte won, thanks @DjMcMayhem:
```
5á\5á/05ä$4Ä5x$p4Ä3ä}
```
Changes are:
* `Y4P` -> `4Ä` Use V duplicate line instead of Vim built-in command (this will add a blank line at the end of the paragraph)
* `3äG` -> `3ä}` Duplicate the paragraph instead of the whole buffer (to avoid blank line generated by previous change)
---
**Original post**
```
5á\5á/05ä$Y4P5x$p4Ä3äG
```
[Try it online](http://v.tryitonline.net/#code=NcOhXDXDoS8wNcOkJFk0UDV4JHA0w4Qzw6RH&input=)
Decomposed like this:
```
5á\                    Write 5 \
   5á/                 Write 5 / after
      0                Go to the beginning of the line
       5ä$             Copy the text to the end of the line and repeat it 5 times
          Y4P          Copy the line and create 4 new copies
             5x$p      Delete the 5 first characters and put them at the end of the line
                 4Ä    Duplicate this line
                   3äG Duplicate the whole text
```
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~17~~ 16 bytes
```
⁾/\ẋ6Wẋ4;U$ẋ3x5Y
```
[Try it online!](http://jelly.tryitonline.net/#code=4oG-L1zhuos2V-G6izQ7VSThuoszeDVZ&input=)
Thanks to 6710 (miles) for -1 byte.
[Answer]
# [Actually](http://github.com/Mego/Seriously), 21 bytes
```
"/\"5*SR6*;4α@R4α+3αi
```
[Try it online!](http://actually.tryitonline.net/#code=Ii9cIjUqU1I2Kjs0zrFAUjTOsSszzrFp&input=)
*-1 byte from Adnan*
Explanation:
```
"/\"5*SR6*;4α@R4α+3αi
"/\"5*                 "/\" repeated 5 times
      SR               sort and reverse (result: "\\\\\/////")
        6*             repeat string 6 times (forms one row)
          ;4α          copy and push a list containing 4 copies
             @R4α+     push a list containing 4 copies of the reversed string, append to previous list (now we have one row of diamonds)
                  3α   repeat pattern vertically 2 more times
                    i  flatten and implicitly print
```
[Answer]
# J, ~~31~~ ~~28~~ 19 bytes
```
4#_60]`|.\5#72$'/\'
```
## Usage
```
   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
```
[Answer]
# APL, 30 bytes
```
A←240⍴'/////\\\\\'⋄24 60⍴A,⊖A
```
I'm quite new to APL, (I'm using APLX, but this should work across most implementations of APL), so this is a quite simplistic solution.
### Explanation:
```
A ← 240 ⍴ '/////\\\\\' ⍝ set A to be a 240 character vector populated with '/////\\\\\'
⋄                      ⍝ statement separator
24 60 ⍴ A,⊖A           ⍝ populate a 24 by 60 character matrix with the concatenation
                          of A and the reverse of A (⊖A)
```
[Answer]
# Python 2, 63 bytes
```
a='\n'.join([('/'*5+'\\'*5)*6]*4);print'\n'.join([a,a[::-1]]*3)
```
For Python 3, do this (65 bytes):
```
a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
```
[Answer]
# [Self-modifying Brainfuck](//soulsphere.org/hacks/smbf), 91 bytes
```
>>+++[<++++[<++++++[<.....<.....>>-]<<<.>>>>-]++++[<++++++[<<.....>.....>-]<<<.>>>>-]>-]
\/
```
[Try it online!](//smbf.tryitonline.net#code=Pj4rKytbPCsrKytbPCsrKysrK1s8Li4uLi48Li4uLi4-Pi1dPDw8Lj4-Pj4tXSsrKytbPCsrKysrK1s8PC4uLi4uPi4uLi4uPi1dPDw8Lj4-Pj4tXT4tXQpcLw)
Same as my [brainfuck answer](/a/98711/41024), but uses the 3 last characters of the source code instead of generating them at runtime.
[Answer]
## Octave, ~~50~~ 48 bytes
Anonymous function:
```
@()repmat([A=repmat(47,4,5) B=A*2-2;B A ''],3,6)
```
You can try [online here](http://octave-online.net). Simply run the above command and then run the function with `ans()`.
Essentially this creates an array of the value 47 which is 4 high and 5 wide. It then creates a second array of value 92 which is the same size.
The two arrays are concatenated into a checkerboard of `[A B;B A]`. The `''` is concatenated as well to force conversion to character strings.
Finally the whole array is replicated 3 times down and 6 times across to form the final size.
---
* Saved 2 bytes, thanks @StewieGriffin
[Answer]
## PHP, ~~73~~ 69 bytes
```
for($s='/\\';$i<1440;$i++)echo$i%60<1?'
':'',$s[($i/5+($i/240|0))%2];
```
### Demo
<http://ideone.com/z7N1Md>
[Answer]
## APL, 16
```
4⌿5/1↓⍉12 7⍴'\/'
```
Try it on [tryapl.org](http://tryapl.org/?a=4%u233F5/1%u2193%u234912%207%u2374%27%5C/%27&run)
[Answer]
# Java 7, 120 bytes
```
String c(){String r="";for(int i=0;i<1440;r+=(i%60<1?"\n":"")+(i/60%8<4?i%10<5?"/":"\\":i%10<5?"\\":"/"),i++);return r;}
```
Pushed everything into one loop. Beats Brainfuck, mission accomplished.
See it online: <https://ideone.com/pZjma3>
]


[Question]
      [
Given a number N, output the [sign](https://en.wikipedia.org/wiki/Sign_function) of N:
* If N is positive, output 1
* If N is negative, output -1
* If N is 0, output 0
N will be an integer within the representable range of integers in your chosen language.
## The Catalogue
The Stack Snippet at the bottom of this post generates the catalogue 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:
```
## [><>](https://esolangs.org/wiki/Fish), 121 bytes
```
```
/* Configuration */
var QUESTION_ID = 103822; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8478; // This should be the user ID of the challenge author.
/* App */
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, 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.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
    if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) 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);
  }
}
```
```
body {
  text-align: left !important;
  display: block !important;
}
#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}
#language-list {
  padding: 10px;
  width: 500px;
  float: left;
}
table thead {
  font-weight: bold;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=ffb5d0584c5f">
<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>
```

[Answer]
# [Yabasic](http://www.yabasic.de), 16 bytes
Anonymous function that takes input as a number, `n`, and output to STDOUT
```
input""n
?sig(n)
```
[Try it online!](https://tio.run/##q0xMSizOTP7/PzOvoLRESSmPy744M10jT/P/f11zAA "Yabasic – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 9 + 1 (`-p`) = 10 bytes
```
$_=$_<=>0
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lYl3sbWzuD/f10zU2MTM2NTIGVmDCS4DLhMjI1MTY2MTf7lF5Rk5ucV/9ctyAEA "Perl 5 – Try It Online")
[Answer]
# [Pyt](https://github.com/mudkip201/pyt), 1 [byte](https://github.com/mudkip201/pyt/wiki/Codepage)
```
±
```
[Try it online!](https://tio.run/##K6gs@f//0Mb//00B)
Boring built-in answer (padding for body length)
[Answer]
# Lua (51 Bytes)
```
n=tonumber(...) print(n<0 and -1 or n>0 and 1 or 0)
```
... is the variable that represents arguments in lua, tonumber(...) converts the first argument to a number.
also in lua a and b or c is a structure that returns b if a is truthy or c if a is falsy, you can nest this structure as well
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 2 bytes
```
:+
```
[Run and debug online!](https://staxlang.xyz/#c=%3A%2B&i=0%0A3%0A-4&a=1&m=2)
## Explanation
Added for completeness. It is a builtin, but all built-ins starting with a colon in Stax is actually a macro defined using other Stax operations.
Internally it is defined as `c0>s0<-`, which is simply `(x>0)-(x<0)`.
[Answer]
**SHELL** ( **20 Bytes** )
```
sed s/[1-9][0-9]*/1/
```
tests:
```
echo "789" | sed s/[1-9][0-9]*/1/
1
echo "-789" | sed s/[1-9][0-9]*/1/
-1
echo "0" | sed s/[1-9][0-9]*/1/
0
```
[Answer]
# [Swift](http://rextester.com/l/swift_online_compiler), 44 bytes
```
func s(i:Int)->Int{return i>0 ?1:i<0 ? -1:0}
```
Strange spacing around the ternary options, I know, but this was the shortest way.
[Try it online!](http://rextester.com/LUWO28653)
[Answer]
# [Brain-Flueue](https://github.com/DJMcMayhem/Brain-Flak), 40 bytes
```
{([({})]){({}())<>([{}()()])<>}}(<>[]{})
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/v1ojWqO6VjNWsxpIaWhq2thpRIMYGkAhG7vaWg0bu@hYoIL//3UNDQz@6@YoOIF1u@WUppamAgA "Brain-Flak – Try It Online")
## Readable version
```
{
 ([({})])
 {
  ({}())<>
  ([{}()()])<>
 }
}
(<>[]{})
```
[Answer]
# [MachineCode](//github.com/aaronryank/MachineCode), 26 bytes
```
31c085ff0f9fc0c1ef1f29f8c3
```
Requires the `i` flag for integer output. Input must be appended to the code on a separate line. This is equivalent to the C code `(n>0)-(n<0)`. [Try it online!](https://tio.run/##BcHBDYAwDAPAiSolRFHbcZCJRR7A/i9z95y4@y18V0nhsJWkcRMGLzqPzYXQiMyYUv8)
Alternatives with the same bytecount:
* `31c085ff0f95c0c1ff1f09f8c3` - [Try it online!](https://tio.run/##BcFBCsAgDATAFwkJIdQ8R7YuerD9/2mdOQNrfxP/O6VwWE/SWAmDk04rdoRaZMYj7Qs) Equivalent to the highest voted C submission.
* `89f8c1ff1ff7d8c1e81f01f8c3` - [Try it online!](https://tio.run/##y01MzsjMS03OT0n9/9/CMs0i2TAtDYjMU4CsVAvDNANDoJjxf11jU1Nj8///MwE) Equivalent to [this](https://tio.run/##S9ZNT07@/z9No0Kzuii1pLQoT0FDQ6M0rzgzPS81RSEzr0RTt0LTzs7YUFMXXQIqbl37PzcxM09Ds7qgCCicpqGkmqIARko6CmkaukaaIMoATBoam2iCNAAA) C code.
[Answer]
## [Canvas](https://github.com/dzaima/Canvas), ~~3~~ 2 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
⤢÷
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXUyOTIyJUY3,i=MTQ_,v=2)
This might be the shortest solution without a builtin that does the problem for you (I'm looking at you, Jelly.)
Explanation:
```
⤢÷ | *Full code*
 ÷ | Divide
   | The input (implicit)
⤢  | By its absolute value
```
[Answer]
## F#, 140 bytes
```
open Checked
let s n=
 if n=0 then 0
 else
  try
   let mutable p=n
   while p<>0 do
    p<-p+1
   -1
  with| :? System.OverflowException->1
```
[Try it online!](https://tio.run/##HU5BasMwELz7FUOg0FIU5MSlUBL1UHJuIcfSg@usalFbUmUlTiB/365ymZ2ZnWXHTqoLiZhDJI@3nrpfOlQDZUzw2wrOytDIvWx1BRomqoCcLoIosfGY2@@BELe@WHPvitgYjUMohnAVH@tCVcHZ5f6Kl1fsL1Omcfl@omSHMO/OHcXsglem5s/NzsuPj@B8Nl@3OmPrPNr0c4K02tPf0mVKuLdHjzOUgSSFXI30FohJtPVY3LnFw@2sgmZWa1bP3PCaNTerp2bV1DWrWmv9Dw)
Basically, if the number is non-zero, keep adding `1` to it until you get either `0` (so the original value was negative) or an overflow (so the original value was positive).
That's all right, isn't it?
[Answer]
# [naz](https://github.com/sporeball/naz), 64 bytes
```
9a5m2x1v3a2x2v1x1f1o0m1a1o0x1x2f1o0x1x3f1r3x1v1e3x2v2e0m1a1o0x3f
```
**Explanation** (with `0x` commands removed)
```
9a5m2x1v                 # Set variable 1 equal to 45 ("-")
3a2x2v                   # Set variable 2 equal to 48 ("0")
1x1f1o0m1a1o             # Function 1
                         # Output once, set the register equal to 1, and output again
1x2f1o                   # Function 2
                         # Output once
1x3f                     # Function 3
    1r                   # Read a byte of input
      3x1v1e             # Jump to function 1 if the register equals variable 1
            3x2v2e       # Jump to function 2 if the register equals variable 2
                  0m1a1o # Otherwise, set the register equal to 1 and output
3f                       # Call function 3
```
[Answer]
# [Keg](https://github.com/JonoCode9374/Keg), `-hr`, 13 bytes
```
:0<[0;|0>[1|0
```
[Try it online!](https://tio.run/##y05N///fysAm2sC6xsAu2rDG4P9/XQsjy/@6GUUA "Keg – Try It Online")
A very simple switch like comparison happening here.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
A signum built-in.
```
.±
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f79DG//8NjYwB)
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), 8 bytes
```
I:SA:?,h
```
[Try it online!](https://tio.run/##S8/PScsszvj/39Mq2NHKXgfI0jUyNjQyMgYA "Gol><> – Try It Online")
### How it works
```
I:SA:?,h
I         Input as number; [n]
 :        Duplicate; [n n]
  SA      Absolute value; [n abs(n)]
    :     Duplicate again; [n abs(n) abs(n)]
     ?    Pop one; if it is zero, skip next command
      ,   Nonzero n: Divide n by abs(n)
       h  Print top as number and exit
```
---
# [Gol><>](https://github.com/Sp3000/Golfish), 11 bytes
```
I:0(qm$0)+h
```
[Try it online!](https://tio.run/##S8/PScsszvj/39PKQKMwV8VAUxvI0TUyNjQyMgYA "Gol><> – Try It Online")
### How it works
```
I:0(qm$0)+h
I            Input as number
 :           Duplicate top
  0(         Change top to "top < 0"
    q        If top is true...
     m$      Push -1 and swap top two; the stack is [-1 x]
             Otherwise, skip two commands (m$); the stack is [x]
       0)    Change top to "top > 0"
         +   Add top two
          h  Print top as number and halt
```
[Answer]
## PowerShell, ~~22~~ 21 bytes
```
[math]::sign("$args")
```
Boring built-in, calls the .NET function that does exactly what it says on the tin. Ho-hum.
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/Pzo3sSQj1sqqODM9T0NJJbEovVhJ8////7qGpgA "PowerShell – Try It Online")
*-1 byte thanks to Veskah.*
---
For **26 bytes** however, we get the classic greater-than less-than equation
```
param($b)($b-gt0)-($b-lt0)
```
This, at least, has a little bit of logic and thought put into it. [Try it online!](https://tio.run/nexus/powershell#@1@QWJSYq6GSpAnEuuklBpq6IEYOkPH//39dQ1MA "PowerShell – TIO Nexus")
---
Best yet, though is **44 bytes**, where we roll our own solution.
```
param($b)if("$b".indexof('-')){+!!$b;exit}-1
```
Here we take input `$b`, stringify it, take the `.IndexOf('-')` on it, and use it in an `if` clause. If the negative sign isn't found, this returns `-1`, which is truthy in PowerShell, so we turn `$b` into a Boolean with `!`, invert the Boolean with another `!`, cast it as an int with `+`, leave it on the pipeline, and `exit`. This turns a positive integer (which is truthy) into `$false`, then `$true`, then `1`, while turning `0` into `$true`, then `$false`, then `0`. Otherwise, the `.IndexOf` returned `0` (meaning it was the first character in the string), which is falsey, so we skip the `if` and just place a `-1` on the pipeline. In either case, output via implicit `Write-Output` happens at program completion. [Try it online!](https://tio.run/nexus/powershell#@1@QWJSYq6GSpJmZpqGkkqSkl5mXklqRn6ahrquuqVmtraiokmSdWpFZUqtr@P//f11DUwA "PowerShell – TIO Nexus")
[Answer]
# [Scratch 3.0](https://scratch.mit.edu), 9 blocks/44 bytes
For those who are tired of the old way of introducing these answers [*I'm looking at you a'\_'* ...(ಠ ͟ʖಠ)], I'll put the ScratchBlocks Syntax first:
```
define f(n
set[r v]to(<(n)>(0)>-<(n)<(0
say(r
```
[![enter image description here](https://i.stack.imgur.com/beNB7.png)](https://i.stack.imgur.com/beNB7.png)
I decided to use a function instead of the old `when gf clicked` approach because that means I don't have to deal with having an `ask() and wait` next.
[Try it not online but on Scratch](https://scratch.mit.edu/projects/379658176)
[Answer]
# [Io](http://iolanguage.org/), 28 bytes
Does a conditional checking over x/abs(x).
```
method(x,if(x!=0,x/x abs,0))
```
[Try it online!](https://tio.run/##y8z/r6@v4JevUJyZnqeQX5BalFiSX2Sv4KmQXppaXAyk81JTUxRK8hVS8hUySxRyK4tTc9L0FB63zNd4v3@xDhBrPm7p5wJrt7JViPmfm1qSkZ@iUaGTmaZRoWhroFOhX6GQmFSsY6Cp@R@kTEPX0EhToaAoM68kJ@8/AA "Io – Try It Online")
[Answer]
# [Symja](https://symjaweb.appspot.com/), ~~29~~ 26 bytes
```
f(x_):=If(x==0,0,x/Abs(x))
```
[Try It Online!](https://symjaweb.appspot.com/input?i=f%28x%5f%29%3a%3dIf%28x%3d%3d0%2c0%2cx%2fAbs%28x%29%29%3bf%280%29)
*-3 bytes to due porting the idea behind the Io answer.*
## Answer History
### 29 bytes
```
f(x_):=If(x<0,-1,If(x>0,1,0))
```
For some reason, my edit history didn't save this old approach.
[Answer]
# [Python 3](https://docs.python.org/3/), 25 bytes
```
lambda x:x and(1,-1)[x<0]
```
[Try it online!](https://tio.run/##K6gsycjPM/5fnJmeZxvzPycxNyklUaHCqkIhMS9Fw1BH11AzusLGIPZ/QVFmXokGSJmGoaYmFxLXAJUL1KH5HwA "Python 3 – Try It Online")
Uses a different approach from other python answers
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), 7 bytes
```
?dd*v/p
```
[Try it online!](https://tio.run/##S0n@H2/@3z4lRatMv@D/fwA "dc – Try It Online")
Input on stdin, output on stdout. (There may also be spurious output to stderr, which should be ignored, as usual.)
This uses the formula $$\frac{\left\lfloor\sqrt{n^2}\right\rfloor}n$$
plus the fact that if you divide by `0` in dc, it leaves the `0` at the top of the stack.
(If you try this out, note that negative numbers are written in dc with an initial `_` instead of `-`, since `-` is only used for the two-argument subtraction operation.)
[Answer]
## [Desmos](https://desmos.com), 12 bytes
```
f(x)=sign(x)
```
or
$$f\left(x\right)=\operatorname{sign}\left(x\right)$$
[Try It On Desmos!](https://www.desmos.com/calculator/1yr8dm8fhq)
[Answer]
# [Haskell](https://www.haskell.org/), 6 bytes
```
signum
```
It's a function belonging to the Num typeclass, so every number works.
[Answer]
# [8th](http://8th-dev.com/), ~~40~~ 3 bytes
With **8th** is quite simple to get the sign of N, which is left on TOS
```
sgn
```
**Testing** and **Output**
```
ok> 42 sgn .
1
ok> -42 sgn .
-1
ok> 0 sgn .
0
```
The following code, as an alternative, has the same behaviour of **8th**'s builtin word `n:sgn`
```
: f dup 0; 0 n:> if 1 else -1 then nip ;
```
**Explanation** of word `f`
```
: f \ n -- -1|0|1
  dup     \ Duplicate input
  0;      \ Check if number is 0. If true, leave 0 on TOS and exit from word
  0 n:>   \ Check if positive
  if 1    \ Return 1 if positive
  else -1 \ Return -1 if negative
  then
  nip     \ Get rid of input
;
```
**Testing** and **Output**
```
ok> 42 f .
1
ok> -42 f .
-1
ok> 0 f .
0
```
[Answer]
# Python - 23 bytes
```
print((n>0)*2+(n==0)-1)
```
This checks if n is greater than 0 (in which case it outputs *2* for the next step), then if it is equal to 0 (in which case it outputs 1) and then subtracts 1, leaving us with -1 if n < 0, 0 if n == 0, and 1 otherwise.
(Yes, the double brackets *are* necessary, I have checked.)
[Answer]
# [R](https://www.r-project.org/), 21 bytes, no builtin
```
x=scan();x/abs(x^!!x)
```
[Try it online!](https://tio.run/##K/r/v8K2ODkxT0PTukI/MalYoyJOUbFC878hl6EBl5GxCZcBl64hEAEpIO8/AA "R – Try It Online")
Takis input from STDIN. Avoids the builtin `sign`. This comes out 4 bytes shorter than JAD's [solution](https://codegolf.stackexchange.com/a/103870/86301) with `if`. We cannot use directly `x/abs(x)` since we would divide by 0 when `x=0`.
After coercion to integer, `!!x` will be equal to `1` for all input except 0 (when it is equal to `0`). Since `0^0=1`, this trick allows to avoid dividing by 0:
* For nonzero input, it is equivalent to `x/abs(x^1)`, giving +1 or -1
* For `x=0`, it is equivalent to `x/1`, giving 0
[Answer]
# [Pxem](https://esolangs.org/wiki/Pxem), Contents: 0 bytes + Filename: ~~33~~ 25 bytes
* Filename(unprintables are escaped): `1._.c.w\001.r.yXX-.a.p.d.a.n`
* Content is empty.
[Try it online!](https://tio.run/##jVh7V9rKFv@/n2JII5khCckgKBKjUvRazlGK1rqsgK5AgoIxcJKgaOB89d49kyAQertu1yqZ@e3n7Mc8fAoef33@XHb2rN5uz@kW@oXtsr2r7@z0Sra@U@p3rb5u64ViSS@VaOlT4IRIdSbG5NkKnpCuFwqGMx2P/BCd1e6rZ2dmzcDh29hBD07YG3n9bJbPeqPnZ8uzyYFmOy@aN3FdVDjI0mw2EW5Wr76agogTPqSOFwo4iYgR@8iVeTxQ58LC7I9G/eb@@9WxWdD17QXY/Pa9fnP287727fLypHZlUqOFBDH6Uv3@9f765PJ7/VujIr/NBWSiN9TJZvmqRmg8CgbTeCZ/iUVu/4eE8zxxrdBBwSPnH41DGL6OfDsYu4Mwm7XcgRUg9QFJYkRlQTwS5pIpsa@UzTZ@nJ3Vzo/NCreBmT3bCB4H/dDgY8T4EsDpPY6Q@Jkwy5RZzoChwsi1D7IQ@hfLRUIG9S03cITZbJXGVXPp6SxwbCQF2lR704wAft41iSt8Rx0mxLmAZyHawwSPIAlVD6kv4YTOQh@ptQC1W7q610FSq@3lOtLswXfGKB8r1@6KO6IWVaqG2DUahtb2@LwJ5u7y@banaUa3aszjaeuO6aG0IGpjzQhXwbK@iVFKRW2UAnf3NjFKQdpLM5Y3MaqXRG2QZtzexPaA7z6NgeVeCtvZ3cQoBeEgvb7tTYxScPElzbiziVEdItZPu61vYlSHiDlpH/c2MUqLouanTRc2MUpB@jXNuLuJ0QL4M00zljcxWgAf39KMe5sYLYA/7@kk6L/BwB0rvejSJkYpxDZMWy5uYlQHd57T8d7dxKgO7thp0@VNrAjpl9MYuKimsG3gy6Qx8FpMY@DMFsPm0gz3rGS7sEnSlLxfteiUNeXUsKH/Tpl0G@fbpI3bHvvN59pE1Nrb7UKbasAVaPkcdOt0vb8rriFmIq31On17t@yOlokaRtcFhXPjDZpdQ5qhte4SKitxUUO2tqZD9ZCUmG/dHSkdsAse4FY8BBcKR4i58JjwxDjK54DEPYutw3rG3E1RUxjaBRcgxRHMMlEAo6o2NroXgMZsyhEo@GC0Pxht7XjBuMa2oCRxqPiGGMXmjhBTDVsc50bVBRJWeWjFTAMoba@F1PdOzmbaQn8FgSXx@HTixWqcZAHbmOc0XpwVS83B28rFh8o89y28SO25STy@QmSOqxCXaZJcHtll3OL4nCaa@P/YldiTJOu/E5TQ4uhYSYg26GPX6jquaQptKpCIrwS3xiNvcN8LXvqOHz7LGXFL7TDuNsXE0B5iHlaP7Ygq7TkjNXGbJjRr1aVg0sUCS4igMOlDGAsV4UhQuFkyTwyu8/@J@VjUur5jPfEJ5K2KBXc0GiNvFKJnK@w9DrwHAVilxXJlTLQupoT7pvKJmswyfKbHExEm/ywmW3zC2KAZeSNK/ZGfxAo8MgwSScZHl0pziZBf/2lUz09Miebv8738a1vXad7Pv93cqHkrP87b8OtJn2rfGlcnjStTkj7hsT/wwj4c7lxSTEjC7LWH1B6B4/tX4PdM6cvJab0RQarkwHFsEvhwrcJ8OO9PvF44GHmoiY9J9L31pPyNScc8NmDYkeUl/QSTyHfCie@hjAw8S8pfSwrgB3RJ@XtJYeqWhKs1AjOp0hXyDb4k0aUJXNwNVTUS5sslzwTXSMTXj2pL9BRfKrcfuuHa6A4850A/FPWKuuLY19iASA1eLne8FmWoGkEgaxCKoU3zP5j5iWeu2K7i84VH5zMBUgvxZ1fTQYhWTI9h6a@PA9fBGQgpGa1GEiYRgLPZBN8AbUnwcF25Vo4Vl7AscsHo2gQewzVdx3sIH/E1MViB1eF@W983XYNMMD42YS1B6ONrpS7LCiXkX4GvSzg8lovlSrFE5ksjA7DexKdrhu/xuVJTbpWfJDo3hfx9BTWgTSxkO73BM9w3YbHOg@PDdzwJBaNmgrhxCz4wX1iNg7vF3f1aNlvbL5UJbzwDsNq/wl2xtV3qiLBn3JrFolpLhOPeBBZcjsVoEQJSM83tAoliFngKhANv4sxZxBlrbb9YBp6D0i5hUGx8aTbWTH6a@CdBNbVYNlj2jCa@zf1cWWtvEf0mvloLQrAg3Kwm6wVyMlSuSVQ3dW5xaPI6hvAPWdkqQ1XtmNcsUWxW73AQ8tDh82FnJfT@0jREFPP@JDlWAysGX5dNs@nNFF8o3FYG2pFFOAOzC14i1@bFPuNNZK@XQm9/FDr4vdD7hxtMiruhrrkSLhbzCL1rrpGegfQExYLgpdTEjL5C7GILAhqX@F@swpvYOgRx2WKRqNwkETGWO0bOpGohh619neRYzuC7EtR/0vqGScfcJIvFw5xLoGLAjJDfgoMiD9UoVNCt48O9afAyCECNwAqFJcU6HB64h8Mtt@JuDSt8rPEx5Gge77Dgmal3oBzgcZfam4VZjwjS0rk@RGKN62Pv3nxs/eGtZcaHVHwzgIsXHFrszav63hOd9SYwsiUkIbVfWJxmcJFp4ixhj74VdxxezPEpGUHh8oJ@kmVDlof7mG3CrGgh5HH4h8kUBsT4/TLYcm3HdeBdDHmGVki2J2gQWa7vg7hM45bgJ02da5Qp9Em86cvxvDOXDHZSsT8IwNWph/gfDSasQ0bP7AkMoL8BLmNoF5HaKK4xzGZ4DM/xKrzxB7bihINnRxn3xhPlJXg3bHjIk9UcFP/84EWhNXDhOltcCTC7Ukdldq3hlydpZr0@gS5kmWqBFneL5e2dYhlJkSWboj4/aRwnp4YFlwDh0/@d/0RrEh32ESABcOALnCSJOtzJ4J@Agjg9WNgaCYqoE2k2tfwHiEF9ipLMTT@hX/p/AQ "ksh – Try It Online")
## Usage
Give an integer from STDIN. The result is output from stdout, with no LF termination.
## How it works
```
XX.z
# Prepare character 1 at this point
.aXX1.z
# integer input is pushed
.a._XX.z
# duplicate, and is it non-zero?
.a.c.wXX.z
  # then come here
  # also \001.r is an idiom to push zero:
  # actually "n=pop;push(int(random()*n))"
  # where 0<=random()<1
  # because filename cannot have null character
  # don't be afraid of such binary for code golf
  .a\001.rXX.z
  # is input less than zero?
  # DOT-y to DOT-a is:
  # while size<2 OR pop>pop; do something; done
  .a.yXX.z
    # if so, push hyphen so string "-1" is made
    .aXXXX-.z
  .a.aXX.z
  # at this point DOT-y popped two items: zero and input integer
  # so no worry about garbages
  # print the string and exit
  # .p is actually: while !empty; do printf "%c", pop; done
  .a.p.dXX.z
# if input is zero, come here
# .n is printf "%d", pop
# OBTW the "1" will on stack, but it's not matter,
# because it is ignored when program ends
.a.a.n
```
## Previously
* 33bytes of filename: `._.c.w.c00.-.-.z-1.p.d.a1.o.d.a.n`
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 1 byte
```
g
```
[Try it online!](https://tio.run/nexus/japt#@5/@/78hAA "Japt – TIO Nexus")
[Answer]
# Python 3.8, 47 bytes
```
print(1if(n:=int(input()))>0else-1if n<0else 0)
```
[Answer]
# [tinylisp](https://github.com/dloscutoff/Esolangs/tree/master/tinylisp), 32 bytes
```
(d F(q((X)(i X(i(l X 0)(q -1)1)0
```
[Try it online!](https://tio.run/##K8nMq8zJLC74/18jRcFNo1BDI0JTI1MhQiNTI0chQsFAU6NQQddQ01DT4L@Gm4KhJheQNACTGsUKBkABMNvQwAQhZmZqamymqfkfAA "tinylisp – Try It Online")
Since there are no negative number literals in tinylisp, they have to be passed in using subtraction.
]


[Question]
      [
**Challenge:**
The concept is simple enough: write a full program to output its own code golf score!
Output should only be the byte count of your program and a trailing  `bytes`.
**BUT WAIT**..... there is one restriction:
* Your source code can not include any of the digits from your byte count
* So if your score is `186 bytes`, your program can not contain the characters `1` , `6` , or `8`
**Example Output:**
```
315 bytes
27 Bytes
49 BYTES
```
**Additional Rules:**
* Unnecessary characters, spaces, and newlines are forbidden in the source code, however trailing spaces and newlines are perfectly acceptable in output
* There should be a single space between the number and `bytes` in the output
* Letters are case insensitive
* No self inspection or reading the source code
* [standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are disallowed
* this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so
**Shortest code in bytes wins!**

[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 14 bytes
```
"$(2*7) bytes"
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0lFw0jLXFMhqbIktVjp/38A "PowerShell – Try It Online")
Ho-hum. Uses an inline code block `$(...)` to put `14` into the string before leaving it on the pipeline. Output is implicit.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 18 bytes
```
puts"#{6*3} bytes"
```
[Try it online!](https://tio.run/##KypNqvz/v6C0pFhJudpMy7hWIamyJLVY6f9/AA "Ruby – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 95 bytes
```
+[--------->+<]>.----.--[--->++<]>--.[->+++<]>++.[--->+<]>+++.-----.+++[->+++<]>.[--->+<]>----.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fO1oXBuy0bWLt9EAsIBENFgCJALnRICaIra2tFw1TCRQBK9bVA7LgKhDyYKn//wE "brainfuck – Try It Online")
97 bytes:
```
>-[++>+[+<]>]>+.--.>++++[->++++++++<]>.[->+++<]>++.[--->+<]>+++.-----.+++[->+++<]>.[--->+<]>----.
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), ~~10~~ 10 bytes
```
Ao" bytes"
```
[Try it online!](https://tio.run/##S85KzP3/3zFfSSGpsiS1WOn/fwA "CJam – Try It Online")
[Answer]
# [Gol><>](https://github.com/Sp3000/Golfish), 11 bytes
```
bn"setyb "H
```
[Try it online!](https://tio.run/##S8/PScsszvj/PylPqTi1pDJJQcnj/38A "Gol><> – Try It Online")
### How it works
```
bn"setyb "H
b            push number 11
 n           pop and print as integer
  "setyb "   push " bytes" in reverse order
          H  print the stack content as chars, then halt
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 8 bytes
```
#+` ßs
```
char-code 8 concatenated with " bytes" compressed.
[Try it online!](https://tio.run/##y0osKPn/X5lDO0Hh8Hyp4v//AQ "Japt – Try It Online")
[Answer]
# Google Sheets, 12 bytes
An anonymous worksheet function that takes no input and outputs to the calling cell
```
=3*4&" bytes
```
[Answer]
# MSSQL, ~~26~~ 24 bytes
```
print str(8*3) +' bytes'
```
[Answer]
# F#, ~~24~~ 23 bytes
I hope this counts. Never code golfed before
```
printfn "%i bytes" 0x17
```
Just switched ~~24 to octal~~ 23 to hex
[Try it online!](https://tio.run/##SyvWTc4vSv3/v6AoM68kLU9BSTVTIamyJLVYScGgwtD8/38A "F# (.NET Core) – Try It Online")
[Answer]
## Windows Command Line, 20 bytes
```
set/a4*5&echo  bytes
```
Run Windows Command Prompt (cmd.exe), type the command and hit Enter.
![img](https://i.stack.imgur.com/pEQbo.png)
[Answer]
# SQL, 18 bytes
```
SELECT 2*9,'bytes'
```
[Answer]
## ArnoldC, 216 Bytes
[Try it online!](https://tio.run/##ZY5NCsIwEIX3PcXDTS@gB0jtsxk0SUmmlS5FN4IoeH@ISUE3zmZ4P/Mxl/fz9bhdcxZtE5INZxXHBrBcsLdRkjqToJHEvdhLmJComBKmEdviDEVpgFqWfhhHxrVYxzISkuAWiJ9FjUrwv7Sg2pIfJLLHrqLowzRYqDkdi6rrS7bG9@vhn7npFmXaNPUxa2aiIz2U0Yk3yj7nDw)
```
IT'S SHOWTIME
    HEY CHRISTMAS TREE i
    YOU SET US UP 4
    GET TO THE CHOPPER i
        HERE IS MY INVITATION i
        YOU'RE FIRED 54
    ENOUGH TALK
    TALK TO THE HAND i
    TALK TO THE HAND "BYTES"
YOU HAVE BEEN TERMINATED
```
**Output**
```
216
BYTES
```
Well, i took too long with my **php** answer, i had to try this.
As far as i read, i can't write without a line break or concatenate an integer with a string :(
[Answer]
# [Husk](https://github.com/barbuz/Husk), 8 bytes
```
+sD4¨₆Ẏ¿
```
[Try it online!](https://tio.run/##yygtzv7/X7vYxeTQikdNbQ939R3a//8/AA "Husk – Try It Online")
### Explanation
```
+sD4¨₆Ẏ¿
    ¨₆Ẏ¿  Compressed string of " bytes"
  D4        Multiply 4 by 2
 s          Convert to string
+         Concatenate the strings
```
[Answer]
# [Swift 4](https://developer.apple.com/swift/), ~~19~~ 18 bytes
*Saved 1 byte thanks to Jo King.*
```
print(9*2,"bytes")
```
[Try it online!](https://tio.run/##Ky7PTCsx@f@/oCgzr0TDUstIRympsiS1WEnz/38A "Swift 4 – Try It Online")
[Answer]
# Vim, 12 10 bytes
```
i9*<C-o><C-a>* bytes
```
[Answer]
# [Backhand](https://github.com/GuyJoKing/Backhand), 11 bytes
```
"" sbbeOytH
```
[Try it online!](https://tio.run/##S0pMzs5IzEv5/19JSaE4KSnVv7LE4/9/AA "Backhand – Try It Online")
Non-linear pointer progression makes for weird looking programs. Outputs `11 bytes`.
The orde: of commands is such:
```
"  s  e  t      Start string literal to push letters
                Bounce and go left
     b  y       Finish pushing " bytes"
                Bounce and go right
 "  b  O  H   Push 11 to print and then halt and output the stack
```
[Answer]
## C#, ~~68~~ ~~65~~ 64 bytes
```
class P{static void Main(){System.Console.Write(8*8+" bytes");}}
```
[Try it online!](https://tio.run/##Sy7WTc4vSv3/PzknsbhYIaC6uCSxJDNZoSw/M0XBNzEzT0OzOriyuCQ1V885P684PydVL7wosyRVw0LLQltJIamyJLVYSdO6tvb/fwA)
[Answer]
# [33](https://github.com/TheOnlyMrCat/33), 14 bytes
Technically non-competing, as I made the language after this challenge was posted.
```
2c7xo" bytes"p
```
Pretty simple. Multiplies 2 and 7.
[Answer]
# [Runic Enchantments](https://github.com/Draco18s/RunicEnchantments/tree/Console), 10 bytes
```
` ā`XESa@
```
[Try it online!](https://tio.run/##KyrNy0z@/z9B4UhjQoRrcKLD//8A "Runic Enchantments – Try It Online")
Huh, I thumbed this one up and never answered it.
`ā` encodes the value 257 (still shorter than any other method) which gets multiplied by 10 and converted to a word via a dictionary. `2570` happens to be `bytes`. `a` encodes `10` (`b`-`f` encode `11` through `15`) and gets around the "no digits" restriction. And conveniently enough, the rest of the program is 9 bytes.
Doesn't end up being shorter than `" bytes"a@` (also 10 bytes), but oh well.
[Answer]
## [W](https://github.com/A-ee/w) `d`, 7 bytes
```
♣êæ█☺₧K
```
## Explanation
Unpacked:
```
7 bytes"
```
[Answer]
# [RProgN 2](https://github.com/TehFlaminTaco/RProgN-2), 10 bytes
```
°' Bytes'.
```
# Explination
```
°           # Push 10 to the stack
 ' Bytes'   # Push the literal string " Bytes" to the stack
         .  # Concatenate. Implicit print.
```
[Try it online!](https://tio.run/##Kyooyk/P0zX6///QBnUFp8qS1GJ1vf//AQ "RProgN 2 – Try It Online")
[Answer]
# [Golfscript](http://www.golfscript.com/golfscript/), 12 bytes
```
6 6+" bytes"
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/30zBTFtJIamyJLVY6f9/AA)
[Answer]
## Javascript, 15 bytes
`j=>0xf+' bytes'`
Seems like the obvious answer.
Alternative:
`j=>9+6+' bytes'`
[Answer]
# [RAMDISP, ~~133~~ 26 bytes](https://github.com/Oderjunkie/RAMDISP)
~~There's room for improvement.~~
```
[P[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]][*[[[[]]]]][+[[[]]]][S[; bytes]]]]
```
i honestly don't even remember how i did this, i attached a debugger, and found it it calculates 3 \* 37 + 2.
```
[P[5[*5][+1][S[; bytes]]]]
```
26 = 5\*5+1
[Answer]
# PICO-8, 25 bytes
```
print(ord("」").." bytes")
```
`ord()` gets the index of a character, and `」` is character 25 in [P8SCII](https://pico-8.fandom.com/wiki/P8SCII).
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 13 bytes
```
dn'setyb '>o<
```
[Try it online!](https://tio.run/##S8sszvj/PyVPvTi1pDJJQd0u3@b/fwA "><> – Try It Online")
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `ṡ`, 5 bytes
```
4›`¨∞
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyLhuaEiLCIiLCI04oC6YMKo4oieIiwiIiwiIl0=)
## Explanation :
```
4     # push 4
 ›    # increment
  `¨∞ # push "Bytes"
      # flag `ṡ` => join with space
      # implicit output
```
[Answer]
# [Haskell](https://www.haskell.org/), 34 bytes
```
main=putStr$show(0x1D+5)++" bytes"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM8@2oLQkuKRIpTgjv1zDoMLQRdtUU1tbSSGpsiS1WOn/fwA "Haskell – Try It Online")
[Answer]
# dc, 14 bytes
```
7d+n[ bytes]p
```
Double it
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGLOnline), 8 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
┌`m39Σ³‘
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUyNTBDJTYwbTM5JXUwM0EzJUIzJXUyMDE4,v=0.12)
]


[Question]
      [
The three-dimensional Levi-Civita symbol is a function `f` taking triples of numbers `(i,j,k)` each in `{1,2,3}`, to `{-1,0,1}`, defined as:
* `f(i,j,k) = 0` when `i,j,k` are not distinct, i.e. `i=j` or `j=k` or `k=i`
* `f(i,j,k) = 1` when `(i,j,k)` is a cyclic shift of `(1,2,3)`, that is one of `(1,2,3), (2,3,1), (3,1,2)`.
* `f(i,j,k) = -1` when `(i,j,k)` is a cyclic shift of `(3,2,1)`, that is one of `(3,2,1), (2,1,3), (1,3,2)`.
The result is the [sign](https://en.wikipedia.org/wiki/Parity_of_a_permutation) of a permutation of `(1,2,3)`, with non-permutations giving 0. Alternatively, if we associate the values `1,2,3` with orthogonal unit basis vectors `e_1, e_2, e_3`, then `f(i,j,k)` is the [determinant](https://en.wikipedia.org/wiki/Determinant) of the 3x3 matrix with columns `e_i, e_j, e_k`.
**Input**
Three numbers each from `{1,2,3}` in order. Or, you may choose to use zero-indexed `{0,1,2}`.
**Output**
Their Levi-Civita function value from `{-1,0,1}`. This is code golf.
**Test cases**
There are 27 possible inputs.
```
(1, 1, 1) => 0
(1, 1, 2) => 0
(1, 1, 3) => 0
(1, 2, 1) => 0
(1, 2, 2) => 0
(1, 2, 3) => 1
(1, 3, 1) => 0
(1, 3, 2) => -1
(1, 3, 3) => 0
(2, 1, 1) => 0
(2, 1, 2) => 0
(2, 1, 3) => -1
(2, 2, 1) => 0
(2, 2, 2) => 0
(2, 2, 3) => 0
(2, 3, 1) => 1
(2, 3, 2) => 0
(2, 3, 3) => 0
(3, 1, 1) => 0
(3, 1, 2) => 1
(3, 1, 3) => 0
(3, 2, 1) => -1
(3, 2, 2) => 0
(3, 2, 3) => 0
(3, 3, 1) => 0
(3, 3, 2) => 0
(3, 3, 3) => 0
```

[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
ṁ4IṠS
```
[Try it online!](https://tio.run/##ASEA3v9qZWxsef//4bmBNEnhuaBT/zPhuZczwrU7IsOH4oKsR/8 "Jelly – Try It Online")
### Algorithm
Let's consider the differences **j-i, k-j, i-k**.
* If **(i, j, k)** is a rotation of **(1, 2, 3)**, the differences are a rotation of **(1, 1, -2)**. Taking the sum of the signs, we get **1 + 1 + (-1) = 1**.
* If **(i, j, k)** is a rotation of **(3, 2, 1)**, the differences are a rotation of **(-1, -1, 2)**. Taking the sum of the signs, we get **(-1) + (-1) + 1 = -1**.
* For **(i, i, j)** (or a rotation), where **i** and **j** may be equal, the differences are **(0, j-i, i-j)**. The signs of **j-i** and **i-j** are opposite, so the sum of the signs is **0 + 0 = 0**.
### Code
```
ṁ4IṠS  Main link. Argument: [i, j, k]
ṁ4     Mold 4; yield [i, j, k, i].
  I    Increments; yield [j-i, k-j, i-k].
   Ṡ   Take the signs, replacing 2 and -2 with 1 and -1 (resp.).
    S  Take the sum.
```
[Answer]
# [Python 2](https://docs.python.org/2/), 32 bytes
```
lambda i,j,k:(i-j)*(j-k)*(k-i)/2
```
[Try it online!](https://tio.run/##XcoxCoNAEEbhWk/xN@JumEVcO0FPkkYRyczoKmLj6TfGQjDNKz7eeuyfJfg4osE7Tt3cDx2YhLQ27MS@jDg9q45tcW7LBgYHlARPqOo0@ZE86TL9s2TdOOwwTBCCWkLuWmR@yJFhvDl@AQ "Python 2 – Try It Online")
### Algorithm
Let's consider the differences **i-j, j-k, k-i**.
* If **(i, j, k)** is a rotation of **(1, 2, 3)**, the differences are a rotation of **(-1, -1, 2)**. Taking the product, we get **(-1) × (-1) × 2 = 2**.
* If **(i, j, k)** is a rotation of **(3, 2, 1)**, the differences are a rotation of **(1, 1, -2)**. Taking the product, we get **1 × 1 × (-2) = -2**.
* For **(i, i, j)** (or a rotation), where **i** and **j** may be equal, the differences are **(0, i-j, j-i)**. Taking the product, we get **0 × (i-j) × (j-i) = 0**.
Thus, dividing the product of the differences by **2** yields the desired result.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 9 bytes
```
Signature
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n6Zgq/A/ODM9L7GktCj1f0BRZl5JtLKOgpKCrp2Cko5CWrRybKyCmoK@g0JIaUFOanF0taGOgpGOgnEtEMf@BwA "Wolfram Language (Mathematica) – Try It Online")
---
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 18 bytes
Saved 2 bytes thanks to Martin Ender.
```
Det@{#^0,#,#^2}/2&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n6Zgq/DfJbXEoVo5zkBHWUc5zqhW30jtf0BRZl5JtLKOgpKCrp2Cko5CWrRybKyCmoK@g0JIaUFOanF0taGOgpGOgnEtEMf@BwA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# x86, 15 bytes
Takes arguments in `%al`, `%dl`, `%bl`, returns in `%al`. Straightforward implementation using Dennis's formula.
```
 6: 88 c1                   mov    %al,%cl
 8: 28 d0                   sub    %dl,%al
 a: 28 da                   sub    %bl,%dl
 c: 28 cb                   sub    %cl,%bl
 e: f6 e3                   mul    %bl
10: f6 e2                   mul    %dl
12: d0 f8                   sar    %al
14: c3                      retq
```
Aside: I think I understand why `%eax` is the "accumulator" now...
[Answer]
# Octave, 20 bytes
```
@(v)det(eye(3)(:,v))
```
Pretty direct implementation of the determinant formula. Permutes the columns of the identity matrix then takes the determinant.
[Answer]
# [Haskell](https://www.haskell.org/), 26 bytes
```
(x#y)z=(x-y)*(y-z)*(z-x)/2
```
[Try it online!](https://tio.run/##TYpBDkAwFAWv8hKb/6Ul2HIEJxCLLiS@IoJF27h7dcdmMpPMbC47rWuM5DLPoSOnPefkdUgM2nFZx83Ijg6bOXocp@w3BiJRWBQsK5Agw8LJ8UDQagxVUTRjGv5hvxjjCw "Haskell – Try It Online")
Nasty IEEE floats...
[Answer]
# JavaScript (ES6), 38 bytes
Overcomplicated but fun:
```
(a,b,c,k=(a+b*7+c*13)%18)=>k-12?+!k:-1
```
[Try it online!](https://tio.run/##ZZJNa4QwEEDv/oopWEzWZGkmh5YtcfHQQmmhP0CEjan2w2UtWnoRf7td6@LqDgQPz3nJO8yX/bWNqz@/f@Shesv7wvTMikw4URpmw2x1G7qV0vxa3XETlVLhNrwqN1L1MRhIPIAkUQKGkwq4ScWMICF6SZBYSCwcLXUmmlh6tORyaP4YkkQkiTglThchaUTSiFPjjJwa1YIgmZlbmiTqKVEtyIV1KpRqgZAMXWiaPKaJNSV66b3nxeuiqh@s@2AsSf6X5PivTjmYCFx1aKp9vt5X72zH/NZ2wm@z4eM6DjICv63z5rgyxbhevBsIGAMD3kLw@hzABoLH@Okl6Hac938 "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 28 bytes
Using the standard formula:
```
(a,b,c)=>(a-b)*(b-c)*(c-a)/2
```
[Try it online!](https://tio.run/##ZZJNa4QwEEDv/oo5CCYl2TaT25ZYPLRQWugPCMLGVPvBsilaehF/u9WupLoDksPLPPMO8@l@XOfbj69veQqv9diYkTlRCc9Nzpys@BWrpJ9OLx2/xrEAAzYBsFYJmL9SwE0pVgQJ0VuCxEJi4dlS/0QTS58tuR1aP4YkEUkixsT4IySNSBoxNq7I0qg2BMnM2tIkUcdEtSEX1lIo1QYhGbrQNHlMEysmJuVtkhS7JrT3zr8zZu3fakx3bcnB5ODDqQvHencMb@zA0t4NIu2r@fADB5lD2rd1N61MsyzVMBMwBmZ8B9nLUwZ7yB6Kx@dsOHA@/gI "JavaScript (Node.js) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~7~~ 5 bytes
*1 byte saved thanks to @Emigna*
```
ĆR¥P;
```
[Try it online!](https://tio.run/##MzBNTDJM/f//SFvQoaUB1v//RxvpKBjqKBjHAgA "05AB1E – Try It Online")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~11~~ 9 bytes
*2 bytes saved thanks to @ngn*
```
+/×2-/4⍴⎕
```
[Try it online!](https://tio.run/##Lcy9DUBQAEXh3hR6EXGvhSRCI6E1AQ2dWMQGNnmLPH8nt7jJKb567PNmqvuhi2GZ25gV16G8qMJ6hm1/W2yTMn2W/C/e34suuuimm@6vC0c4whGOcIQjHOEIxzjGMY5xjGMc4xjnfd8 "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 28 bytes
```
->a,b,c{(a-b)*(b-c)*(c-a)/2}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y5RJ0knuVojUTdJU0sjSTcZSCbrJmrqG9X@L7KN1jLQ0zOK5SrSKyjKTylNLtEo0inS1MtNLKiuyawBa7XNtC5QiM7USYsGc2Nja/8DAA "Ruby – Try It Online")
[Answer]
## CJam (16 bytes)
```
1q~{)1$f-@+:*\}h
```
[Online demo](http://cjam.aditsu.net/#code=1q~%7B)1%24f-%40%2B%3A*%5C%7Dh&input=%5B3%202%202%5D). Note that this is based on [a previous answer of mine](https://codegolf.stackexchange.com/a/143775/194) which uses the Levi-Civita symbol to calculate the Jacobi symbol.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 56 bytes
```
->t{t.uniq!? 0:(0..2).any?{|r|t.sort==t.rotate(r)}?1:-1}
```
[Try it online!](https://tio.run/##bU7bioQwDH33K7IFoYIW67wJHT9EZOhqZQWn7fYCzlq/3Smu7tMSQpJzkpxj/OdrH9le3N3qiJfT90cDZY1LQqqMcPlq1mCCI1YZx5gjRjnuBDbZ1tC6oNuuvNPeWWDQlvkVNGZBz@Gvof@xMbqkpXmV3zpihBbx/fDQwjx9VJqUxLeM/Ewan0IZEbz/gkFBmGQEchCLFn08CglAPyspopeDIk@u17CEZYuMEdbPLlJjeyx1ETuMo9RCcYe0soBTmyFIoT0//95clbFLCRpAmluLoAY08mlGXSLksL8B "Ruby – Try It Online")
Once we rule out cases where the values of the triplet are not unique, `t.sort` is equivalent to (and shorter than) `[1,2,3]` or `[*1..3]`
```
->t{
  t.uniq! ? 0                     # If applying uniq modifies the input, return 0
          : (0..2).any?{|r|       # Check r from 0 to 2:
              t.sort==t.rotate(r) #   If rotating the input r times gives [1,2,3],
            } ? 1                 #     return 1;
              :-1                 #     else return -1
}
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 7 bytes
```
ṁ±Ẋ-S:←
```
[Try it online!](https://tio.run/##yygtzv7//@HOxkMbH@7q0g22etQ24f///9FGOsY6hrEA "Husk – Try It Online")
# Explanation
Straight port of Dennis's [Jelly answer](https://codegolf.stackexchange.com/a/160365/78915). `S:←` copies the head of the list to the end, `Ẋ-` takes adjacent differences, and `ṁ±` takes the sign of each element and sums the result.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
⁼QȧIḂÐfḢ
```
[Try it online!](https://tio.run/##ASMA3P9qZWxsef//4oG8UcinSeG4gsOQZuG4ov///1szLCAyLCAxXQ "Jelly – Try It Online")
Seems too ungolfed. :(
[Answer]
# [Add++](https://github.com/cairdcoinheringaahing/AddPlusPlus), 13 bytes
```
L,@dV@GÑ_@€?s
```
[Try it online!](https://tio.run/##S0xJKSj4/99HxyElzMH98MR4h0dNa@yL/6vkJOYmpSQqGNoBkbGdEZc/F5KQkZ2hnSG6kDFI6D8A "Add++ – Try It Online")
[Answer]
**SHELL**, **44 Bytes**
```
 F(){ bc<<<\($2-$1\)*\($3-$1\)*\($3-$2\)/2;}
```
tests :
```
 F 1 2 3
 1
 F 1 1 2
 0
 F  2 3 1
 1
 F 3 1 2
 1
 F 3 2 1
 -1
 F 2 1 3
 -1
 F 1 3 2
 -1
 F 1 3 1
 0
```
Explanation :
```
 The formula is : ((j - i)*(k - i)*(k - j))/2
```
**BC**, **42 Bytes**
```
 define f(i,j,k){return(j-i)*(k-i)*(k-j)/2}
```
tests:
```
 f(3,2,1)
 -1
 f(1,2,3)
 1
 f(1,2,1)
 0
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
äN§lüy²Å
```
[Run and debug it](https://staxlang.xyz/#p=844e156c8179fd8f&i=[1,1,1]%0A[1,1,2]%0A[1,1,3]%0A[1,2,1]%0A[1,2,2]%0A[1,2,3]%0A[1,3,1]%0A[1,3,2]%0A[1,3,3]%0A[2,1,1]%0A[2,1,2]%0A[2,1,3]%0A[2,2,1]%0A[2,2,2]%0A[2,2,3]%0A[2,3,1]%0A[2,3,2]%0A[2,3,3]%0A[3,1,1]%0A[3,1,2]%0A[3,1,3]%0A[3,2,1]%0A[3,2,2]%0A[3,2,3]%0A[3,3,1]%0A[3,3,2]%0A[3,3,3]&a=1&m=2)
Translates to `-(b-a)(c-b)(a-c)/2`.
[Answer]
# [J](http://jsoftware.com/), 12 bytes
```
1#.2*@-/\4$]
```
[Try it online!](https://tio.run/##Tc0xCsJQFETRPqsYVAiK@ZoZq4AgCFZW1lqJQWzcf/U1VS6PVwxcOJ@6KO2o46BWW@01/L8rOt@ul9ovizenbnc/rB513ah5Pd9fjeqn4zBH5mFmZmZmYRZmmTMTNVETNVETNVETNVETDdEQDdEQDdEQDdEQnUbqDw "J – Try It Online")
Direct translation of Uriel's APL solution into J.
## Explanation:
`4$]` Extends the list with its first item
`2 /\` do the following for all the overlapping pairs in the list:
`*@-` find the sign of their difference
`1#.` add up
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 bytes
```
änUÌ xg
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=5G5VzCB4Zw==&input=WzEsMiwzXQ==)
---
## Explanation
```
            :Implicit input of array U
ä           :Get each consecutive pair of elements
 n          :Reduce by subtracting the first from the last
  UÌ        :But, before doing that, prepend the last element in U
     g      :Get the signs
    x       :Reduce by addition
```
---
## Alternative
Takes input as individual integers.
```
NänW ×z
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=TuRuVyDXeg==&input=MSwyLDM=)
[Answer]
# Java 8, 28 bytes
```
(i,j,k)->(i-j)*(j-k)*(k-i)/2
```
Port of [*@Dennis*' Python 2 answer](https://codegolf.stackexchange.com/a/160375/52210).
[Try it online.](https://tio.run/##ZZJBTsMwEEX3nGKUlUPiIGZ2VHADuukSWJg0INupWzVuJYR69uA4WdB@yflSxn6at/jOnI12Wz@2vRkGejU2/N4R2RC745dpO1pPv3lArZrS1lO6nL5cpdtL@tIZoom2pTUFeqZR2drVvtQvympX3iunfUqvbfnA42omDqfPPhELeN7bLe2SgNrEow3fbx@mnJfHbojqsabp5I1XI8aR3IwYQUaQERQEBUG5ARlVGVUZVRlVGVUZVRlVGVUZVQVVBVUFVQVVBVUFVQVVBVXln@p1v3JN8hts41yXzc8Qu12zP8XmkIoU@6BsVdRF5XL6qnh6j0UVmnYp6bLlMv4B)
[Answer]
# [Python](https://docs.python.org/2/), 33 bytes
```
lambda i,j,k:(i^j!=k or-~j-i)%3-1
```
[Try it online!](https://tio.run/##VY7NCsMgEAbP8Sm2h4KCQl1vAd@kFFLaEJM0DWIpvfTV7U@MccHL8I3LzK/Q3SeMrT3GsbmdLw042cuh5u7U7@wAd6/evXJib5SOz86NV9A1sIr/NSEDWHDT/AhcsMp/oU0Lq2bvpgBZlN7aEDnXEn5PSDgItiJSNAUilZHKuMg6oaGyWWRVzPk00g6kHZg7ls9IQ5CGYA5ZMYXoDZGuWTa0w@QOvWEppwylN0Y6l7ahpw2Vc8cH "Python 2 – Try It Online")
I tried for a while to beat the [product-of-differences approach](https://codegolf.stackexchange.com/a/160375/20260), but the best I got was 1 byte longer.
]


[Question]
      [
# The Task
In this challenge, your task is to write a program or function which takes in a String and outputs a truthy or falsey value based on whether the first character and the last character of the input String are equal.
## Input
You may take input in any way reasonable way. However, assuming that the input is present in a predefined variable is not allowed. Reading from a file, console, command line, input field etc., or taking input as a function argument is allowed.
## Output
You may output in any reasonable format, except for assigning the result to a variable. Writing to a file, console, command line, modal box, function `return` statements etc. is allowed.
## Additional Rules
* The input can be empty String as well, for which you should return a falsey value.
* Single-Char Input Strings should have a truthy result.
* Your program should be case-sensitive. `helloH` should output a falsey value.
* You can only have a single Truthy value and a single Falsey value. For example, outputting `false` for an Input String and `0` for another input String as Falsey values is not allowed.
* [Standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are not allowed.
## Test Cases
```
Input    ->    Output
"10h01"        Truthy
"Nothing"      Falsey
"Acccca"       Falsey
"eraser"       Falsey
"erase"        Truthy
"wow!"         Falsey
"wow"          Truthy
"H"            Truthy
""             Falsey
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins!

[Answer]
# Perl 5: 28 bytes
```
exit$ARGV[0]=~/^(.)(.*\1)?$/
```
Similar to perl 6 but it seems to be shorter as a program.
[Answer]
# PowerShell, 42 bytes
```
$a=(read-host);$a-ne""-and$a[0]-ceq$a[-1]
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 55 bytes
```
(({})<(())>)({}[<{({}<>)<>}><>{}]<>)((){[()](<{}>)}{})
```
[Try it online!](https://tio.run/nexus/brain-flak#DYuxCQAxEMPWsYvfwHiRkCJzGM9@f40QCA2QUgBprh5lKVOu5fSub80BL5Sa3WFmvvcD "Brain-Flak – TIO Nexus")
[Answer]
# [Actually](https://github.com/Mego/Seriously), 10 bytes
```
;;lb)F@N=*
```
[Try it online!](https://tio.run/nexus/actually#@29tnZOk6ebgZ6v1/7@SEgA "Actually – TIO Nexus")
Explanation:
```
;;lb)F@N=*
;;          copy input twice
  lb        length of input, cast to boolean
    )F      first character
      @N    last character
        =   compare equality
         *  multiply by boolean casted length (to make empty strings falsey)
```
[Answer]
# REXX 32 Bytes
```
a=arg(1)
say abbrev(a,right(a,1))
```
Tests if the last character is a valid abbreviation of the whole string.
[Answer]
# [Chip](https://github.com/Phlarx/chip), 91+3 = 94 bytes
```
*Z~.
,-{mA
>{xmB
|BA|
|CD|AvB
>{xmC+G
>-{mD+H
>{-mE+~t
>x{mF^S
|EF|
|HG|
>x{mG
>{-mH
Z--)~a
```
+3 for `-z`
Outputs the byte `0x0` for falsey, and `0x1` for truthy. This is a lot bigger than I was hoping, sadly.
[Try it online!](https://tio.run/##S87ILPj/XyuqTo9LR7c615HLrroi14mrxsmxhqvG2aXGscwJLOSs7c5lB1Tgou0B5OvmumrXlXDZVVTnusUFc9W4ugFVe7jXgEXcwQo8uKJ0dTXrErlStdL@/8/4r1tVBgA "Chip – Try It Online") (Note about the TIO: it includes an extra line `e*f` to map the output to ASCII digits. TIO also includes the verbose flag `-v`, which gives extra debug output via stderr.)
The first line produces a signal on only the first byte, allowing us to store that byte's bits, and to detect the empty string. (If we could give a truthy value for the empty string, -3 bytes.)
The last line deals with output, producing truthy only if the first and most recent bytes match, and if it isn't the first byte. Output is given one byte after the end of the input, with the help of `-z`. If not, we would be unable to detect the end of the string. (If we swapped truthy and falsey, -2 bytes, or if combined with empty string savings above, -4 for the both.)
The blob to the right, surrounding the `+`'s, is what triggers the end of input behavior. This actually looks for a zero byte, meaning that incorrect results may occur if one is given as input.
The remainder of the elements perform the actual comparison. This comparison performed is equivalent to, in C-ish: `!(input[0] xor input[n])`. In Chip, however, this must be performed for each bit individually, hence the eight sets of memory cells `m`, xor-gates `{`, and so on.
There is an interesting caveat to this implementation, in that it can handle 8 bits, but is unaware of unicode. So, effectively, this compares the first and last *bytes*, rather than *chars*.
[Answer]
# Axiom, 30 bytes
```
f(a)==(#a=0=>false;a.1=a.(#a))
```
this below seems not to be ok
```
f(a)==(#a=0=>false;a.#a=a.1)
```
[Answer]
# TI-Basic (TI-84 Plus CE), 17 bytes
```
sub(Ans,1,1)=sub(Ans,length(Ans),1
```
Run with `"string":prgmNAME`. Returns 1 for true and 0 for false.
[Answer]
# J, 12 bytes
```
'({.={:)*.*@#
```
`{.` means start, `=` means equals, and `{:` means end. `*.*@#` means "logical and with the length of the string", i.e., if the length is 0, it returns 0.
[Answer]
## Powershell, 30 bytes
```
"$args"|%{!($_[0]-$_[-1]+!$_)}
```
[Try it online](https://tio.run/nexus/powershell#U0myrf6vpJJYlF6sVKNaraihEh9tEKsLJHUNY7UVVeI1a//Xcqmr66hnpObk5ANpEyNDcwMQvzQDTIIImLCJOtAMNZUkBZX42v8A)
[Answer]
## Clojure: 21, 27 or 34 bytes
**depending on the handling of "" test case**
`true` for "aba" and "", `false` for "abc":
```
#(=(first %)(last %))
```
`true` for "aba", `nil` for "", `false` for "abc":
```
#(first(map =(reverse %)%))
```
`true` for "aba", `nil` for "" and "abc":
```
#(or(first(map =(reverse %)%))nil)
```
[Answer]
# PowerShell, 25 Bytes
```
($a="$args")[0]-ceq$a[-1]
```
gets the first char and last char, performed a case-sensitive comparison of them.
[Answer]
# Perl 5, 22+1 (-p flag)=23 bytes
```
/^(.).*(.)/;$_=$1 eq$2
```
Outputs 1 for truthy and an empty string for falsey.
[Answer]
# q/kdb+, ~~21~~ ~~20~~ 18 bytes
**Solution:**
```
{#:[x]&(1#x)~-1#x}
```
**Example:**
```
q){#:[x]&(1#x)~-1#x}"abc"
0
q){#:[x]&(1#x)~-1#x}"abca"
1
q){#:[x]&(1#x)~-1#x}""
0
```
**Explanation:**
Take the first and last elements of the list, check for equality (return boolean 1 or 0), then check length of string, return the minimum of these two results.
```
{                } / anonymous lambda function
             -1#x  / take (#) 1 item from end of list
       (1#x)       / take (#) 1 item from start of list
            ~      / are they equal
 #:[x]             / count (#:) length of list x
      &            / minimum
```
[Answer]
# [J](http://jsoftware.com/), 8 bytes
1 byte thanks to Kritixi Lithos.
```
1{.{.=|.
```
[Try it online!](https://tio.run/##y/r/P83WyrBar1rPtkbvf2pyRr5CmoK6oUGGgaE6F4zrl1@SkZmXjhBwTAaCRAS/PL9cEYUH5@ioeyAkgKyKzJL/AA "J – Try It Online")
[Answer]
# Vim, 30 bytes
```
:s/\v^(.)(.*\1)?$/1
:s/^..\+/
```
Leaves you with `1`, if the string starts and ends with the same character, or nothing, if it doesn't.
[Answer]
# [Tcl](http://tcl.tk/), 34 bytes
```
proc C s {regexp ^(.)(.*\\1)?$ $s}
```
[Try it online!](https://tio.run/##K0nO@f@/oCg/WcFZoVihuig1PbWiQCFOQ09TQ08rJsZQ015FQaW49n9ObmIBSAGXkqFBhoGhEpeSX35JRmZeOpDlmAwEiUoKXErl@eWKSgoKEBaIAWR5gGkQS4mrVqG6oLSkWEFJpVgh2hlocKxS7X8A "Tcl – Try It Online")
[Answer]
# [Julia 0.6](http://julialang.org/), 29 bytes
```
f(x)=x==""?false:x[1]==x[end]
```
[Try it online!](https://tio.run/##yyrNyUw0@/8/TaNC07bC1lZJyT4tMac41aoi2jDW1rYiOjUvJfZ/QVFmXklOnkaahpKhQYaBoZKmpoKCsgIYhBSVlmRUciEp8csvycjMSwcpAqtxAxmIosIxGQgS8Sgozy9XBFsCsQarAqg8xAhMV3gA5ZH5QO5/AA "Julia 0.6 – Try It Online")
[Answer]
# [Perl 6](https://perl6.org), ~~18~~ 17 bytes
```
{?m/^(.)[.*$0]?$/}
```
[Test it](https://tio.run/nexus/perl6#VY9NboMwEIX3PsXUQpWdECCbLgKBdlN11RW7kFaIuAWJP8WmNIqSw7TnyJlyBDogIHQWtvW9eU/PlRTw9WBENskOcB8VOwHr5uhl5hsz@MaYadbW08xTg@qjElLBGtIkF5JxIwvL1ZEAZCtp4gVwvfzQ6@UXzuNLc5K8rJSLLmexoVt31i1qjvguRaTErlWYz72gnqNi2nicB5PuTfZ07Z2cSIVtfWxhkzINc5h3lWzyUez7dguXBZ1bDwYrOnlbM5HQfo91Mtdh1KGNbujSiq0lhX78faXiA6GvhYqT/LPnz2EqBdKnCCcclgdaF/XdGDClNzjmvkzYjf6DfcIf "Perl 6 – TIO Nexus")
```
{?/^(.)[.*$0]?$/}
```
[Test it](https://tio.run/##VY9NboMwFIT3PsUrsio7IUA2WQQC7abqqit2Ia0QcQsSPxY2pVGUHKY9R86UIxCDgNC3sK1v3ozGnJXpqqkEg@@VEdkoO8BjVOwZbJqjZ74Tg26NGbZ2HjZPjRKfJBMSNpAmOROEGlnI10cEkK2FqS6A6@VXu17@4Dy@sJPkvJKucjmLrbZzZ90idtgPZ5Fk@1YhPvWCeq4U01bHeTDp3mRPxx/ohNqyvmphI56GOcy7Sjb6LMq@3cIlQefWg8GqnLStmQhof0c6meow6tBGN9rSiq2lBv34ZSXjA9LeChkn@VfPX8JUMEWfIzXhsDzQuqgfxoApvcMx93XC7vQf7BNu "Perl 6 – Try It Online")
## Expanded:
```
{  # bare block lambda with implicit parameter ｢$_｣
  ?        # Boolify the following
  /        # match implicitly against ｢$_｣
    ^      # beginning of string
    (.)    # character ｢$0｣
    [
      .*   # followed by any number of characters
      $0   # and itself
    ]?     # optionally (Str with a single char)
    $  # end of string
  /
}
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 4 bytes
```
Γ·=→
```
[Try it online!](https://tio.run/##yygtzv7//9zkQ9ttH7VN@v//v1JiUlKiEgA "Husk – Try It Online")
Takes a string as an argument to the program, returns 0 for falsy cases and 1 for truthy cases.
# Explanation:
`Γ` is list deconstruction. The version I'm using (listN) takes a binary function and returns a function that takes a list. This new function returns the default type (0 in this case) for an empty string, and otherwise applies the given function to the head and tail of the string. The binary function I'm giving it is `=` (equality), composed on the second argument (`·`) with `→` (last element of a list).
[Answer]
# SmileBASIC 3, 36 bytes
In SmileBASIC, 0 is false and 1 (or nonzero) is true.
```
LINPUT S$L=LEN(S$)?L&&S$[0]==S$[L-1]
```
Explainer:
```
 LINPUT S$                'read line from console to string S$
 L=LEN(S$)                'store length of line in L
 ? L && S$[0] == S$[L-1]
'| |          |
'| |          \-----------first char equals last char
'| \----------------------length is false if zero, && shortcuts
'\------------------------print
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 11 bytes
```
l?!<{:}=n;!
```
[Try it online!](https://tio.run/##S8sszvj/P8de0abaqtY2z1rx////usWJSYkA "><> – Try It Online")
Takes input through the `-s` flag. You'll need to remove the flag for an empty input.
### How it works
```
l?!<  Go right if there is input, left is there is none
    {:  If there is input, rotate the stack and dupe the first element
        This creates two copies of a one character input
      }=n;  Print if the last character is equal to the first
l  If there is no input, push the length of the stack (0)
        n;!  Wrap around and print the 0
```
[Answer]
# Excel VBA, ~~52~~ ~~48~~ ~~40~~ ~~38~~ ~~37~~ 36 34 Bytes
Anonymous VBE immediate window function that takes input of type `variant` and expected type `variant\String` from cell `[A1]` on the `ActiveSheet` object and outputs boolean response to the VBE immediate window.
```
?[A1]<>""=([Left(A1)]=[Right(A1)])
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 4 bytes
```
h.&t
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFSuVv2obcOjpuZHHcuVSopKU5VqQKy0xJziVKXaciU9BaWHuzprH26d8D9DT63k//9oJUODDANDJR0lv/ySjMy8dCDLMRkIEoGM8vxyRQgFJD2AWCkWAA "Brachylog – Try It Online")
and
# [Brachylog](https://github.com/JCumin/Brachylog), 4 bytes
```
h~t?
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFSuVv2obcOjpuZHHcuVSopKU5VqQKy0xJziVKXaciU9BaWHuzprH26d8D@jrsT@//9oJUODDANDJR0lv/ySjMy8dCDLMRkIEoGM8vxyRQgFJD2AWCkWAA "Brachylog – Try It Online")
are both predicates which try to unify the first and last elements of the input, outputting through success or failure (which prints `true.` or `false.` when it's run as a program).
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 7 bytes
```
)\(@=\;
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/XzNGw8E2xvr///L8cgA "GolfScript – Try It Online")
## Explanation
```
)       # The last character
 \(     # And the first character
   @=\; # Are they equal
```
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 6 bytes
```
l_-]==
```
[Try it online!](https://tio.run/##SyotykktLixN/f8/J1431tb2///EnIKMRAA "Burlesque – Try It Online")
```
l_ # Non-destructive tail, leaving the rest of the string on top of the stack
-] # Destructive head
== # Equal
```
[Answer]
# [MAWP](https://esolangs.org/wiki/MAWP), ~~21~~ 29 bytes
```
|1A<1:.>1M\%_1A<1:.>\A{0:.}1:
```
[Try it!](https://8dion8.github.io/MAWP/v1.1?code=%7C1A%3C1%3A.%3E1M%5C%25_1A%3C1%3A.%3E%5CA%7B0%3A.%7D1%3A&input=HiH)
Fixed for empty input(and single character input, after Lyxal pointed out). If input is empty, it checks if the existing 1 on the stack is still at the top. then checks the length of the input.
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), 3 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
Ć`Q
```
[Try it online](https://tio.run/##MzBNTDJM/f//SFtC4P//AA) or [verify all test cases](https://tio.run/##MzBNTDJM/V9Waa@k8KhtkoKSfeX/I20Jgf91/kcrGRpkGBgq6Sj55ZdkZOalA1mOyUCQCGSkFiUWpxbBGEC6PL9cEUIBSQ8gVooFAA).
**Explanation:**
```
Ć    # Enclose the (implicit) input-string; append its own head
 `   # Pop and push all characters separated to the stack
  Q  # Check if the top/last two are the same
     # (after which the result is output implicitly)
```
The empty test case only works in the legacy version of 05AB1E, because `Q` on an empty stack and without input is apparently falsey. Whereas in the new version of 05AB1E an empty input is interpret as an empty string, in which case `""==""` is truthy.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 3 bytes
```
Ṙ=h
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLhuZg9aCIsIiIsIlsnSCcsICdFJywgJ1MnLCAnSCddIl0=)
Input as a list of chars.
[Answer]
# [Perl 5](https://www.perl.org/) + `-plF`, 15 bytes
This matches the char at the last index of `@F` (`$#F`) against the beginning of the string (`/^.../`) and sets `$_` to the result only if `$_` is truthy (non-empty).
```
$_&&=/^$F[$#F]/
```
[Try it online!](https://dom111.github.io/code-sandbox/#eyJsYW5nIjoid2VicGVybC01LjI4LjEiLCJjb2RlIjoiJF8mJj0vXiRGWyQjRl0vIiwiYXJncyI6Ii1wbEYiLCJpbnB1dCI6IjEwaDAxXG5Ob3RoaW5nXG5BY2NjY2FcbmVyYXNlclxuZXJhc2VcbndvdyFcbndvd1xuSFxuXG4ifQ==)
---
# [Perl 5](https://www.perl.org/) + `-plF/^.*(.)$/`, 11 bytes
If we abuse `-F` so that it will only include the final char, we can save four more bytes. The trailing `/x` is necessary as `@F` will contain two indices, empty string at `0` and the desired char at `1` which when interpolated results in a leading space.
```
$_&&=/^@F/x
```
[Try it online!](https://dom111.github.io/code-sandbox/#eyJsYW5nIjoid2VicGVybC01LjI4LjEiLCJjb2RlIjoiJF8mJj0vXkBGL3giLCJhcmdzIjoiLXBsRi9eLiooLikkLyIsImlucHV0IjoiMTBoMDFcbk5vdGhpbmdcbkFjY2NjYVxuZXJhc2VyXG5lcmFzZVxud293IVxud293XG5IXG5cbiJ9)
]