เครดิตทั้งหมดให้กับ Adnan สำหรับความท้าทายนี้

ความท้าทายครั้งล่าสุดของฉันก่อนที่ฉันจะไปในช่วงพัก

งาน

รับจำนวนเต็มบวกnถ้าnเป็นเลขคี่ให้ทำซ้ำ/หลายครั้ง; ถ้าnเป็นเช่นนั้นให้ทำซ้ำ\หลายครั้ง

(อย่างจริงจังการทดสอบจะชัดเจนกว่าคำอธิบายนี้มากดังนั้นให้ดูที่การทดสอบ)

รายละเอียด

• รูปแบบอินพุต / เอาท์พุตที่สมเหตุสมผล
• ช่องโหว่มาตรฐานใช้

Testcases

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

Javascript, 22 ไบต์

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

กำหนดฟังก์ชั่นที่ไม่ระบุชื่อ

ถ้ามีเพียง*สตริงซ้ำ ๆ ใน Javascript ถอนหายใจ

Python 20 ไบต์

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

05AB1E / 2sable , 15 11 9 8 ไบต์

DÈ„/\sè×

-2 ไบต์ขอบคุณ Leaky Nun

-1 ไบต์ต้องขอบคุณ Emigna

ลองออนไลน์! ใน 05AB1E
หรือ 2sable

Perl, 20 ไบต์

รวม +1 สำหรับ -p

รันด้วยอินพุตบน STDIN:

squigly.pl <<< 6

squigly.pl

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

จอประสาทตา 21

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

ลองออนไลน์ (เพิ่มบรรทัดแรกเพื่ออนุญาตให้มีการทดสอบหลายชุด)

C #, 42 ไบต์

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

เลือกอักขระที่ถูกต้องจากนั้นสร้างสตริงใหม่ที่ประกอบด้วยอักขระซ้ำหลายnครั้ง

PHP, 38 ไบต์

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

(ตัวแปร 38 ไบต์)

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

(ตัวแปร 38 ไบต์)

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

(ตัวแปร 40 ไบต์)

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

C, 40 ไบต์

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

ลองใช้กับ Ideone

เยลลี่ 5 ไบต์

ị⁾/\x

ลองออนไลน์! หรือตรวจสอบผลการทดสอบทั้งหมด

ị⁾/\x

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

J, 10 ไบต์

#'\/'{~2|]

นี่คือคำกริยาหกรถไฟประกอบด้วย:

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

นี่คือตะขอระหว่าง#และ('\/' {~ 2 | ]); เบ็ด(f g) yขยายไปถึงy f (g y)ดังนั้นสิ่งนี้จะขยายไปถึงy # (... y)ซึ่งสำหรับอักขระเดี่ยวให้ผลลัพธ์รายการของyอักขระ

ส่วนที่สองคือรถไฟ 5 ขบวนประกอบด้วย:

'\/' {~ 2 | ]

สิ่งนี้ประเมินเป็นสองส้อม:

'\/' {~ (2 | ])

ส้อมด้านใน2 | ]เป็นโมดูลัสสอง ส้อมด้านนอกจึงเป็น:

'\/' {~ mod2

ซึ่งจะใช้เวลา ( {~) ดัชนี mod2 (ที่mod2) /จากสตริง

จากนั้นใช้ตะขอจากด้านบน:

y # (apt char)

สิ่งนี้ให้สิ่งที่เราต้องการและเราทำเสร็จแล้ว

Haskell, 25 ไบต์

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

-1 cycleไบต์ขอบคุณที่เดเมี่ยนด้วย

Mathematica, 34 32 28 ไบต์

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

ฟังก์ชั่นไม่ระบุชื่อ รับจำนวนเต็มเป็นอินพุตและส่งคืนรายการอักขระเป็นเอาต์พุต

Powershell, 30 27 ไบต์

ปรับปรุง:

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

สลับไปparamขอบคุณtimmyd

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

หรือมากกว่าอ่านได้เล็กน้อย

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

ทดสอบ:

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

Mathematica, 29 ไบต์

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

อย่างโหดร้ายใช้ประโยชน์จากความจริงที่ว่า[[1]]ผลตอบแทนอาร์กิวเมนต์แรกของการทำงานในขณะที่[[0]]ผลตอบแทนที่ฟังก์ชั่น (หัว) ตัวเองนำไปใช้กับการทำงานที่ถูกต้องแปลกชื่อ"\\"ที่จะถูก "ประเมิน" "/"ที่

ทับทิมขนาด 15 ไบต์

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

ดูได้ที่ eval.in: https://eval.in/632030

ฟูริเยร์ 27 ไบต์

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

ลองออนไลน์!

Brachylogขนาด 15 ไบต์

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

ลองออนไลน์!

คำอธิบาย

: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

CJam , 9 ไบต์

ri_"\/"=*

ลองออนไลน์!

คำอธิบาย

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.

> <> (ปลา), 30 ไบต์

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

ครั้งแรกที่ใช้ภาษานี้ แต่ฉันคิดว่าอย่างน้อยฉันก็ประหยัดห้องเล็ก ๆ โดยใช้เงื่อนไข / เป็นส่วนหนึ่งของผลลัพธ์หรือมิเรอร์เพื่อเปลี่ยนเส้นทางการไหล แม้ว่าอาจจะไม่มีประสิทธิภาพอย่างน่ากลัว แต่ฉันรู้สึกว่ามันน่าจะลดน้อยลงไปได้อีกเล็กน้อย

อินพุตเป็นสแต็กเริ่มต้นเอาต์พุตคือ stdout

ลองออนไลน์!

Dyalog APL , 11ขนาดไบต์

ต้องใช้⎕IO←0ซึ่งเป็นค่าเริ่มต้นในหลาย ๆ ระบบ

⊢⍴'\/'⊃⍨2|⊢

⊢ อาร์กิวเมนต์

⍴ ปรับรูปร่าง (ซ้ำ)

'\/'⊃⍨ สตริง "/" ที่เลือกโดย

2|⊢ ส่วนที่เหลือเมื่ออาร์กิวเมนต์ถูกหารด้วยสอง

ลองใช้ออนไลน์!

Java 7, 68 65 bytes

void c(int i){for(int x=0;x++<i;)System.out.print(i%2<1?92:'/');}

3 bytes saved thanks to @user902383 and @SeanBean.

Just like with this answer, the shortest code-golf seems to loop and print. Both recursive and
void c(int i){System.out.print(new String(new char[i]).replace("\0",i%2<1?"\\":"/"));}
seems to be longer.

Ungolfed & test code:

Try it here.

class M{
  static void c(int i){
    for(int x = 0; x++ < i;){
      System.out.print(i % 2 < 1
                        ? 92
                        : '/');
    }
  }

  public static void main(String[] a){
    for(int i = 0; i < 10; i++){
      c(i);
      System.out.println();
    }
  }
}

Output:

/
\\
///
\\\\
/////
\\\\\\
///////
\\\\\\\\
/////////

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.

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('/',@))

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.}

Pyth, 5 bytes

*@"\/

Test suite.

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

Perl 6, 16 bytes

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

Usage:

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

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

Julia, 20 bytes

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

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.

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);
}

Actually, 10 bytes

Golfing suggestions welcome. Try it online!

;'\'/2(%I*

How it works

       Implicit input of n
;      Duplicate n
'\'/   The strings "/" and "\"
2(%    n mod 2
I      If n mod 2, then "/", else "\"
*      Multiply by n. Implicit print at the end.