[Question]
  [
# Alternate Title: [Tally Your Prison Sentence on the Wall](https://s3.amazonaws.com/lowres.cartoonstock.com/law-order-jail-jail_cell-prisoner-prison_cell-prison-jcen999_low.jpg)
Given a number `n`, output tallies grouped into the traditional 5-per-group and 50 per row.
---
# Examples
1
```
|
|
|
|
```
4
```
||||
||||
||||
||||
```
5
```
|||/
||/|
|/||
/|||
```
6
```
|||/ |
||/| |
|/|| |
/||| |
```
50
```
|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 
```
51
```
|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 
|
|
|
|
```
256
```
|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 
|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 
|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 
|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 
|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 
|||/ |
||/| |
|/|| |
/||| |
```
---
# Rules
* 5 tallies per group, 50 total tallies per row.
* The first 4 tallies are vertical, the 5th tally crosses all other tallies.
	+ Each of the first four consist of 4 vertical `|` characters.
	+ The final 5th tally spans all 4 of the first, with a `/` character, diagonally.
* Each group should be separated by a space, each row a blank newline.
* The constraints on `n` are: `0 <= n <= 1000` (for simplicity).
* Trailing spaces and newlines are fine, preceding are not.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'")[ascii-art](/questions/tagged/ascii-art "show questions tagged 'ascii-art'"), lowest byte-count wins.
---
Reviewed by ~4 people in the [sandbox](https://codegolf.meta.stackexchange.com/a/14215/59376).
---
P.S. *fun little tid-bit, the average number of tallies per row in prison was 50, hence the alt. title.*
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~30~~ 25 bytes
```
ＦＮ«Ｊ﹪ι⁵⁰×⁵÷ι⁵⁰¿﹪⊕ι⁵↓⁴«←↙⁴
```
[Try it online!](https://tio.run/##TY29CsIwFIXn5Cky3kAEEeNQ1y4RKw59gdreYiA/JU3qIH322ICC63fO@U7/7ELvO5Pz6AMD5aYUb8k@MADn7E3JJdmp9dD4IRkPWjC554K12uIMUjDlYq0XPeA34vxMiR7Zb6BcH9CiiziA3oZys96DdhGq2r@cYEdOCZoZyxdp/IJQXXGMRUP@ioWV8oZXuuZ8kKe8W8wH "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
 Ｎ                          Input number
Ｆ «                         Loop over implicit range
     ι     ι                Loop index
      ⁵⁰    ⁵⁰              Literal 50
    ﹪                       Modulo
          ÷                 Integer divide
         ⁵                  Literal 5
        ×                   Multiply
   Ｊ                        Jump to column, row
                 ι          Loop index
                ⊕           Incremented
                  ⁵         Literal 5
               ﹪            Modulo
              ¿             If
                   ↓⁴       Print 4 `|`s downwards
                     «      Implicit else
                      ←     Move left
                       ↙⁴   Print 4 `/`s down and left
```
[Answer]
# [Funky](https://github.com/TehFlaminTaco/Funky), ~~156~~ ~~132~~ 133 bytes
```
n=>{k=n=>((l="|"::rep)(3-i)+"/"+l(i)+" ")::rep(n)p=print L=f=>fori=0i<4i++p(f())forc=0c<n//50c++{L@k(10);p()}L@k((m=n%50)//5)+l(m%5)}
```
[Try it online!](https://tio.run/##HYxbCoMwEEW3IgFhhqEkfeTHOtIFuIvQgaBOQ7Afxbr2NPbncrgHjrx1@hThojxsE9cFmNl8TdflZ0K4niKSsYZmOKAx@BegmDjlqGszsvAgrxzZxf4WiRIIINYnsAu9WutdINrGxwRnh/cEuB8MC2vrHVaPtb60Hvci4C9Yfg "Funky – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 117 bytes
```
f m|m<1=""|n<-min 50 m=unlines[[last$"| "!!(0^c%5):['/'|r+c%5==4,n-n%5>c]|c<-[1..n]]|r<-[0..3]]++'\n':f(m-50)
(%)=mod
```
[Try it online!](https://tio.run/##Dc1LDoIwEADQvacYGkgh2NpGGxNCvYTLWhOCEImd0fDZ9e6V3du9d7d8hhBSGgEjttoyFqkVOBEYBWg3ChMNi3OhW9acRWBZVqpnX5iqcfzE41zvtvZyJEGFufU@9q1wWkryPs47lZRn7@uaP4g3Y4nCqOpQFpXF7ytht0cWftt6X2fIYQStr@kP "Haskell – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 29 bytes
```
J;øṀṪṙŀ4C10§:oR"|||/"÷5oR'|%5
```
[Try it online!](https://tio.run/##ATMAzP9odXNr//9KO8O44bmA4bmq4bmZxYA0QzEwwqc6b1IifHx8LyLDtzVvUid8JTX///8yNTY "Husk – Try It Online")
I feel like the first `5` is redundant, but removing it gives a type error...
## Explanation
```
J;øṀṪṙŀ4C10§:oR"|||/"÷5oR'|%5  Implicit input, an integer n.
                       oR'|    Repeat the character '|'
                           %5  n mod 5 times.
             oR"|||/"          Repeat the string "|||/"
                     ÷5        n/5 times.
           §:                  Tack the '|'-string to the end of that list.
        C10                    Cut the list of strings into pieces of length 10.
   Ṁ                           For each piece,
    Ṫ ŀ4                       for each k in [0,1,2,3],
     ṙ                         rotate each string k steps to the left
                               and collect the results into a list.
                               Now we have a list of lists of lists of strings.
J;ø                            Join them with the list [[]].
                               Implicitly join each list of strings by spaces,
                               then join the resulting list of strings by newlines,
                               and print the result.
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 37 bytes
```
:5[“|||/”]ẋ;”|ẋ⁸%5¤¤W¤ṙ€4Ḷ¤s⁵Z€G€j⁾¶¶
```
[Try it online!](https://tio.run/##y0rNyan8/9/KNPpRw5yamhr9Rw1zYx/u6rYG0jVA@lHjDlXTQ0sOLQk/tOThzpmPmtaYPNyx7dCS4keNW6OAPHcgznrUuO/QtkPb/v9HUWFogKHA0gIA "Jelly – Try It Online")
# Explanation
```
:5[“|||/”]ẋ;”|ẋ⁸%5¤¤W¤ṙ€4Ḷ¤s⁵Z€G€j⁾¶¶  Main Link
:5                                     Floordiv by 5
  [“|||/”]ẋ                            Repeat ["|||/"] by this number
           ;                           Append
            ”|ẋ    ¤                   "|" repeated by
               ⁸%5¤                    The argument modulo 5
                    W¤                 Then wrapped to prevent weirdness
                      ṙ€               Rotate each tally segment by
                        4Ḷ¤            (each) [0, 1, 2, 3]
                           s⁵          Slice into pieces of length 10 (to get 50 per row)
                             Z€        Transpose each
                               G€      Convert each into a grid
                                 j⁾¶¶  Join these grids by a double newline
```
wheee this is too long
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 33 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
ā.{┐4∙F5\?X1w⁄3-14╚╬5@}┼FM»\?O¶oā
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/index.html?code=JXUwMTAxLiU3QiV1MjUxMDQldTIyMTlGNSU1QyUzRlgxdyV1MjA0NDMtMTQldTI1NUEldTI1NkM1QCU3RCV1MjUzQ0ZNJUJCJTVDJTNGTyVCNm8ldTAxMDE_,inputs=MjU2)
Golfing on a phone is hard..
Explanation:
```
ā                                  push an empty array
 .{                                repeat input times
   ┐4∙                               push a 4 tall line
      F5\?            }              if the counter (1-indexed) divides by 5
          X                            pop that vertical line
           1w⁄                         get the width of the main array
              3-                       subtract 3 from that width - X position
                1                      push 1 - Y position
                 4╚                    push a 4 long diagonal
                   ╬5                  place that in the main array at [width-3; 1]
                     @                 push a space - for the below to add spacing
                       ┼             append horizontally
                        FM»\?        if the counter divides by 50
                             O         output the main array
                              ¶o       output a newline
                                ā      push a new array
                                       (note that the outputting here doesn't disable
                                       implicit outputting)
```
[Answer]
# JavaScript (ES6), ~~139~~ 137 bytes
```
n=>eval('s="";for(i=0;i++<=n/50;s+=N)for(j=5;--j;s+=N=`\n`)for(k=0;k<(x=(y=n-i*50)<0?50+y:50);)s+=++k%5?k%5-j|k>5*(x/5|0)?"|":"/":" ";s')
```
Returns a string with one trailing newline when `n` is not a multiple of 50 and one with several trailing newlines when `n` *is* a multiple of 50.
## Ungolfed
```
n=>{
    s=""
    for(i=0; i++ <= n/50; s+=N)
        for(j=5; --j; s+=N=`\n`)
            for(k=0; k < (x = (y = n-i*50) < 0 ? 50+y : 50);)
                s += ++k%5 ?
                    k%5-j|k>5*(x/5|0) ?
                        "|"
                    : "/"
                : " "
    return s
}
```
## Test Snippet
```
f=
n=>eval('s="";for(i=0;i++<=n/50;s+=N)for(j=5;--j;s+=N=`\n`)for(k=0;k<(x=(y=n-i*50)<0?50+y:50);)s+=++k%5?k%5-j|k>5*(x/5|0)?"|":"/":" ";s')
;(I.oninput=_=>O.innerText=f(+I.value))(I.value=76)
```
```
<input id=I type=number>
<pre id=O style="border-bottom:1px solid black"></pre>
```
## Non-`eval` solution, 150 bytes
```
n=>(A=(v,m)=>j=>[...Array(v).keys()].map(m).join(j))(n/50+1|0,i=>A(4,j=>A(x=(y=n+~i*50)<0?50+y:50,k=>++k%5?k%5-4+j|k>5*(x/5|0)?"|":"/":" ")``)`
`)`
`
```
Possibly able to golf this one further but the `eval` method has been shorter so far.
[Answer]
# [J](http://jsoftware.com/), ~~50 48 45 35~~ 33 bytes
```
_50|:\'|/ '{~[{.(|.2,=i.4)$~]-5|]
```
[Try it online!](https://tio.run/##y/r/P81WTyHe1KDGKka9Rl9BvbouulpPo0bPSMc2U89EU6UuVte0JvZ/anJGvoONQ5pCZklqbrGCsYKJpYKpgYKRqdl/AA)
```
                (    =i.4)          Identity matrix of size 4.
                (  2,    )          Prepend a row of 2s.
                (|.      )          Upside down.
                          $~        Take __ rows.
                            ]-5|]   Input rounded down to a multiple of 5.
             [{.                    Pad with rows of zeroes to [input] rows.
      '|/ '{~                       Get the characters.
_50|:\                              Transpose and fit to width.
```
[Answer]
# C (gcc), 170 bytes
```
char*s="|||/ \0||/| \0|/|| \0/||| \0";h;k;g(x){for(h=0;h<5;h++){for(k=x;k>4;k-=5)printf(s+6*h);for(;k&&h-4;k--)printf("|");putchar(10);}}f(x){for(;x>49;x-=50)g(50);g(x);}
```
[Try it online!](https://tio.run/##NY3BCoMwEETP7VeUHCSrBFMxQtnGL@lFAjESakUtBEy@3SYVL/OWGXZGsV6pfVemm/NFEu99eXvxqD6h9AlREwgatNhTB5v@zNRIjuYp0BTFYVjp0LY1WiYFTPMwrpouRZMbwBSjzTLDUszOlHgCOH3XtE7vHDAEfdaja@sHutjFoadR/ssY9vh5e3fDSGG7XjStABPEgUo08Qj7Dw "C (gcc) – Try It Online")
`f` is a function taking a nonnegative integer (`x`) and printing that many tallies, grouped as specified, to stdout
`g` is a helper function that prints `x` tallies, grouped by 5, without splitting lines.
`f` calls `g(50)` and decrements `x` by 50 until it is less than 50, then calls `g(x)` to print the remaining tallies on one line.
`s` is a `char*` such that, as strings, `s` is the first row of a bundle, `s+6` is the second, `s+12` is the third, and `s+18` is the fourth, and `s+24` is an empty string.
`g(x)` prints bundles and decrements x by 5 until x is less than 5, then prints `x` single tallies.
[Answer]
# Python, ~~129~~ ~~113~~ 112 bytes
```
f=lambda n:n>50and f(50)+"\n\n"+f(n-50)or"\n".join(("|||/|||"[k:k+4]+" ")*(n//5)+" "+"|"*(n%5)for k in range(4))
```
### Explanation
```
def p(n):
  if n > 50:
    return p(50) + "\n\n" + p(n-50) # Handle 50-groups recursively
  else:
    # For each of the 4 lines:
    rows = []
    for row in range(4):
      #  - Build the "|||/"-blocks by slicing the correct part of "|||/|||".
      #  - Do that n/5 times
      #  - Then add "|" n%5 times
      rows += [("|||/|||"[row:row+4]+" ")*(n//5) + " " + "|"*(n%5)]
    # Join the four rows together
    return "\n".join(rows)
```
Works in Python 2 and 3.
[Try it online](https://tio.run/##FcdBCsIwEEbhqwwDwsSgKdq4KOhFrItIjcbUPyV0I@TuMS4evG/5rq@EY63@PLvPfXKEARfbOUzkxXZK84gRrL1g15hyM@/fKUCESymmxdc4RN3fNBOrrcAYq/6vuXDjxiqfMkUKoOzwfEivVF1ywCpeDvbU9AM)
[Answer]
# [Python 2](https://docs.python.org/2/), 142 bytes
```
n=input()
while n>0:print"\n".join("".join("|/ "[2*(j%5>3)+(n/(5*(j/5+1))and 3-i==j%5)]for j in range(min(50,n)))for i in range(4)),"\n";n-=50
```
[Try it online!](https://tio.run/##RY3RCoJAFETf@4plIbg3tV217aFYf6R6ELK8UrMiRgT9@6ZB9DQMhzPTv8Y2oIgRXtA/RuLFs5Vbo1DZXT8IRn2EXndBQPqXb6P0oVhRt3RVyQnBkJuacUnOXOOsyky8nyifLmFQnRKooca1ofukO5uCmWcif7JhTuerPTLvbMwN2e9eLNz2Aw "Python 2 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/), 103 bytes
```
$a=<>;do{$_=$a<50?"|||/ "x($a/5).'|'x($a%5):"|||/ "x10;for$i(1..4){say;s%\|/%/|%g}say""}while($a-=50)>0
```
[Try it online!](https://tio.run/##NYtBCsIwEAC/ImFDm0OTDbgX09QX@ANBAlYNFFMaQaXbrxvrwdsMw4z9NFApEHzbuXOa4eQhtIR7wcxmI141BENKV1z9UJLa/YtFd0kTxNpqvVVzDm@X5ZGNNCyvy6pCLM9bHPr1azyh6rAUsp80PmK659IcSKPFLw "Perl 5 – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 134 bytes
```
f#n=unlines$(concat.f.(<$[1..n`div`5]))<$>["|||/ ","||/| ","|/|| ","/||| "]
f n|n>50=id#50++'\n':f(n-50)|1>0=(++['|'<$[1..n`mod`5]])#n
```
[Try it online!](https://tio.run/##NY7NCoMwEITvfYolCknQxliaHor6Bj31aAOVamiobsWfnvLudin0MPPBMAzzbOZX1/fb5iIsV@w9dnMsHm98NItyShRxnSuF99Z/7sZKWcRVzUIIGbCUmIUfs/AjgWh3DjBgZXTp28joJOE35GcncG@0DHmlS5EkNQ/8Pz68Wxq3MsJtaDxCCUMzXkCM63JdJlBAfRBTN/aebnVgNPA9l0ApuyGT1HAS6jyFYwomhRO5JlFwMCe7fQE "Haskell – Try It Online")
asdfghjkl-- Yeah, I'm working on it.
[Answer]
# PHP, ~~138~~ 141+1 bytes
probably not the shortest possible solution
```
for(;0<$z=50+min($n=$x=$y=0,$argn-=50);print"
")while($n++<$z||!$x=+(3<$y+=$n=print"
"))echo"/| "[$n%5?($y+$x++)%4<3|$n%5+$y<4|$z-$z%5<$n:2];
```
Run as pipe with `-nR` or [try it online](http://sandbox.onlinephpfunctions.com/code/9ee6ee191ed8f83b9b14ae4537d0179dc4929042).
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 188 bytes
```
i->{int j=0,l,k;String r="";for(;j<~-i/50+1;j++,r+="\n")for(l=0;l<4;l++,r+="\n")for(k=0;k<(j*50+50>i?i-j*50:50);k++)r+=k%5>3?" ":k%5==3-l?"/":"|";return r.replaceAll("/(?=(\\|*\n))","|");}
```
[Try it online!](https://tio.run/##XZAxa8MwFIT3/AohKEixrbhN3cGybLoUOhQKGesOqqMEyYosZDkQkvSvu3JjKPRNH/fuhjvFjzzprDBq247yYDvngQoaGbzUZDeYxsvOkCVd2OFLywY0mvc9eOPSgPOi99wH7WW2Fa/Gi71wMdh4J82@BJ5rfXoP7AEDo0zK84SKpbGOW3pzAccgpLvOIaqK70SusjS6pyqKYhcxWBuIp59mKdXFI9X/9DbobYHUMqSytJSVTCbOsxTTNopw8LZ3WbmuIIB5IMbWia7gCubwAqkTfnAGOOKE1bwRz1ojuEIVQ3V9WdYGYxgHH6bXkc4DzJ2PndyCQ5gB3Vp8fAKOwyRgvs2p9@JAusETO/VHf1MQbq0@oYfsCWP6G7hexx8 "Java (OpenJDK 8) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 100 bytes
```
->n{(n/-50*-4).times{|i|j=[n-i/4*50,50].min
$><<("|||/|||"[i%4,4]+" ")*(j/5)+?|*(j%5)+$/*(1+i%4/3)}}
```
**Commented**
```
->n{(n/-50*-4).times{|i|              #Calculate rows of tallies (Ruby rounds division towards negative infinity. Multiply by 4 lines per tally and iterate through them.)
  j=[n-i/4*50,50].min                 #Number of strokes printed in current row is either the number remaining, or 50, whichever is less
    $><<("|||/|||"[i%4,4]+" ")*(j/5)+ #Send to stdout the correct 4 chars selected from "|||/|||" plus a space, j/5 times (rounded down, which eliminates odd strokes.) 
    ?|*(j%5)+                         #If there are any odd strokes, add them to the output
    $/*(1+i%4/3)                      #followed by a newline (2 for the final line of each row of tallies.)
  }
}
```
[Try it online!](https://tio.run/##NYyxCsMgFAD3fkWRBPQZ85QqdEjSDxGXQgMKcWibIeT57dalw8ENx73351HXuaolnzyjchqUFeM3bq/PSZHS7LOKaMHpwekwbjFfumWaOCMibDAfezvYINmVCeAJnZAPatI36RC4kS3Amyil3v/fRKtPYEwo9Qc "Ruby – Try It Online")
[Answer]
# [Pip](https://github.com/dloscutoff/pip), ~~47~~ 46 bytes
```
Wa-:yP('|X4.sRA3-_'/M,4)X(YMN[a50])/5.'|Xy%5.n
```
[Try it online!](https://tio.run/##K8gs@P8/PFHXqjJAQ70mwkSvOMjRWDdeXd9Xx0QzQiPS1y860dQgVlPfVA8oXalqqpf3//9/I1MzAA "Pip – Try It Online")
### Explanation
```
        Implicit: a is 1st cmdline arg, y is "", s is space, n is newline
W       While loop:
 a-:y   Each iteration, subtract y from a and check if a is still nonzero
        (Since "" is 0 in numeric contexts, this does nothing the first time through)
     P  Print the following:
('|X4.sRA3-_'/M,4)X(YMN[a50])/5.'|Xy%5.n
              M                           Map this function to each number in
               ,4                         range(4):
 '|X4                                      String of four pipe characters
     .s                                    Concatenate a space
       RA                                  Replace the character at index
         3-_                                (3 minus function argument)
            '/                              with forward slash
                                          We now have a list of four strings representing
                                           the rows of a group of 5 tally marks; the
                                           following operations apply to the list
                                           element-wise:
                       [a50]              List of a (number of remaining tallies) and 50
                     MN                   Get the min (number of tallies on this row)
                    Y                     Yank it into y
                   (        )/5           Divide by 5 (number of groups on this row)
(                )X                       String-multiply by that amount
                                   y%5    Number of leftover tallies on this row
                                '|X       String-multiply that many pipes
                               .          Concatenate
                                      .n  Concatenate a newline
```
The resulting list will be something like this:
```
["|||/ ||\n" "||/| ||\n" "|/|| ||\n" "/||| ||\n"]
```
By default, `P` concatenates the contents of the list together and outputs them with a trailing newline. Thus, we get
```
|||/ ||
||/| ||
|/|| ||
/||| ||
```
with *two* trailing newlines (one from the list contents and one added by `P`). If there is another row to be printed, this gives the requisite blank line in between.
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 30 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
Ｈ╷‾#％╵¹‾#÷Ｕ╷５×¹５％？４|＊］；４－；４／｝╋
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjI4JXUyNTc3JXUyMDNFJTIzJXVGRjA1JXUyNTc1JUI5JXUyMDNFJTIzJUY3JXVGRjM1JXUyNTc3JXVGRjE1JUQ3JUI5JXVGRjE1JXVGRjA1JXVGRjFGJXVGRjE0JTdDJXVGRjBBJXVGRjNEJXVGRjFCJXVGRjE0JXVGRjBEJXVGRjFCJXVGRjE0JXVGRjBGJXVGRjVEJXUyNTRC,i=MjU2,v=8)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 28 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
5‰"|||/"¬‚×J4ôTôεε3Ý._}ø»¶«,
```
[Try it online.](https://tio.run/##AUIAvf9vc2FiaWX//zXigLAifHx8LyLCrOKAmsOXSjTDtFTDtM61zrUzw50uX33DuMK7wrbCqyz//zExMf8tLW5vLWxhenk)
**Explanation:**
```
5‰              # Divmod the (implicit) input-integer by 5
                #  i.e. 111 → [22,1]
  "|||/"        # Push string "|||/"
        ¬       # Push its first character (without popping the string itself): "|"
         ‚      # Pair them together: ["|||/","|"]
          ×     # Repeat it based on the divmod
                #  i.e. [22,1] → ["|||/|||/|||/...|||/|||/|||/","|"]
           J    # Join everything together to a single string
                #  → "|||/|||/|||/...|||/|||/|||/|"
            4ô  # Which is then split into block of size 4
                #  → ["|||/","|||/","|||/",...,"|||/","|||/","|||/","|"]
Tô              # Then split this list into sublists of size 10
                #  → ["|||/","|||/","|||/",...],[...,"|||/"],["|||/","|||/","|"]]
  ε             # For-each over the sublists:
   ε            #  Map over the strings in the sublist:
    3Ý          #   Push list [0,1,2,3]
      ._        #   For each: rotate the string that many times
                #    ("|||/" → ["|||/","||/|","|/||","/|||"])
   }ø           #  After the map: zip/transpose; swapping rows/columns
     »          #  Join each inner list by spaces, and then the strings by newlines
      ¶«        #  Append a newline to each string
        ,       #  And print with trailing newline
```
`¶«,` of course has a few possible equal-bytes alternatives, like `,¶?` or `,õ,`.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 24 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
⌐å9☼,▄█┌`╕G╛ï╞▬Gpƒ\╜ª_N╬
```
[Run and debug it](https://staxlang.xyz/#p=a986390f2cdcdbda60b847be8bc61647709f5cbda65f4ece&i=1%0A4%0A5%0A6%0A50%0A51%0A256&a=1&m=2)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~107~~ 106 bytes
```
i,j;f(n){for(;n>50;f(50))n-=50;for(i=5;--i;)for(j=0;putchar(++j+~n?j%5?(j-i)%5|n-j<n%5?'|':47:32:10)%5;);}
```
[Try it online!](https://tio.run/##NY3RbsIwDEXf8xUIqSJWHJGyGlBNx4dsPKCwbo60gLruhVJ@vTPT9nbOtXVv9O8xTpNg4tZmGNpzZzk/U1ClAJB982BNpSH2XhgekprAl@8@fhw761xy97xPBe1t8gIF3bJPu6y@uC3qalM/reoyaM7A4/R5lGxhMJL7WR9fDs1QYoWEa6SAVOKK1mi2WFYjm99d/ROdk92XXN/Ore0jLP9Qb8DiHJjBXDq11s6L02ueozbLAbTB/tNoxukH "C (gcc) – Try It Online")
-1 thanks to [ceilingcat](https://codegolf.stackexchange.com/questions/147962/basic-ascii-tallies/189237?noredirect=1#comment453635_189237)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `L`, 169 [bitsv2](https://github.com/Vyxal/Vyncode/blob/main/README.md), 21.125 bytes
```
4ẋ5ẇƛ\|*₅5=[ḢėṘƛ÷$\/Ȧ;ðwj
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyJMPSIsIiIsIjThuos14bqHxptcXHwq4oKFNT1b4biixJfhuZjGm8O3JFxcL8imO8Owd2oiLCIiLCI2Il0=)
[Answer]
# Befunge, ~~125~~ 105 bytes
```
$&:!#@_:::"2"v>*\5%4\`+1g1-,1+:14g\`#v_55+,$:#v_55+,
!}0:+*`"2"\-\<^!-g01%5\!`g41+5*5/5:::<0p01:-1<<<4-p4
```
[Try it online!](http://befunge.tryitonline.net/#code=JCY6ISNAXzo6OiIyInY+Klw1JTRcYCsxZzEtLDErOjE0Z1xgI3ZfNTUrLCQ6I3ZfNTUrLAohfTA6KypgIjIiXC1cPF4hLWcwMSU1XCFgZzQxKzUqNS81Ojo6PDBwMDE6LTE8PDw0LXA0&input=MjU2)
]