[Question]
  [
Given a *strictly* positive integer `n` (therefore `0` isn't a valid test case), produce an approximate triangle of height `n`.
## A non-programmatic process of drawing the picture
Initially we start with the base of the triangle.
```
|
```
So, we want to draw a triangle of a height of 5. First we know that all the `|`'s align on a straight line, and there is a missing `|` on every even position.
```
|
|
|
```
Then, we insert the `/`'s onto these empty lines, where every `/` has 1 more preceding space than the next `/`. The lowest `/` starts at 1 space.
```
|
  /
|
 /
|
```
## More reference outputs + Sample program
Here's what the program should output for inputs `1` to `9`. A [sample program](https://tio.run/##ZY/BCsIwDIbP21OEgqx1utl5K@wtBA9zh8E6jYysdPUg@O610ZOYW/7/y5/EPcNtoWOMo53g7Ad38jjQdbaSlMmzGdcALXR9nk2LBwQk8Mm3Uu@o1IxkOAFuGmhb0Nx@ZqrBOUujFC@hkmbn1f57ILZIQWLdqFLUDHobHp6guFBR3RckyXxnzF73Kv4doA@833kOEW0qEOUavMQUZ4AFzvz6P6@hUvEN) is available if you still don't understand the specification.
For those that don't see that it's a triangle: Take a look at [this](https://tio.run/##ZY7BCoJAFEXX@hWPgXAmSx3bCf5F0MJcCD7rhTyH57QI@vfJaRct7z3nwnUvf1/4FMKIE1xkcGehgW8zajZNmsy0emih69NkWgQIiEE2jtoeOLdRSWgC2tXQtmBj/G6KwTnkUau3MluH84r/DNSe2Gsqa5OrMoqC/ikM2ZWz4rEQ6@h3TXO0vQlOov3zsa4qY8IH). Scroll the picture really quickly. You will see the two sides of a triangle.
```
==== 1: ====
|
==== 2: ====
 /
|
==== 3: ====
|
 /
|
==== 4: ====
  /
|
 /
|
==== 5: ====
|
  /
|
 /
|
==== 6: ====
   /
|
  /
|
 /
|
==== 7: ====
|
   /
|
  /
|
 /
|
==== 8: ====
    /
|
   /
|
  /
|
 /
|
==== 9: ====
|
    /
|
   /
|
  /
|
 /
|
```
## Specification
* Leading/Trailing whitespace is allowed.
* The string *has* to be joined with newlines, outputting a string list is not allowed.
  
[Answer]
# [Husk](https://github.com/barbuz/Husk), 12 bytes
```
↔↑ṁe"|"¡Θ" /
```
[Try it online!](https://tio.run/##AR8A4P9odXNr///ihpTihpHhuYFlInwiwqHOmCIgL////zkw "Husk – Try It Online")
Builds the infinite triangle upside-down, then takes the required number of lines and reverses them before printing.
### Explanation
```
↔↑ṁe"|"¡Θ" /
       ¡        Repeat and accumulate results:
        Θ          prepend a space
         " /       starting from the string " /"
                   (this will create all the lines of the slanted side)
  ṁ             For each line:
   e"|"            put it in a list with a "|" line
  ṁ             and merge all these lists together
 ↑              Take the number of lines required by the input
↔               Reverse the result
```
[Answer]
# [Python 2](https://docs.python.org/2/), 45 bytes
```
def f(n):print n%2*'|'or n/2%n*' '+'/';f(n-1)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/PyU1TSFNI0/TqqAoM69EIU/VSEu9Rj2/SCFP30g1T0tdQV1bXV/dGqhE11Dzf5pGZl5BaYmGpuZ/cwA "Python 2 – Try It Online")
A function that prints, terminating with error. The `%n` in `n/2%n` is just to give an error when `n` falls to 0, but is harmless otherwise.
---
As a program
**50 bytes**
```
n=input()
while n:print n%2*'|'or n/2*' '+'/';n-=1
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P882M6@gtERDk6s8IzMnVSHPqqAoM69EIU/VSEu9Rj2/SCFPH8hSUNdW11e3ztO1Nfz/3wwA "Python 2 – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 48 bytes
```
unlines.reverse.(`take`f" /")
f c="|":c:f(' ':c)
```
[Try it online!](https://tio.run/##BcG9CoAgEADgvac4JLCGamsQfIrWhuQ4TTIRf5p69q7vO025KAR2eucWg49U5kwP5ULzcFRz0WEFLGLsLKAWr1Co7CBBKhz5Nj6ChtTqVjP04GDlD20wrvCEKf0 "Haskell – Try It Online")
`f" /"` generates an infinite (reversed) approximate triangle, the first line is mostly formatting.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~17~~ ~~14~~ ~~13~~ 11 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
L'/ú€'|I£R»
```
-3 bytes thanks to *@Grimmy*.  
-1 byte after getting inspiration from *@MagicOctopusUrn*.
[Try it online](https://tio.run/##yy9OTMpM/f/fJ@jcVmt1/cO71GseNcyqPLxC5/9/8/@6unn5ujmJVZUA) or [verify all test cases](https://tio.run/##yy9OTMpM/R/iquSZV1BaYqWgZO9ny6XkX1oC4en891HXP7zrUdMa9Rq/Q4uDDu3@r3Nom/1/AA).
**Explanation:**
```
L            # Push a list in the range [1, (implicit) input]
             #  i.e. 5 → [1,2,3,4,5]
 '/ú        '# Pad "/" with that many leading spaces
             #  → [" /","  /","   /","    /","     /"]
    €'|     '# Put a "|" in front of each item
             #  → ["|"," /","|","  /","|","   /","|","    /","|","     /"]
       I£    # Only leave the first input amount of items
             #  → ["|"," /","|","  /","|"]
         R   # Reverse it
             #  → ["|","  /","|"," /","|"]
          »  # And join it by newlines
             #  → "|\n  /\n|\n /\n|"
             # (after which the result is output implicitly)
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~52~~ 51 bytes
```
f(n){for(;n--;)printf(n&1?"%*c\n":"|\n",n/2+2,47);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI0@zOi2/SMM6T1fXWrOgKDOvBCimZmivpKqVHJOnZKVUAyR18vSNtI10TMw1rWv/5yZm5mloVnOBtAGVK2TaGlpn2lhYa2tnAkUVoGYo2QKBagqIBBmQqWnNpZCmAaZquWr/mwMA "C (gcc) – Try It Online")
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~21~~ 20 bytesSBCS
```
⊖(0⌊-\∘⍳)⌽⊢↑⍤0⍴∘'|/'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/x91TdMweNTTpRvzqGPGo97Nmo969j7qWvSobeKj3iUGj3q3AIXVa/TV/6cBlT/q7YPo7Go@tN4YpKZvanCQM5AM8fAM/p@mYMilq6vLlaZgAqXNAQ "APL (Dyalog Unicode) – Try It Online")
**Edit**: Use `↑⍤0` instead of `↑¨` to avoid an extraneous use of `↑`.
An anonymous tacit function. This is an improvement over [Graham's APL+WIN solution](https://codegolf.stackexchange.com/a/200573/78410) using modern APL.
I was about to post a 24-byter when `-\⍳n` randomly struck my brain. It is an expression that yields first `n` terms of `0 -1 1 -2 2 -3 3 ...`, so applying `0⌊` yields `0 -1 0 -2 0 -3 0 ...` which is perfect for row-wise rotation vector.
### How it works
```
⊖(0⌊-\∘⍳)⌽⊢↑⍤0⍴∘'|/'  ⍝ Input: n
              ⍴∘'|/'  ⍝ Repeat '|/' to length n
          ⊢↑⍤0        ⍝ Create a n-by-n matrix whose 1st column is the above
                      ⍝   and the rest is blank
         ⌽            ⍝ Rotate left each row:
 (  -\∘⍳)             ⍝   First n values of 0 -1 1 -2 2 -3 3 ...
  0⌊                  ⍝   Minimum with 0; 0 -1 0 -2 0 -3 ...
                      ⍝ (Negative rotate left is rotate right)
⊖                     ⍝ Reverse vertically
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 168 bytes
```
,[->>>+<[-<+>>-]>[<+>->]<<<<]>>>>>>>++>++[-<[-<++>]<[->++<]>>]<<++++++[-<+++++++>]<[-<+<+++>>]++++++++++<+++++<--<[->.>>.<<<]<[[->+>>>>>.<<<<<<]>>>.>.<<.>>.<<<[-<+>]<-]
```
[Try it online](https://tio.run/##PY5RCoAwDEP/vUrsTlBykdIPFQQR/BA8/2w7MQxKeGm69V6Oa3@2s/fZhCTUREGK02IKXUPOISBeBDKDQLECJI0USkVKhRVpg@PX4CrZwka27FfLqrqR/jvZ0nyR@pareO/TCw "brainfuck – Try It Online"), with 10 as input. There is substantial room for improvement for sure. I should try different memory layouts for the constants, for example. My pointer walks around way too much.
The commented code:
```
Divide input by two and get the mod as well
Mem layout is
input | quotient | remainder | ifelse flag | 0
,[->>>+<[-<+>>-]>[<+>->]<<<<]
Mem: ^0 | quotient | remainder | 0 | 0
Build 32 which is the SPACE character
>>>>>>>++>++
Mem: 0 | quot | rem | 0 | 0 | 0 | 0 | 2 | ^2
[-<[-<++>]<[->++<]>>]
Mem: 0 | quot | rem | 0 | 0 | 0 | 0 | 32 | ^0
Build 124 and 47 for the vertical bar and the slash
<<
++++++[-<+++++++>]<[-<+<+++>>]++++++++++<+++++<--
Mem: 0 | quot | rem | ^124 | 47 | 10 | 0 | 32
If there is a remainder print the loose vertical bar
<[->.>>.<<<]<
Mem: 0 | ^quot | 0 | 124 | 47 | 10 | 0 | 32
while there is something in the quotient
[
  print those many spaces
[->+>>>>>.<<<<<<] print as many spaces as needed
  then a slash
>>>.
  then a newline
>.
  then a vertical bar
<<.
  then a newline
>>.<<<
reset the space counter and decrement it
[-<+>]<-
] (end while)
```
that you can [try at a different interpreter](https://copy.sh/brainfuck/?c=RGl2aWRlIGlucHV0IGJ5IHR3byBhbmQgZ2V0IHRoZSBtb2QgYXMgd2VsbApNZW0gbGF5b3V0IGlzCmlucHV0IHwgcXVvdGllbnQgfCByZW1haW5kZXIgfCBpZmVsc2UgZmxhZyB8IDAKLFstPj4-KzxbLTwrPj4tXT5bPCs-LT5dPDw8PF0KTWVtOiBeMCB8IHF1b3RpZW50IHwgcmVtYWluZGVyIHwgMCB8IDAKQnVpbGQgMzIgd2hpY2ggaXMgdGhlIFNQQUNFIGNoYXJhY3Rlcgo-Pj4-Pj4-Kys-KysKTWVtOiAwIHwgcXVvdCB8IHJlbSB8IDAgfCAwIHwgMCB8IDAgfCAyIHwgXjIKWy08Wy08Kys-XTxbLT4rKzxdPj5dCk1lbTogMCB8IHF1b3QgfCByZW0gfCAwIHwgMCB8IDAgfCAwIHwgMzIgfCBeMApCdWlsZCAxMjQgYW5kIDQ3IGZvciB0aGUgdmVydGljYWwgYmFyIGFuZCB0aGUgc2xhc2gKPDwKKysrKysrWy08KysrKysrKz5dPFstPCs8KysrPj5dKysrKysrKysrKzwrKysrKzwtLQpNZW06IDAgfCBxdW90IHwgcmVtIHwgXjEyNCB8IDQ3IHwgMTAgfCAwIHwgMzIKSWYgdGhlcmUgaXMgYSByZW1haW5kZXIgcHJpbnQgdGhlIGxvb3NlIHZlcnRpY2FsIGJhcgo8Wy0-LjxdPApNZW06IDAgfCBecXVvdCB8IDAgfCAxMjQgfCA0NyB8IDEwIHwgMCB8IDMyCndoaWxlIHRoZXJlIGlzIHNvbWV0aGluZyBpbiB0aGUgcXVvdGllbnQKWwogIHByaW50IHRob3NlIG1hbnkgc3BhY2VzClstPis-Pj4-Pi48PDw8PDxdIHByaW50IGFzIG1hbnkgc3BhY2VzIGFzIG5lZWRlZAogIHRoZW4gYSBzbGFzaAo-Pj4uCiAgdGhlbiBhIG5ld2xpbmUKPi4KICB0aGVuIGEgdmVydGljYWwgYmFyCjw8LgogIHRoZW4gYSBuZXdsaW5lCj4-Ljw8PApyZXNldCB0aGUgc3BhY2UgY291bnRlciBhbmQgZGVjcmVtZW50IGl0ClstPCs-XTwtCl0gKGVuZCB3aGlsZSk$) and to which you can pass different input numbers more easily. For example, try typing `\10` in the input bar. Then pass the commented code [over this Python script](https://tio.run/##jVNNi9swEL3rVww@2Sg22WShsKiC7cexUOjROKDYk1iLLLmSsyHQ/56O5KTJYQMdbOtr5s34zdN4mnpn1@fWdQifIcuy8zf9rmmh7XiYYHuC6ehA2Q72OMHUIwyuAxXgiMawHziAUSdHnjqwOeQP/D64SaONU4@D0rZDT3O9QxMQdkbtabVki7qUUnJRl4JLWTayprGUjSBrIvQLbJaP4ZYJ5MtBmw7WKzj2uu2pilTjr5@vX79D2yuv2gk9k7NxTs@MfAWeQa9wd@@K3s2KUXGxPk5lUbmci0bK5j8h1gljyYRgPFlCSpbgBI9LwuP/bD4XZfkgxeZp9UzD8yf6PN3ysFhcJRpxC9tc4uL8QRBRZjDy5TESF9yAU6/tnnqfWLwSz2oGMHptowActXBQ9gRhVC0GFllJ5FYiWXPxJIncucWlReywIyjCtqAgGBX62JrqtmfxaLRFdr/3jn7SrTKwVZ64/Mg7JWcew0WjKSm07mCp@0m9HbbEYFSRnlhSXCNK1kCOdJiIKM6kfsbcGOJFWFR1IyQvaSf9Tx4OQ06Z40WpEnAe5VXAzvkktEgaxbKiuEZkWfXmtM132lAVuVHDtlPQvrQX10UCK4ri/Bc) to remove the comments and get the byte count.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 42 bytes
```
"$args"..1|%{((" "*($_/2)+"/"),"|")[$_%2]}
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0klsSi9WElPz7BGtVpDQ0lBSUtDJV7fSFNbSV9JU0epRkkzWiVe1Si29v///6YGAA "PowerShell – Try It Online")
Loops from input `$args` down to `1`, each iteration choosing whether to output spaces and a `/`, or the `|` character based on a modulo-index into an array. Default output gives us newlines for free. Ho-hum.
[Answer]
# [J](http://jsoftware.com/), 24 bytes
```
>@}.&,i.;&'|'@{.&'/'@->:
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/7Rxq9dR0MvWs1dRr1B2q9dTU9dUddO2s/mtypSZn5CukKRiCGeq66jABI3QB0/8A "J – Try It Online")
*-4 bytes thanks to Bubbler*
[Answer]
# APL+WIN, ~~36 33~~ 30 bytes
3 bytes saved by incorporating bubbler's row rotation method
Prompts for integer:
```
    ⊖(0⌊-\⍳n)⌽(n,n)↑((n←⎕),1)⍴'|/'
```
[Try it online! Courtesy of Dyalog Classic](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v@ob6qvz6O2CcZcjzra0/4/6pqmYfCop0s35lHv5jzNRz17NfJ0gHTbRA2NPKAyoHJNHUPNR71b1Gv01f8D9fxP4zLnAgA "APL (Dyalog Classic) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~66~~ ~~56~~ 55 bytes
Saved a byte thanks to [kaya3](https://codegolf.stackexchange.com/users/91685/kaya3)!!! 
```
def f(n):
 if n:print((-~n//2*' '+'/','|')[n&1]);f(n-1)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/PyU1TSFNI0/TikshM00hz6qgKDOvRENDty5PX99IS11BXVtdX11HvUZdMzpPzTBW0xqoWNdQ839afpFCpkJmnkJRYl56qoahjgXICIjuNHVbIKjOrAVR6ppcQAsyNf@bAwA "Python 3 – Try It Online")
[Answer]
# Java (OpenJDK 8), 88 84 bytes
```
x->{for(int i=x,j=i+2;i-->0;j--)System.out.printf((i%2<1?"|\n":"%"+j/2+"s\n"),"/");}
```
[Try it online!](https://tio.run/##XZBBbsIwEEX3nGJkCcmRcYAsa0zFAbpi2XYxDQmyG5woNsgVzdnTaRKqqH9jz/fXzBtbvKGsm8LZ02ffXD8qk0NeoffwgsbBfbEAknGhaEvMCziQBZNutTkBcnqEmKjB7sa8Dxio0QEQNPRR7u9l3Q5Bo@PKaiMyZaTcb5SVMjl@@VBc0voa0qalUMm5WWa77TP7fnPsiS2ZsOtMME9VsmJrlqiuV@OkCXkaOBBdCJwfA3U6v74DtmefzKAJBEZkQtsqOnYasg1dhJjnfvUfrHI8ggCm/8SmvR/CFHmced3jV7r@Bw "Java (OpenJDK 8) – Try It Online")
If Java's output methods weren't so long, I'd get close to John's `R` submission!
Edit:  
-4 bytes thanks to @Kevin Cruijssen!  
Also the link led to an older 91 bytes version, fixed that now...
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~14~~ 13 bytes
```
H⁶ṁ;”/)”|ÐoṚY
```
[Try it online!](https://tio.run/##y0rNyan8/9/jUeO2hzsbrR81zNXXBBI1hyfkP9w5K/L////mAA "Jelly – Try It Online")
A monadic link taking an integer and returning a list of Jelly strings. If a single newline-separates string is needed, append `Y` for a cost of a byte. Thanks to @JonathanAllan for saving a byte!
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 18 bytes
```
Ｎθ↙⊘θＵＥ⁰¦¹Ｆ⊘⊕θ«↑↑¹
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98zr6C0xK80Nym1SKNQ05oroCgzr0TDyiW/PM8nNa1ER8EjMacsNQUoB5R0rShJzUvRMNBRMATy0vKLFDSg0p55yUWpual5JRClCtVcnL75ZakaVqEFQJWcUFNDCyA6a///N/2vW5YDAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｎθ
```
Input `n`.
```
↙⊘θ
```
Print the diagonal line of the appropriate length.
```
ＵＥ⁰¦¹
```
Space the rows out.
```
Ｆ⊘⊕θ«↑↑¹
```
Fill in the vertical line on alternate lines.
[Answer]
# [Perl 5](https://www.perl.org/) `-n`, 36 bytes
```
say$_%2?$"x(1+$_/2).'/':'|'while$_--
```
[Try it online!](https://tio.run/##K0gtyjH9/784sVIlXtXIXkWpQsNQWyVe30hTT11f3Uq9Rr08IzMnVSVeV/f/f8t/@QUlmfl5xf91fU31DAwN/uvmAQA "Perl 5 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 23 bytes
```
HĊ”|ẋż³HḞR¤” ẋ$;€”/¤ẎṚY
```
[Try it online!](https://tio.run/##y0rNyan8/9/jSNejhrk1D3d1H91zaLPHwx3zgg4tAYooAEVUrB81rQGy9Q8tebir7@HOWZH///83BwA "Jelly – Try It Online")
It's been a while since I've golfed in Jelly, so this answer is probably embarrassingly long.
[Answer]
# [PHP](https://php.net/), ~~76~~ 57 bytes
```
for(;$a=$argn--;)echo$a%2?"|
":str_repeat(' ',$a/2)."/
";
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKxVEm1VEovS83R1rTVTkzPyVRJVjeyVariUrIpLiuKLUgtSE0s01BXUdVQS9Y009ZT0uZSs//83/5dfUJKZn1f8X9cNAA "PHP – Try It Online")
I feel there should be much better but can't put my finger on it yet.. I also didn't find how to use recursive functions with PHP7 arrow notation.. well..
EDIT: Actually, a basic loop is still better for PHP than recursion
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 50 bytes
```
f(n){for(;n;)printf(n--%2?"|\n":"%*s/\n",n/2,"");}
```
Takes as input an integer `n` and prints a triangle. It would look more realistic and save 2 bytes if `n` was not divided by 2.
[Try it online!](https://tio.run/##S9ZNT07@/z9NI0@zOi2/SMM6z1qzoCgzrwQooquramSvVBOTp2SlpKpVrA9k6OTpG@koKWla1/4HqlHITczM0yjLz0zR5KrmUgACkBEgiUwFWwVDayBlo2BoAKS1tTXB8mA1GpmaOgoFpSXFGiCTuGr/AwA "C (gcc) – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~75~~ 61 bytes
Thanks again, Giuseppe! Forgot that cat does pasting itself.
```
for(i in scan():1)cat(`if`(i%%2,'|',c(rep('',i/2),'/')),'\n')
```
[Try it online!](https://tio.run/##K/r/Py2/SCNTITNPoTg5MU9D08pQMzmxRCMhMy1BI1NV1UhHvUZdJ1mjKLVAQ11dJ1PfSFNHXV9dE0jG5Klr/jf9DwA "R – Try It Online")
[Answer]
# [4](http://esolangs.org/wiki/4), 171 bytes
```
3.6006260132602476031061101612026401020000127908906554819090552999940099999079098993139912214131211599141161115815500503615009816317991281750111717119502503616009199991194
```
[Try it online!](https://tio.run/##HU6LDUQxCNroAvip7D9Yzz5MRIUQ8974NdBqMLYpTyOIJsGmoE4QwoI6xhhdlUPDqJIXCTwyVvfYwbApMRkUWbslN27HYRVQiOayhx08zz08hXWcLbqgz7O/mS97b3mv8Ac)
### Explanations
```
3.    start of code
60062 assign half ASCII of pipe
60132 space
60247 slash
60310 endl
61101 int one
61202 int two
64010 int ten
2000012 multiply half-pipe by two for a pipe
790 get input
890 while there's still input
65548 char zero
1909055 decrease input char by char zero to get result
2999940 multiply previous result by ten (to make way for current char input)
0999990 put current result
790 get input again
9 end of loop
======== At this point we already got the int n
899 while (n != 0)
3139912 2141312 1159914 mod by 2 (n-[[n/2]]*2)
1161115 check odd or even
815     if odd
500 503 61500 9 print pipe and endl
816     if even
3179912 get n/2
817 501 1171711 9 print spaces
502 503 61600 9 print slash and endl
1999911 9 get n-1, end of loop
4       end of code
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 16 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
Çg['|'/iSp°Zz]Ãw
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=x2dbJ3wnL2lTcLBael3Ddw&input=OQ)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 22 bytes
```
:2&\w~*"@:~'|/'X@)hXhP
```
[Try it online!](https://tio.run/##y00syfn/38pILaa8TkvJwapOvUZfPcJBMyMiI@D/f0sA "MATL – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 52 bytes
```
i=input()
while i:print(' '*(i/2)+'/','|')[i%2];i-=1
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9M2M6@gtERDk6s8IzMnVSHTqqAoM69EQ11BXUsjU99IU1tdX11HvUZdMzpT1SjWOlPX1vD/f0MDAwA "Python 2 – Try It Online")
[Answer]
# JavaScript (ES6), 48 bytes
```
f=n=>n?(n&1?`|
`:' '.repeat(n/2)+`/
`)+f(n-1):''
```
[Try it online!](https://tio.run/##ZchBCoAgEADAu6/olLtEihEEgfUVxTQKWaOkU3@3czTH2e1tL3duR24pLb6UoElPNAPVajYPMyOvuDj94W0Gkh02RjKDTQBqFY6cF5foStGLmFYIoBDZd/rfDIjlBQ "JavaScript (Node.js) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 44 bytes
```
->n{(1..n).map{[?|," "*(n/2)+?/][(n-=1)%2]}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vWsNQTy9PUy83saA62r5GR0lBSUsjT99IU9tePzZaI0/X1lBT1Si2tvZ/QWlJsUJatHnsfwA "Ruby – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 47 bytes
```
f=(n,s=`/
`,v=`|
`)=>--n?f(n,v,s<v?' '+s:s)+v:v
```
[Try it online!](https://tio.run/##JcgxDsIwDEDRvadgcywnQNemphdhSFUaZFQlqEaeuHsA8aen/5ht1mWX5yuUeltby@yKV06nLnnj9O4S8iWEMuXvN6@jTXAA0kGRbLCW6@6E@ygj9@coRLjUonVbj1u9O@BfQEJ/XQtQdoIY2wc "JavaScript (Node.js) – Try It Online")
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 68 bytes
```
f(){ for((i=$1;i-->0;)){((i%2))&&printf %$[2+i/2]s\\n /||echo \|;};}
```
[Try it online!](https://tio.run/##S0oszvj/P01Ds1ohLb9IQyPTVsXQOlNX187AWlOzGshXNdLUVFMrKMrMK0lTUFWJNtLO1DeKLY6JyVPQr6lJTc7IV4ipsa61rv2fpmDIBebr6upypSmY/gcA "Bash – Try It Online")
Don't golf in bash that often, so tips appreciated.
[Answer]
# [Go](https://golang.org/), 94 bytes
```
import."fmt"
func f(n int){for n!=0{if n%2==0{Printf("%*s/\n",n/2,"")}else{Println("|")}
n--}}
```
Port of my C answer.
[Try it online!](https://tio.run/##PY1NDoIwFIT3PcXzJSStgPws1d7BA7ghhJJG@kpKXWHPXgsYVzOZL/lmtHHu@lc3DmA6TVGb2Tp/QWU8MvWmHhQn0OTFqqwDOsl61Qooa2VqD5eI4pidl@pJWFDVFogiDNMyHHAijp@0MCrLEOJu3I64gJUBwCbVcJXQ3FLeoalT5vkBN861@NW/D/clsBC/ "Go – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `j`, 15 bytes
```
ɾ\/꘍\|?ẋf$Y?wiṘ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=j&code=%C9%BE%5C%2F%EA%98%8D%5C%7C%3F%E1%BA%8Bf%24Y%3Fwi%E1%B9%98&inputs=4&header=&footer=)
An attempted port of the 05AB1E answer, but not really...
]