14
\$\begingroup\$

Specifications

Given a number n, output an ASCII "meme arrow" (greater-than symbol, >) of size n.

n will always be a positive integer, greater than 0.

Examples

n = 2

\
 \
 /
/

n = 5

\
 \
  \
   \
    \
    /
   /
  /
 /
/

Sample code

Here is a sample program, written in Crystal, that returns the correct results. Run it as ./arrow 10.

arrow.cr:

def f(i)
        i.times { |j|
                j.times { print ' ' }
                puts "\\"
        }
        i.times { |j|
                (i-j-1).times { print ' ' }
                puts '/'
        }
end

f(ARGV[0].to_i)

Rules

  • This is . The shortest answer wins. However, I will not select an answer, because the shortest answer may change over time.
  • Standard loopholes are not allowed.
| improve this question | | | | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Are you sure this is not a duplicate (that is, did you sandbox this)? I think this is likely to be, but it's slightly nearly impossible to search for. \$\endgroup\$ – my pronoun is monicareinstate Jun 9 '19 at 4:46
  • 1
    \$\begingroup\$ Can n be zero? \$\endgroup\$ – xnor Jun 9 '19 at 6:05
  • 6
    \$\begingroup\$ I think it's pretty silly to call this common symbol a "meme arrow". They're obviously comedy chevrons. \$\endgroup\$ – scatter Jun 10 '19 at 18:04
  • 4
    \$\begingroup\$ @Christian They're actually amusing angles \$\endgroup\$ – dkudriavtsev Jun 10 '19 at 20:39
  • 2
    \$\begingroup\$ @ArtemisFowl I thought they were interesting increases \$\endgroup\$ – dkudriavtsev Jun 12 '19 at 22:17

42 Answers 42

12
\$\begingroup\$

Canvas, 2 bytes

\═

Try it here!

| improve this answer | | | | |
\$\endgroup\$
8
\$\begingroup\$

C (gcc), 56 bytes

f(n,i){for(i=-n;n;printf("%*c\n",i?++i+n:n--,i?92:47));}

Try it online!

f(n,i){for(i=-n;i;printf("%*c\n",  ++i+n    ,  92   ));     //first print descending '\'s
       for(    ;n;printf("%*c\n",        n--,     47));}    // then print returning  '/'s
| improve this answer | | | | |
\$\endgroup\$
6
\$\begingroup\$

Python 2, 54 bytes

f=lambda n,p='':n*'?'and p+'\\\n'+f(n-1,p+' ')+p+'/\n'

Try it online!

Outputs with a trailing newline.

| improve this answer | | | | |
\$\endgroup\$
5
\$\begingroup\$

05AB1E, 6 bytes

'\3.Λ∊

Try it online!

Explanation

   .Λ    # draw
'\       # the string "\"
         # of length input
  3      # in the south-eastern direction
     ∊   # then vertically mirror it
| improve this answer | | | | |
\$\endgroup\$
4
\$\begingroup\$

C# (Visual C# Interactive Compiler), 66 bytes

n=>new int[n*2].Select((a,b)=>"".PadLeft(b<n?b:n*2+~b)+"\\/"[b/n])

Saved a byte thanks to @someone.

Try it online!

| improve this answer | | | | |
\$\endgroup\$
4
\$\begingroup\$

C64Mini/C64 BASIC (and other CBM BASIC variants), 52 tokenized BASIC bytes used

 0INPUTN:N=N-1:FORI=0TON:PRINTTAB(I)"\":NEXT:FORI=NTO0STEP-1:PRINTTAB(I)"/":NEXT

Here is the non-obfuscated version for exaplantion:

 0 INPUT N
 1 LET N=N-1
 2 FOR I=0 TO N
 3  PRINT TAB(I);"\"
 4 NEXT I
 5 FOR I=N TO 0 STEP -1
 6  PRINT TAB(I);"/"
 7 NEXT I

What ever number is entered into N in line zero is reduced by one as the TAB command is zero-indexed; The FOR/NEXT loops in lines two through to four and five through to seven then output the upper and lower part if the meme arrow respectively (represented by a shifted M and shifted N in graphics mode source)

Commodore C64 meme arrow

| improve this answer | | | | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Did you know that in Commodore Basic all keywords can be abbreviated? Here's a link: c64-wiki.com/wiki/BASIC_keyword_abbreviation For example, for can be fO (f - shoft o), print is ?, etc. \$\endgroup\$ – gaborsch Jun 15 '19 at 17:09
  • 1
    \$\begingroup\$ 52 bytes is misleading in Code Golf, the binaries don't count, just the source code. It shoulf be something ike this: 0inputn:n=n-1:fOi=0ton:?tA(i)"\":nE:fOi=0ton:?tA(i)"/":nE - it takes 57 bytes. \$\endgroup\$ – gaborsch Jun 15 '19 at 17:10
  • 1
    \$\begingroup\$ As discussed here -> codegolf.meta.stackexchange.com/questions/11553/… I count the tokens used as this is more representative of how much of the memory is being used. \$\endgroup\$ – Shaun Bebbers Jun 17 '19 at 8:39
  • 1
    \$\begingroup\$ Oh, I didn't know this. Is there a decision about this? Even the answer has not been accepted there. \$\endgroup\$ – gaborsch Jun 17 '19 at 8:45
  • 1
    \$\begingroup\$ My first computer was a C16, I did a lot of assembly on that, too, so no offence, I love Commodore. C16 had Basic 3,5, 80 chars per line, I also had a book with the ROM listings explained, so I exactly knew how the tokenization and listing worked, \$\endgroup\$ – gaborsch Jun 17 '19 at 9:41
4
\$\begingroup\$

MarioLANG, 719 677 bytes

+
+
+
+
+
+         ((((+)+++++)))<
+>======================"
+)++++++)+++++++++++((-[!)
========================#=-
) ![-    <+;)+++)---)++++)<
)=#======"=================
) >)+)+((!
+ "======#
         <))))).(((((((<
 ========">============"
>)+)+((-[!+))        -[!((((((((.)).))))+(-[!)
"========#=============#====================#<
!)                                          <
#==========================================="
                  >(((((.)))>
                  "========<"========
 ![-)).))).(((((((![-    ))+![-((+)+)<((![<
 #================#=========#========"==#="===
 >                                   !  >-!
 "===================================#  "=#

Try it online!

This was harder than expected...

| improve this answer | | | | |
\$\endgroup\$
4
\$\begingroup\$

brainfuck, 125 bytes

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

Try it online!

++++++++++[->+>+++++++++>+++<<<]>>++>++>    ; Initialize with " \"
,                                           ; Get input
[->                                         ; loop and decrement n 
    [->+<<<.>>]                             ; output number of spaces, copy n
    <<<.                                    ; output \
    <.                                      ; output newline
    >>>>                                    
    >[-<+>]<+                               ; copy copy of n back to original place 
<]
<<[--<<+>>]<<+>>                            ; change "\" to "/"
>>>                             
[                                           ; second loop for bottom half
 -                                          ; decrement n
 [-<+<.>>]                                  ; output n spaces
 <<<<<.>.                                   ; output \ and newline
 >>>[->+<]>                                 ; copy n back
]
| improve this answer | | | | |
\$\endgroup\$
4
\$\begingroup\$

Ruby, 111 99 77 73 68 64 57 56 bytes

-12 bytes thanks to Benjamin Urquhart, -43 thanks to manatwork and -2 bytes thanks to Value Ink.

->i{s=[];puts (0...i).map{|j|s=(p=' '*j)+?/,*s;p+?\\},s}

Try it online!

Explanation:

f=->i{                      # instead of a function, use a lambda
  s=[]                      # needs a helper variable *now*, for scope
  puts(                     # puts takes arbitrary num of args; \n after each
    (0...i).map{|j|         # not from 0 to i but from 0 to i-1 (*three* dots)
      s=(
        p=' '*j             # p will remain in scope inside of .map,
      )
      +?/                   # character literal instead of string
      ,*s                   # essentially appending to the array

      p+?\\                 # p is what's returned by .map, not s!

    },                      # up until here, 1st arg to display
    s                       # NOW, as the *2nd* arg, s is displayed
  )
}

Alternative (but longer) Solutions

A friend read this answer and then tried to come up with a couple more approaches. Putting them here, too, so that they're not lost to the vast interwebs.

inject and unshift, 72 bytes

->n{puts (0...n).inject([]){|s,i|i=' '*(n-1-i);s.unshift i+?\\;s<<i+?/}}

Try it online!

downto, inject and unshift, 80 bytes

->n{puts n.downto(1).map{|i|' '*(i-1)}.inject([]){|s,i|s<<i+?/;s.unshift i+?\\}}

Try it online!

intriguing, two non-nested loops, 127 bytes

->n{
r=->s,c{s[0..-(c+1)],s[-c..-1]=s[c..-1],s[0..c-1];s};
n.times{|i|puts r[' '*n+?\\,n-i]}
n.times{|i|puts r[' '*n+?/,i+1]}
}

Try it online!

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ Can't a lot of that whitespace be removed? \$\endgroup\$ – Benjamin Urquhart Jun 9 '19 at 23:17
  • 1
    \$\begingroup\$ Yes, 12 bytes in total, thank you! This was the first time I submitted anything to a code golf game... \$\endgroup\$ – Sixtyfive Jun 10 '19 at 9:08
  • \$\begingroup\$ Then you may find interesting the Tips for golfing in Ruby, or even the Tips for golfing in <all languages>. \$\endgroup\$ – manatwork Jun 10 '19 at 9:11
  • \$\begingroup\$ You could replace the inner loops for padding with String#rjust (Try it online!). \$\endgroup\$ – manatwork Jun 10 '19 at 9:21
  • \$\begingroup\$ Here I applied some of the tips from the above mentioned 2 collections to reduce it to 57 characters: Try it online! \$\endgroup\$ – manatwork Jun 10 '19 at 9:58
3
\$\begingroup\$

Perl 5 -p, 36 bytes

$\=($q=$"x$_)."\\
$\$q/
"while$_--}{

Try it online!

| improve this answer | | | | |
\$\endgroup\$
3
\$\begingroup\$

T-SQL code, 80 bytes

DECLARE @ INT=3

,@z INT=0
x:PRINT
space(@-abs(@-@z-.5))+char(92-@z/@*45)SET
@z+=1IF @z<@*2GOTO x

Try it online

T-SQL query, 96 bytes

In order to make this work online i had to make some minor alterations. Spaces in the beginning of a row doesn't display in the online snippet. So I am using ascii 160 instead. When running in management studio, it is possible to change the settings to show result as text, which would result in the correct spaces in this posted script.

DECLARE @ INT=3
SELECT space(@-abs(@-number-.5))+char(92-number/@*45)FROM
spt_values WHERE number<@*2and'p'=type

Try it online

| improve this answer | | | | |
\$\endgroup\$
3
\$\begingroup\$

PowerShell, 44 41 bytes

filter f{if($_){'\'
--$_|f|%{" $_"}
'/'}}

Try it online!

| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

Charcoal, 5 bytes

↘N‖M↓

Try it online! Link is to verbose version of code. Explanation:

↘N

Input a number and print a diagonal line of \s of that length.

‖M↓

Reflect the line vertically.

| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

APL(NARS), 40 chars, 80 bytes

{f←{⍺,⍨⍵⍴' '}⋄⊃('\'f¨k),('/'f¨⌽k←¯1+⍳⍵)}

test:

  h←{f←{⍺,⍨⍵⍴' '}⋄⊃('\'f¨k),('/'f¨⌽k←¯1+⍳⍵)}
  h 2
\ 
 \
 /
/ 
  h 5
\    
 \   
  \  
   \ 
    \
    /
   / 
  /  
 /   
/    
| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

Retina 0.8.2, 32 bytes

.+
$* ¶$&$* 
\G.
¶$`\
r`.\G
$'/¶

Try it online! Explanation:

.+
$* ¶$&$* 

Generate two lines of n spaces.

\G.
¶$`\

Turn the top line into a \ diagonal.

r`.\G
$'/¶

Turn the bottom line into a / diagonal.

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

C (gcc), 67 65 bytes

-2 bytes thanks to ceilingcat

f(n,i){for(i=~n;i++<n;)i&&printf("%*c\n",n-abs(i)+1,"/\\"[i<0]);}

Try it online!

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

Python 2, 85 84 81 80 75 bytes

def a(n):l="for i in range(n):print' '*";exec l+"i+'\\\\'\n"+l+"(n+~i)+'/'"

Try it online!

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

PowerShell, 50 bytes

param($n)0..--$n|%{' '*$_+'\'}
$n..0|%{' '*$_+'/'}

Try it online!

Will look into making it so it only goes through the range once. Not bad for the no brain method though.

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

Twig, 115 bytes

Builds the string backwards, "returning" it in the end.

Uses a macro to generate all the results.

{%macro a(N,s="")%}{%for i in N..1%}{%set s=('%'~i~'s
'~s~'%'~i~'s
')|format('\\','/')%}{%endfor%}{{s}}{%endmacro%}

This macro has to be in a file, and imported like this:

{% import 'macro.twig' as a %}

{{ a.a(<value>) }}

You can try it on https://twigfiddle.com/5hzlpz (click on "Show raw result").

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

Haskell, 52 49 bytes

-3 bytes thanks to Sriotchilism O'Zaic.

unlines.g
g 0=[]
g n="\\":map(' ':)(g$n-1)++["/"]

Try it online!

| improve this answer | | | | |
\$\endgroup\$
  • 1
    \$\begingroup\$ You can save a byte with g$n-1 instead of g(n-1). You also don't need to count the f= since f never gets referenced. \$\endgroup\$ – Ad Hoc Garf Hunter Jun 10 '19 at 15:53
1
\$\begingroup\$

MATL, 14 13 12 bytes

Xy92*t45-Pvc

1 Byte saved thanks to @LuisMendo

Explanation

        % Implicitly grab the input as an integer
Xy      % Create an identity matrix this size
92*     % Multiply by 92 (ASCII for '\')
t       % Duplicate the matrix
45-     % Subtract 45 from every element yielding 47 (ASCII for '/') on the diagonal
        % and -45 everywhere else
P       % Vertically flip this matrix
v       % Vertically concatenate the two matrices
c       % Convert to characters (negative numbers are replaced with a space)
        % Implicitly display the result

Try it out at MATL Online

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ @LuisMendo Updated! Thanks! \$\endgroup\$ – Suever Jun 11 '19 at 13:39
1
\$\begingroup\$

Python 3, 90 83 bytes

lambda n:'\n'.join([' '*i+'\\'for i in range(n)]+[' '*(n+~i)+'/'for i in range(n)])

Try it online!

-7 bytes thanks to @squid

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ 83 bytes, but I feel like it can still go down \$\endgroup\$ – squid Jun 13 '19 at 12:55
  • 1
    \$\begingroup\$ I wish this was possible. \$\endgroup\$ – Artemis still doesn't trust SE Jun 13 '19 at 14:45
  • \$\begingroup\$ Soon... \$\endgroup\$ – squid Jun 13 '19 at 14:50
  • \$\begingroup\$ Oh yeah I forgot about that. Maybe you should submit it! \$\endgroup\$ – Artemis still doesn't trust SE Jun 13 '19 at 14:54
1
\$\begingroup\$

Rockstar, 133 bytes

Try it online here!

F takes N,S
If N is 0
Give back N

Say S+"\"
Let T be S+" "
Let M be N-1
F taking M,T
Say S+"/"

Listen to X
F taking X,""

Since Rockstar is not famous for string operations, it takes relatively lots of code to do it (recursively was even longer).

The size of the arrow is taken as input.

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

PHP, 79 63 61 bytes

function f($x,$s=''){if($x)echo"$s\\
",f($x-1,"$s "),"$s/
";}

Try it online!

Recursive in PHP.

-12 bytes by @manatwork

| improve this answer | | | | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Better count down. Try it online!. \$\endgroup\$ – manatwork Jun 17 '19 at 19:05
  • \$\begingroup\$ @manatwork very very nice! \$\endgroup\$ – 640KB Jun 17 '19 at 19:11
1
\$\begingroup\$

\/\/>, 74 bytes

jp100o
-84*}!o:?!x1
@+:q:p=?x:o~$:0(pa"\/"q?$~}}:
x2-:p$1-y$:0(?
.{suh?!;2

Explanation: (lines rotated based on start point)

jp100o                        //setup
:?!x1-84*}!                   //add leading spaces, loop and decrement until 0
~$:0(pa"\/"q?$~}}:@+:q:p=?x:o //add correct slash, go back to loop or switch sides
$:0(?x2-:p$1-y                //flip direction state or continue to print
{suh?!;2.                     //remove extra data and print stack
| improve this answer | | | | |
\$\endgroup\$
  • 1
    \$\begingroup\$ \/\/> (pronounced wɜrm) Thanks, I hate it. (jk, I'm looking forward to giving it a try) \$\endgroup\$ – Jo King Jul 5 '19 at 6:39
  • \$\begingroup\$ @JoKing hahaha, gotta wear my inspiration on my sleeve. (thanks!) \$\endgroup\$ – torcado Jul 5 '19 at 6:42
1
\$\begingroup\$

Python 3, 55 bytes

f=lambda n,i="":n and i+"\\\n"+f(n-1,i+" ")+i+"/\n"or""

Try it online!

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

Erlang (escript), 69 bytes

Port of xnor's Python answer.

r(0,_)->"";r(I,X)->X++"\\\n"++r(I-1,X++" ")++X++"/\n".
r(I)->r(I,"").

Try it online!

| improve this answer | | | | |
\$\endgroup\$
0
\$\begingroup\$

Python 2, 63 bytes

f=lambda n,s='':n and f(n-1,~-n*' '+'\\\n'+s+~-n*' '+'/\n')or s

Try it online!

| improve this answer | | | | |
\$\endgroup\$
0
\$\begingroup\$

Stax, 10 bytes

Ç₧¥╗M'gQ9⌂

Run and debug it

| improve this answer | | | | |
\$\endgroup\$
0
\$\begingroup\$

SimpleTemplate, 100 bytes

This was quite a fun challenge, but some bugs in the language made it hard to optimize.

{@set_ argv.0}{@while_}{@callstr_repeat intoS" ",_}{@setO S,"\\\n",O,S,"/\n"}{@incby-1_}{@/}{@echoO}

Basically, cycles throught the values backwards, working the string from the middle out.


How the answer should be

Due to the bugs, the code wasn't being interpreted properly.

This is how the code would be, if the compiler didn't had any bug (86 bytes):

{@forfrom argv.0to0step-1}{@callrepeat intoS" ",_}{@setO S,"\\
",O,S,"/
"}{@/}{@echoO}

Oh, well, at least the solution works :x

| improve this answer | | | | |
\$\endgroup\$

Your Answer

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

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