[Question]
  [
Do you know the optical effect of a tridimensional hand painted whit horizontal lines?
[Examples](https://www.google.com/search?q=mano%20tridimensional%20pintada%20con%20lineas%20horizontales&rlz=1C1CHBF_esES920ES920&source=lnms&tbm=isch&sa=X&ved=2ahUKEwjP8e-v99DwAhVDUhoKHW1tARkQ_AUoAXoECAEQAw&biw=1920&bih=937#imgrc=twMWoWZ6Msj0EM)
This challenge consists of making something like that effect with ascii, and transforming one 2d input into a "3d" output.
## The algorithm
To perform this transformation, you first replace all `1` with a `¯` and all `0` with a `_`. In order to make things more realistic, you should replace a `¯` that does not have another `¯` before it with `/`, and a `¯` that does not have another `¯` after it with `\`.
Some examples:
```
Input:
001111100
Output:
__/¯¯¯\__
```
```
Input:
0110
1111
Output:
_/\_
/¯¯\
```
^ In this case, there are multiple lines, so apply this to all lines.
```
Input:
000000000000000000000000000000000
000000111100000000000001111100000
000000111110000000000111111000000
000000111111000000011111100000000
000000111111000001111110000000000
000000011111100011111100000000000
000000111111111111111100000000000
000000111101111111011110000000000
000000111100111110011110000000000
000000111111111111111110000000000
000000111111111111111110000000000
000000001111111111110000000000000
000000000001111100000000000000000
000000000000000000000000000000000
Output:
_________________________________
______/¯¯\_____________/¯¯¯\_____
______/¯¯¯\__________/¯¯¯¯\______
______/¯¯¯¯\_______/¯¯¯¯\________
______/¯¯¯¯\_____/¯¯¯¯\__________
_______/¯¯¯¯\___/¯¯¯¯\___________
______/¯¯¯¯¯¯¯¯¯¯¯¯¯¯\___________
______/¯¯\_/¯¯¯¯¯\_/¯¯\__________
______/¯¯\__/¯¯¯\__/¯¯\__________
______/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\__________
______/¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯\__________
________/¯¯¯¯¯¯¯¯¯¯\_____________
___________/¯¯¯\_________________
_________________________________
```
Exceptions / rules:
* The input will never have a single positive cell in a row (e.g. `00100`)
* You can consider other characters for the input. However, it should only be two characters and not the same characters that the output uses. For instance:
```
Valid input:    0001111000 # two characters, different from the output
Valid input:    aaiiaiiaaa # two characters, different from the output
Valid input:    ,€€€€,,,,, # two characters, different from the output
Invalid input:  0001223000 # four different characters are used.
Invalid input:  ___1111___ # invalid, because the output uses underscores.
Invalid input:  ///\\\\/// # both slash and backslash are used by the output.
```
* The output must use the four characters described above and **only** those four. Alternatively, you may use `-` instead of the macron (`¯`)
* The macron (upper character) has a codepoint of 175, but you may count it as one byte.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest code in bytes wins.
  
[Answer]
# [sed 4.2.2](https://www.gnu.org/software/sed/), Score 25
26 bytes, but scoring `¯` as 1, as per note in challenge.
```
s|1(1*)1|/\1\\|g
y/01/_¯/
```
[Try it online!](https://tio.run/##K05N@f@/uMZQw1BL07BGP8YwJqYmnatS38BQP/7Qev3//w0MDEHAwICLC8gy4AJxgExCAKoCohUJGMJFuNAFEFxDDDPgSlA4WFQYopnHha4PXQGqGQiAwy8wWay2QAQNERRBW8hRgaoGW6hjC1gsKrCDf/kFJZn5ecX/dYsA "sed 4.2.2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 16 bytes
```
Ż<ƝoḤU)⁺ị“\/Ø-_”
```
[Try it online!](https://tio.run/##y0rNyan8///obptjc/Mf7lgSqvmocdfD3d2PGubE6B@eoRv/qGHu/4e7t9gCacNDO4@1H26P5Hq4czGQW3O4/VHTmqxHjfu4uP7/NzAwBAEDA64aLiDTgAvEA7EJAagKiGYkYAgX4UIXQHANMcyAK0HhYFFhiGYeF7o@dAWoZiAADr/AZLHaAhE0RFAEbSFHBaoabKGOLWCxqMAOAA "Jelly – Try It Online")
Uses hyphens instead of macrons. Takes a good deal of inspiration from hyper-neutrino's answer, so don't forget to send him some votes. Feels like there's got to be some way to shave a byte off the string at the end, with the right replacement for `oḤ`...
```
      )            For each line,
       ⁺           twice:
Ż                  prepend a 0,
  Ɲ                then for each pair of neighboring elements
 <                 is the second greater than the first?
   o               Replace zeroes with corresponding elements of
    Ḥ              the line doubled,
     U             and reverse.
        ị          Modular 1-index into
         “\/Ø-_    "\/Ø-_".
                   (0 -> _, 1 -> \, 2 -> /, 4 -> -)
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~26~~ 19 bytes
```
1(1*)1
/$.1$*¯\
0
_
```
[Try it online!](https://tio.run/##K0otycxL/P/fUMNQS9OQS19Fz1BF69D6GC4Drvj//w0MDEHAwICLC8gy4AJxgExCAKoCohUJGMJFuNAFEFxDDDPgSlA4WFQYopnHha4PXQGqGQiAwy8wWay2QAQNERRBW8hRgaoGW6hjC1gsKrADAA "Retina 0.8.2 – Try It Online") Link includes test cases. Edit: Saved 7 bytes with inspiration from @DigitalTrauma. Explanation:
```
1(1*)1
/$.1$*¯\
```
Replace a run of `1`s with a run of `¯`s between `/` and `\`.
```
0
_
```
Replace `0`s with `_`s.
(Note that Retina uses the ISO-8859-1 code page, so `¯` is 1 byte anyway.)
[Answer]
# [Perl 5](https://www.perl.org/) (`-p -Mutf8`), 25 bytes, score 24
```
s|1(1*)1|/\1\\|g;y;01;_¯
```
[Try it online!](https://tio.run/##K0gtyjH9/7@4xlDDUEvTsEY/xjAmpibdutLawNA6/tD6//8NDAxBwMCAiwvIMuACcYBMQgCqAqIVCRjCRbjQBRBcQwwz4EpQOFhUGKKZx4WuD10BqhkIgMMvMFmstkAEDREUQVvIUYGqBluoYwtYLCqwg3/5BSWZ@XnF/3UL/uv6lpakWQAA "Perl 5 – Try It Online")
Same as [Digital Trauma](https://codegolf.stackexchange.com/users/11259/digital-trauma)'s [sed answer](https://codegolf.stackexchange.com/a/225829/70745), except the trick using semicolon delimiter the last character can be removed.
[Answer]
# [///](https://esolangs.org/wiki////), 80 bytes
```
/0/_//1/a//aaa/a-a//-aa/--a//aa-/a--//-a-/---//a-/\\\/-//-a/-\\\\//aa/\\\/\\\\/
```
[Try it online!](https://tio.run/##nZExCsAgDEV37xK@uY9QMhQ6dPP@2KhU0UaEZsnP85tgjLfE64wpweMAGAKICIRUkAqiQkgJZUJKVGgOIaAgUMhaXYWVIvlduJpYY@DciJtBL/nTo1mGwnDw1M/N92bD2KPH4i3vqTmlQu5pO@WPY/RYW7cWazgWP5ce "/// – Try It Online")
Uses `-` instead of the macron, as it is allowed.
I'm marking it as 80 bytes because of the required newline at the end of the input.
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 80 bytes (but actually 79 because ¯ is counted as a 1 byte char in this challenge)
```
import re
while r:=re.sub:print(r(*"0_",r(*"1¯",r("1(1*)1",r"/\1\\",input()))))
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/PzO3IL@oRKEolas8IzMnVaHIyrYoVa@4NMmqoCgzr0SjSENLySBeSQdEGx5aD2IoGWoYamkaAplK@jGGMTFKOpl5BaUlGpog8P@/gaGhAZchEHBxGRACUBUg1SjihnARLnQBBNcQwwy4EhQOFhWGaOZxoetDV4BqBgLg8AtMFqstEEFDBEXQFnJUoKrBFurYAhaLCuwAAA "Python 3.8 (pre-release) – Try It Online")
Because we love `re.sub` :)
## Old solution : 94 bytes (but actually 93, you know the song ...)
I don't know why but I thought a pure vanilla python solution would beat a solution using regex ... I was wrong.
```
while r:=str.replace:print(r(r(r(r(f"0{input()}0","10","\\0"),"01","0/")[1:-1],*"1¯"),*"0_"))
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPr/vzwjMydVocjKtrikSK8otSAnMTnVqqAoM69EowgK05QMqjPzCkpLNDRrDZR0lAxBREyMgZKmjpKBIZBtoK@kGW1opWsYq6OlZHhoPVBCS8kgXklT8/9/A0NDAy5DIODiMiAEoCpAqlHEDeEiXOgCCK4hhhlwJSgcLCoM0czjQteHrgDVDATA4ReYLFZbIIKGCIqgLeSoQFWDLdSxBSwWFdgBAA "Python 3.8 (pre-release) – Try It Online")
Nothing too crazy here, just a few `str.replace`, and some `str.replace` and even more `str.replace`
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 18 bytes
```
ŒgḤ1¦€N0¦€)ị“-/\_”
```
[Try it online!](https://tio.run/##y0rNyan8///opPSHO5YYHlr2qGmNnwGY0ny4u/tRwxxd/Zj4Rw1z/z/cvSUMKApEh9sj//83IAS4IJQhEKCIG8JFuNAFEFxDDDPgSlA4WFQYopnHha4PXQGqGQiAwy8wWay2QAQNERRBW8hRgaoGW6hjC1gsKrADAA "Jelly – Try It Online")
Inputs a matrix of `0` and `1`s, outputs a list of lines. Uses `-` instead of a macron
## How it works
```
ŒgḤ1¦€N0¦€)ị“-/\_” - Main link. Takes a matrix M on the left
          )        - Over each row R in M:
Œg                 -   Group adjacent equal elements in R
     €             -   Over each group G in R:
  Ḥ                -     Double:
   1¦              -     The first value
         €         -   Over each group G in R:
      N            -     Negate:
       0¦          -     The last value
                        For zeros, these are left unchanged.
                        For ones, the first becomes 2 and the last -1
            “-/\_” - Yield the string "-/\_"
           ị       - Index, 1 based and modularly. This means that:
                       1 or -3 -> -
                       2 or -2 -> /
                       3 or -1 -> \
                       4 or  0 -> _
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 18 bytes
```
Ż;0ṡ3Ḅ)ị“_./__\-_”
```
[Try it online!](https://tio.run/##y0rNyan8///obmuDhzsXGj/c0aL5cHf3o4Y58Xr68fExuvGPGub@f7h7S9ijpjVAdLg98v9/A0KAC0IZAgGKuCFchAtdAME1xDADrgSFg0WFIZp5XOj60BWgmoEAOPwCk8VqC0TQEEERtIUcFahqsIU6toDFogI7AAA "Jelly – Try It Online")
Uses `-` instead of the macron
```
Ż;0ṡ3Ḅ)ị“_./__\-_”  Main Link; takes a matrix of bits and outputs a list of lines
      )             For each row
Ż                   Prepend 0
 ;0                 Append 0
   ṡ3               Get overlapping slices of length 3
     Ḅ              Convert from binary
                 // basically, the center of the 3-slice is the character itself
                 // and we need the left and right context to determine if it needs
                 // to be changed. So ___, __-, -__, and -_- (0, 1, 4, 5) become _,
                 // _-- (3) becomes /, --_ (6) becomes \, and --- (7) stays as -
       ị“_./_.\-_”  index into "_./_.\-_", so 1=_ 3=/ 4=_ 5=_ 6=\ 7=- 0=_
                 // note that Jelly is 1-indexed and indexes wrap around
```
[Answer]
# JavaScript (ES6), 54 bytes\*
*\* by counting the macron as 1 byte, as allowed in this challenge*
```
s=>s.replace(/./g,(c,i)=>'_/¯\\'[c*=!+s[i+1]-~s[i-1]])
```
[Try it online!](https://tio.run/##nZBBTsQgFIb3nAJXgJ1SWBu60wvMctoYwtCKIVChmhijV/IOXqy2GWdqK5NJ/DeP//Hxv/Ae5YuMKpiuz53f66ERQxRlpEF3ViqNC1q0G6w2hogS3Rdfn1WFdupaXGVxZzJe5x9jzXldkyHop2cTNEZNRGQMkPs7Y/X21SnMCO39tg/GtZjQ2FnTY1S5yo1g48OtVA84QlHCNwCh8i56q6n1LW5wJDCDaCJvwDsZGOOTGANgqgCMnh2Pl/RDHAJ@iZ86YN2YLf@TcUIWJkHwVR5Yv1sDy4xZZ/5yvE1OOTT5XC5O@Q@xZFJbTy02QaT1DQ "JavaScript (Node.js) – Try It Online")
[Answer]
# Excel (Insider Beta), ~~139~~ 96 bytes
```
=LET(s,LAMBDA(t,x,y,SUBSTITUTE(t,x,y)),s(s(s(s(s(A2,101,"\_/"),10,"\_"),0&1,"_/"),0,"_"),1,"-"))
```
Had to spend quite a few bytes shortening the `SUBSTITUTE` function. Originally, I thought you had to adapt to any two characters which is what I did below.
```
=LET(s,LAMBDA(t,x,y,SUBSTITUTE(t,x,y)),a,LEFT(A2),b,LEFT(s(s(A2,a,""),"
","")),s(s(s(s(s(A2,b&a&b,"\_/"),b&a,"\_"),a&b,"_/"),a,"_"),b,"-"))
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 24 bytes
```
εγεS¬·0ǝR¬(0ǝR}˜"_¯/\"sè
```
[Try it online!](https://tio.run/##yy9OTMpM/V/z/9zWc5vPbQ0@tObQdoPjc4MOrdEAUbWn5yjFH1qvH6NUfHjF/1qvQ7v/GxACXBDKEAhQxA3hIlzoAgiuIYYZcCUoHCwqDNHM40LXh64A1QwEwOEXmCxWWyCChgiKoC3kqEBVgy3UsQUsFhXYAQA "05AB1E – Try It Online") Takes input as a list of lines of ones and zeros and outputs as a list of lists of characters in each line.
```
εγεS¬·0ǝR¬(0ǝR}˜"..."sè  # trimmed program
                         # implicit input...
ε                        # with each element replaced by...
                      è  # list of characters in...
                "..."s   # literal...
                      è  # with indices in...
               ˜     s   # flattened...
 γ                       # list of groups of consecutive equal elements in...
                         # (implicit) current element in map...
  ε                      # with each element replaced by...
             R           # reversed...
        R                # reversed...
   S                     # list of characters in...
                         # (implicit) current element in map...
       ǝ                 # with element at index...
      0                  # literal...
       ǝ                 # replaced with...
    ¬                    # first element of...
   S                     # list of characters in...
                         # (implicit) current element in map...
     ·                   # doubled...
             ǝ           # with element at index...
            0            # literal...
             ǝ           # replaced with...
          ¬              # first element of...
        R                # reversed...
   S                     # list of characters in...
                         # (implicit) current element in map...
       ǝ                 # with element at index...
      0                  # literal...
       ǝ                 # replaced with...
    ¬                    # first element of...
   S                     # list of characters in...
                         # (implicit) current element in map...
     ·                   # doubled...
           (             # negated
               }         # exit map
                         # (implicit) exit map
                         # implicit output
```
`R}` can also be a `}í` with no change in functionality: [Try it online!](https://tio.run/##yy9OTMpM/V/z/9zWc5vPbQ0@tObQdoPjc4MOrdEAUrWH156eoxR/aL1@jFLx4RX/a70O7f5vQAhwQShDIEARN4SLcKELILiGGGbAlaBwsKgwRDOPC10fugJUMxAAh19gslhtgQgaIiiCtpCjAlUNtlDHFrBYVGAHAA "05AB1E – Try It Online")
[Answer]
# [Pip](https://github.com/dloscutoff/pip) `-rl`, 21 "bytes"
```
gR+X1'/.TM_.'\TRt"¯_"
```
[Try it online!](https://tio.run/##K8gs@P8/PUg7wlBdXy/EN15PPSYkqETp0Pp4pf//DQ0NcAIuCGVoiKYIJGCIJGmIJmWIrBMuC@dgSiIxudBVI5uBohMBMF0Lk0A3FsI3RFD4jCVeElUaLfiwBROqJAb4r1uUAwA "Pip – Try It Online")
### Explanation
```
g                      With -r flag, g is a list of all lines from stdin
 R                     In each line, replace
  +X1                   regex match of one or more 1's
                        with this callback function:
        TM_              Trim the first and last characters from the match
     '/.                 Prepend /
           .'\           Append \
              TR       Transliterate
                t      10
                 "¯_"  into ¯_
                       Autoprint, one list element per line (-l flag)
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal) `aṠD`, 21 bytes
*-1 from Aaron Miller*
```
ƛĠƛ⌊ḣ$NpṫdJ`_¯\/`$İ;f
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=a%E1%B9%A0D&code=%C6%9B%C4%A0%C6%9B%E2%8C%8A%E1%B8%A3%24Np%E1%B9%ABdJ%60_%C2%AF%5C%2F%60%24%C4%B0%3Bf&inputs=0110%0A1111&header=&footer=%23%20Print%20nicely%0A%E1%B9%85%3B%E2%81%8B)
Heavily inspired by [@caird coinheringaahing's Jelly answer](https://codegolf.stackexchange.com/a/225819/80050).  
Outputs a list of lines containing a list of characters in each line. Uses the actual macron!
```
ƛĠƛ⌊ḣ$NpṫdJ`_¯\/`$İ;f    
ƛ                       For each line of (implicit) input...
 Ġƛ                ;     For each group of consecutive characters...
   ⌊                      Convert each character to an integer (so double and negate work)
      N                   Negate...
    ḣ$ p                    the first element of the group.
         d                Double...
        ṫ J                 the last element of the group.
                  İ       Index each element...
           `_¯\/`$          in "_¯\/" (negative indices start from the back)
                    f    Flatten the list of groups to a lists of chars
```
[Answer]
# [J](http://jsoftware.com/), 48 44 43 41 bytes
```
'_^/\'{~(>./@,+:@g&.|.,:3*g=.1=2-/\,&0)"1
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/1ePj9GPUq@s07PT0HXS0rRzS1fRq9HSsjLXSbfUMbY109WN01Aw0lQz/a3KlJmfkK6QBNRsCoYGCjpUhmGX4HwA "J – Try It Online")
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 56 bytes, 54 by the rules
```
gsub(0,"_")gsub(1,"/\\")gsub(/\\\//,"¯")gsub("/¯","/")
```
[Try it online!](https://tio.run/##SyzP/v8/vbg0ScNARyleSRPMNNRR0o@JgXKArBh9fR2lQ@uhAkr6QCZQhZLm//8GhAAXhDIEAhRxQ7gIF7oAgmuIYQZcCQoHiwpDNPO40PWhK0A1AwFw@AUmi9UWiKAhgiJoCzkqUNVgC3VsAYtFBXYAAA "AWK – Try It Online")
Substitutes: all `0` to `_`; all `1` to `/\`; all `\/` to `¯`; and, finally, all `/¯` to `/`.
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 52 bytes, 51 by the rules
```
gsub("01","0/")gsub(10,"\\0")gsub(0,"_")gsub(1,"¯")
```
[Try it online!](https://tio.run/##SyzP/v8/vbg0SUPJwFBJR8lAX0kTzDU00FGKiTGA8oCceJiEjtKh9Uqa//8bEAJcEMoQCFDEDeEiXOgCCK4hhhlwJSgcLCoM0czjQteHrgDVDATA4ReYLFZbIIKGCIqgLeSoQFWDLdSxBSwWFdgBAA "AWK – Try It Online")
Thanks to DLsoc for a 52 bytes/51 characters version.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 17 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepge)
```
γε¬i¦¦…/ÿ\]JT„¯_‡
```
I/O as a multiline string.
[Try it online.](https://tio.run/##yy9OTMpM/f//3OZzWw@tyTy07NCyRw3L9A/vj4n1CnnUMO/Q@vhHDQv//1dSUjIwMAQBAwMuIMOAC8TmMiAEoCogGpGAIVyEC10AwTXEMAOuBIWDRYUhmnlc6PrQFaCagQA4/AKTxWoLRNAQQRG0hRwVqGqwhTq2gMWiAjsAxvh/Xd28fN2cxKpKAA)
**Explanation:**
```
γ           # Split the (implicit) input-string into equal adjacent parts
            #  i.e. "0110\n1111" → ["0","11","0","\n","1111"]
 ε          # Map each part to:
  ¬         #  Get its first character (without popping)
   i        #  If this is a 1:
    ¦¦      #   Remove two characters from this string
      …/ÿ\  #   Surround it with leading "/" and trailing "\"
 ]          # Close both the if-statement and map
            #  → ["0","/\","0","\n","/11\"]
  J         # Join everything back together
            #  → "0/\0\n/11\"
   T   ‡    # Then transliterate the characters "1" and "0"
    „¯_     # to the characters "¯" and "_"
            #  → "_/\_\n/¯¯\"
            # (after which the result is output implicitly)
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 20 bytes
```
ＷＳ⟦⪫Ｅ⪪ι0∧κ⪫/\×¯⁻Ｌκ²_
```
[Try it online!](https://tio.run/##S85ILErOT8z5/788IzMnVUHDM6@gtCS4pCgzL11DU1MhAMgo0Yj2ys/M0/BNLNAILsjJLNHI1FFQMlDS1FFwzEvRyNZRAEsr6cfEKOkohGTmphZrKB1aD2T7ZuaVFmv4pOall2RoZAPVG2mCAFB3vJJmrKb1//8GhAAXhDIEAhRxQ7gIF7oAgmuIYQZcCQoHiwpDNPO40PWhK0A1AwFw@AUmi9UWiKAhgiJoCzkqUNVgC3VsAYtFBY6Y@69blgMA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
ＷＳ⟦
```
Loop over each input string and print each output on a new line until an empty line is reached. (String array input format would have saved a byte.)
```
⪫Ｅ⪪ι0∧κ⪫/\×¯⁻Ｌκ²_
```
Split each string on `0`s, then replace each (non-empty) run of `1`s with a run of `¯`s wrapped in `/` and `\`, finally joining with `_`s.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 19 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
√E6∙²δ♪₧♂─Ç,áR0Z◄@╖
```
[Run and debug it](https://staxlang.xyz/#p=fb4536f9fdeb0d9e0bc4802ca052305a1140b7&i=%22%22%22%0A000000000000000000000000000000000%0A000000111100000000000001111100000%0A000000111110000000000111111000000%0A000000111111000000011111100000000%0A000000111111000001111110000000000%0A000000011111100011111100000000000%0A000000111111111111111100000000000%0A000000111101111111011110000000000%0A000000111100111110011110000000000%0A000000111111111111111110000000000%0A000000111111111111111110000000000%0A000000001111111111110000000000000%0A000000000001111100000000000000000%0A000000000000000000000000000000000%0A%22%22%22)
A regex based solution similar to the Pip and sed answers. Takes a full multiline string.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~71 65~~ 61 bytes
```
n=>n.replace(/./g,(e,i)=>+e?+n[i+1]?+n[i-1]?'-':'/':'\\':'_')
```
[Try it online!](https://tio.run/##nVDRCoMgFH33R1RM3X0d2D5kjRXNohEaNfb7ThZLdI5gB/Rwj@eei/fePJulnYfpwY29adcpZ1RpxKynsWk1kUL2BdHFQFXJ9ImZ88Dg8mbuGXN8xNKfqvLXFVPXWrPYUYvR9qQj9WEPaCXwiHTYFJQKoYSvjM0SFRkHJHko7UsNcUbAj798XrNTVhEC7U75xxF7clvPLTbjyKOm1L0A "JavaScript (Node.js) – Try It Online")
## How it works
Replaces every letter. For each letter in question: if the numerical representation is falsy (`0`) then replace with `_`, otherwise use a simple ternary to find the correct character to use. Uses `-` instead of macron, you know, just because. Saved 6 bytes by reorganizing and removing assignment to unused `a` variable. Then saved 4 thanks to a username by entirely getting rid of variables.
[Answer]
# Mathematica,  74 bytes
```
StringReplace[#,{"101"->"\_/","01"->"_/","10"->"¯\\","0"->"_","1"->"¯"}]&
```
]