The Squiggly Sequence

Question

All credits to Adnan for coming up with this challenge.

My last challenge, before I go on break.

Task

Given positive integer n, if n is odd, repeat / that many times; if n is even, repeat \ that many times.

(Seriously, the testcases would be much clearer than this description, so just look at the testcases.)

Specs

• Any reasonable input/output format.
• Standard loopholes apply.

Testcases

n output
1 /
2 \\
3 ///
4 \\\\
5 /////
6 \\\\\\

Answer 1

Javascript, 22 bytes

n=>"\\/"[n%2].repeat(n)

Defines an anonymous function.

If only * repeated strings in Javascript. sighs

Answer 2

Python, 20 bytes

lambda n:'\/'[n%2]*n

Answer 3

05AB1E/2sable, 15 11 9 8 bytes

DÈ„/\sè×

-2 bytes thanks to Leaky Nun

-1 byte thanks to Emigna

Try it online! in 05AB1E
or in 2sable

Answer 4

Perl, 20 bytes

Includes +1 for -p

Run with input on STDIN:

squigly.pl <<< 6

squigly.pl

#!/usr/bin/perl -p
$_=$_%2x$_;y;01;\\/

Answer 5

J, 10 bytes

#'\/'{~2|]

This is a six-train verb, consisting of:

# ('\/' {~ 2 | ])

This is a hook between # and ('\/' {~ 2 | ]); a hook (f g) y expands to y f (g y), so this expands to y # (... y), which, for single-characters, yields a list of y characters.

The second part is a 5-train, consisting of:

'\/' {~ 2 | ]

This evaluates to two forks:

'\/' {~ (2 | ])

The inner fork, 2 | ], is modulus two. The outer fork, therefore, is:

'\/' {~ mod2

Which takes ({~) the mod2 index (mod2) from the string /.

Then, using the hook from above:

y # (apt char)

This yields what we want, and we are done.

Answer 6

Retina, 21

.+
$*/
T`/`\\`^(..)+$

Try it online (First line added to allow multiple testcases to be run).

Answer 7

C#, 42 bytes

string f(int n)=>new string("\\/"[n%2],n);

Selects the correct character, then creates a new string consisting of that character repeated n times.

Answer 8

PHP, 38 bytes

for(;$i++<$a=$argv[1];)echo'\/'[$a%2];

(variant 38 bytes)

while($i++<$a=$argv[1])echo'\/'[$a%2];

(variant 38 bytes)

<?=str_pad('',$a=$argv[1],'\/'[$a%2]);

(variant 40 bytes)

<?=str_repeat('\/'[($a=$argv[1])%2],$a);

Answer 9

C, 40 bytes

i;f(n){for(i=n;i--;)putchar(n%2?47:92);}

Try it on Ideone

Answer 10

Jelly, 5 bytes

ị⁾/\x

Try it online! or Verify all testcases.

ị⁾/\x

ị⁾/\    modular-indexing into the string "/\"
    x   repeat

Answer 11

Haskell, 25 bytes

f n=cycle"\\/"!!n<$[1..n]

-1 byte thanks to Damien with cycle.

Answer 12

Mathematica, 34 32 28 bytes

If[OddQ@#,"/","\\"]~Table~#&

Anonymous function. Takes an integer as input and returns a list of characters as output.

Answer 13

Mathematica, 29 bytes

"\\"["/"][[#~Mod~2]]~Table~#&

Cruelly exploits the fact that [[1]] returns the first argument of a function while [[0]] returns the function (head) itself, applied to the strangely valid function named "\\" which is being "evaluated" at "/".

Answer 14

Powershell, 30 27 bytes

Update:

param($n)('\','/')[$n%2]*$n

Switching to param, thanks to timmyd.

---

"$("\/"[$args[0]%2])"*$args[0]

or slightly more readable

("\","/")[$args[0]%2]*$args[0]

Test:

> 1..10 | % { ./run.ps1 $_ }
/
\\
///
\\\\
/////
\\\\\\
///////
\\\\\\\\
/////////
\\\\\\\\\\

Answer 15

Ruby, 15 bytes

->n{'\/'[n%2]*n}

See it on eval.in: https://eval.in/632030

Answer 16

Fourier, 27 bytes

92~SI~N%2{1}{47~S}N(Sai^~i)

Try it online!

Answer 17

Brachylog, 15 bytes

:2%:"\/"rm:?jbw

Try it online!

Explanation

:2%                Input mod 2…
   :"\/"rm         …is the index of the element in string "\/",…
          :?j      …element that we juxtapose Input times to itself…
             bw    …and print to STDOUT after removing one slash/backslash

Answer 18

CJam, 9 bytes

ri_"\/"=*

Try it online!

Explanation

ri     e# Read input and convert to integer N.
_      e# Duplicate N.
"\/"=  e# Use N as cyclic index into "\/", giving '\ for even and '/ for odd inputs.
*      e# Repeat N times.

Answer 19

><> (Fish), 30 Bytes

:2%?'/'o1-:?!;30.
30.  >'\'50p

First time using this language, but I think I at least saved a little room by conditionally using the / as either part of the output or a mirror to redirect flow. Probably still horribly inefficient though, I feel like it could probably be cut down a little more at the very least.

Input is the initial stack, output is stdout

Try it online!

Answer 20

Dyalog APL, 11 bytes

Requires ⎕IO←0 which is default on many systems.

⊢⍴'\/'⊃⍨2|⊢

⊢ the argument

⍴ reshapes (repeats)

'\/'⊃⍨ the string "/" selected by

2|⊢ the division remainder when the argument is divided by two

TryAPL online!

Answer 21

Java 11, 68 65 29 bytes

n->(n%2<1?"\\":"/").repeat(n)

-3 bytes saved thanks to @user902383 and @SeanBean
-36 bytes switching from Java 7 to Java 11+

Try it online.

Explanation:

n->                     // Method with integer parameter and String return-type
  (n%2<1?               //  If `n` is even:
         "\\"           //   Use String "\"
        :               //  Else (`n` is odd):
         "/")           //   Use String "/" instead
             .repeat(n) //  Repeat it `n` amount of times

Answer 22

Julia, 20 bytes

!x="$("/\\"[x%2])"^x

Answer 23

R, 47 46 bytes

n=scan();cat(rep(c("\\","/")[n%%2+1],n),sep="")

In R, you have to escape backslashes. the argument sep also has to be fully specified since it comes after .... Thus annoyingly few opportunities to save chars :(

Thanks to bouncyball for golfing away a byte.

Answer 24

T-SQL 50 bytes

Of course no STDIN here, so let's assume a hardcoded INT variable like this: DECLARE @ INT then the solution is:

PRINT IIF(@%2=0,REPLICATE('\',@),REPLICATE('/',@))

Answer 25

Pip, 8 bytes

"\/"@aXa

Straightforward. Uses modular indexing to select the character and string repetition to multiply it. Try it online!

---

This question presents an interesting comparison between Pip, Pyth, and Jelly, the latter two each having scored 5 bytes. All three languages have implicit output, with single-char operators for modular indexing and string repetition, and no requirement to escape backslashes in strings. There are two key differences, though:

1. Under certain circumstances, Pyth and Jelly need only one delimiter to define a string;
2. Pyth and Jelly have syntax such that the input doesn't need to be explicitly represented in the code (though for very different reasons, as Maltysen explained to me).

Neither one of these features is likely to show up in Pip¹ (I don't like the aesthetics of unbalanced delimiters, and point-free syntax or implicit operands seem like they would be too alien to my infix expression parser), but I'm okay with playing third fiddle. Even though "readability" is extremely relative when golfing, I'd argue that those three extra bytes make the Pip program a lot easier to understand at a glance--and in my book, that's a worthwhile tradeoff.

_{¹ Although, single-character strings in Pip use a single ' delimiter, inspired by CJam and by quoting in Lisp.}

Answer 26

Psithurism, 11 bytes

*(%2?"/:"\)

This is a language I'm still developing, but I'm going to start posting answers here to get a feeling of what kind of built-in functions might be useful to have. (This one has taught me I really need some way to index into arrays/strings lol.)

explained:

*(        # implicitly multiply the input by
  %2      # implicitly take input mod 2
    ? "/  # / if truthy (1)
    : "\  # \ if falsy (0)
)

Curious about Psithurism?
Github: https://github.com/AroLeaf/psithurism/
Docs (soon™): https://psithurism.leaf.moe/

Answer 27

Pyth, 5 bytes

*@"\/

Test suite.

Modular-indexing into the string \/ and then repeat.

Answer 28

Perl 6, 16 bytes

{<\ />[$_%2]x$_}

Usage:

for 1..6 {
  say $_, {<\ />[$_%2]x$_}( $_ )
}

1/
2\\
3///
4\\\\
5/////
6\\\\\\

Answer 29

SpecBAS - 28 bytes

1 INPUT n: ?"\/"(ODD(n)+1)*n

ODD returns 1 if number is odd, then uses that as an index to print the correct character n number of times. Have to add 1 as SpecBAS strings start at character 1.

Answer 30

Java 8, 56 bytes

(i,j)->{for(j=i;j-->0;)System.out.print(i%2<1?92:'/');};

I'd like to thank @Kevin Cruijssen in advanced for golfing my answer further.

Ungolfed Test Program

public static void main(String[] args) {
    BiConsumer<Integer, Integer> consumer = (i, j) -> {
        for (j = i; j-- > 0;) {
            System.out.print(i % 2 < 1 ? 92 : '/');
        }
    };

    consumer.accept(5, 0);
    consumer.accept(1, 0);
    consumer.accept(8, 0);
}