[Question]
  [
Your program should take as input a number `n` that is greater than 0 and output a bar composed of `n // 8` ‚ñâ characters (U+2588), as well as a final character which should be one of ‚ñâ ‚ñä ‚ñã ‚ñå ‚ñç ‚ñé‚ñè(U+2589 to U+258F) representing `n % 8`. If `n % 8` is 0, your program should not output any additional characters. This is difficult to explain well in text, so here are some examples:
```
Input: 8
Output: ‚ñà
Input: 32
Output: ‚ñà‚ñà‚ñà‚ñà
Input: 33
Output: ‚ñà‚ñà‚ñà‚ñà‚ñè
Input: 35
Output: ‚ñà‚ñà‚ñà‚ñà‚ñç
Input: 246
Output: ‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñà‚ñä
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest answer wins.
  
[Answer]
# Excel (ms365), 56 bytes
* -2 Bytes thanks to @[EngineerToast](https://codegolf.stackexchange.com/users/38183/engineer-toast)
[![enter image description here](https://i.stack.imgur.com/UH5yu.png)](https://i.stack.imgur.com/UH5yu.png)
Formula in `B1`:
```
=REPT("‚ñà",A1/8)&IF(MOD(A1,8),UNICHAR(9616-MOD(A1,8)),)
```
[Answer]
# [Julia 0.7](http://julialang.org/), ~~35~~ ~~32~~ 27 bytes
```
!n='‚ñê'.-diff((0:8:n)‚à™n)
```
[Try it online!](https://tio.run/##yyrNyUw0//9fMc9W/dG0Cep6uimZaWkaGgZWFlZ5mo86VuVp/i8oyswrycnT08jKzwSSeooahlbGZpqamv8B "Julia 0.7 ‚Äì Try It Online")
Generates a range from 0 to n with step 8, and n itself force-included. Then taking the `diff` produces our codepoint offsets, e.g. `35` gives `8 8 8 8 3`, etc. Returns character arrays.
Analogous solution in R:
# [R](https://www.r-project.org), ~~45~~ ~~44~~ 43 bytes
```
\(n)intToUtf8(9616-diff(c(0:(n/8-.1)*8,n)))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGiNNulpSVpuhY3tWM08jQz80pC8kNL0iw0LM0MzXRTMtPSNJI1DKw08vQtdPUMNbUsdPI0NTUhWtYVJxYU5FRqGFoZm-mkQQUXLIDQAA)
Thanks to amelies and MarcMush for -3 and -5 on Julia and pajonk for -1 on R.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
s8·∫à‚ÅΩ"s_·ªå
```
A monadic Link that accepts a non-negative integer and yields a list of characters.
**[Try it online!](https://tio.run/##y0rNyan8/7/Y4uGujkeNe5WK4x/u7vn//7@RiRkA "Jelly ‚Äì Try It Online")**
### How?
```
s8·∫à‚ÅΩ"s_·ªå - Link: integer, n   e.g. 17
 8       - eight
s        - split (implicit [1..n]) into chucks of length (8)
                                   [[1..8],[9..16],[17]]
  ·∫à      - length of each          [8,8,1]
   ‚ÅΩ"s   - 9616
      _  - subtract (vectorises)   [9608,9608,9615]
       ·ªå - cast to characters      ['‚ñà','‚ñà','‚ñè']
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~43 41~~ 36 bytes
```
lambda n:~-n//8*'‚ñâ'+chr(9608-n%-8)
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSHPqk43T1/fQkv90bROde3kjCINSzMDC908VV0Lzf9p@UUKmQqZeQpFiXnpqRqGOgqGBgaaVlwKBUWZeSUaxSVFGpmaelVpmTk5GkaaOgrqunbqOgppQEHN/wA "Python 3 ‚Äì Try It Online") (Fails for n=0)
* -2 thanks to 97.100.97.109
* -5 thanks to loopy walt
(Note: 9608 is the decimal value of 0x2588)
[Answer]
# x86-64 machine code, ~~18~~ 16 bytes
```
AB B8 88 25 00 00 83 EE 08 77 F5 29 F0 48 AB C3
```
[Try it online!](https://tio.run/##VVLRjtowEHyOv2KbCsk5AoJwUARHq@qke6IvbU@qBAgZxwFXxm5tcwQhfr3p2iDRPsRZz87Mji3zzpbzpnkvNVeHUsCT86U03d1HcoeU4UyJ/7Ej3zEbIMLcHih8TSnpbpXZMAUVsZPEeeNKUk2SvXkDweocenUxHI9J4g4bEE7mgPVPBvaGBArCJCp/k8QKT7IUsil5M7KEisaRa/8ALgepPehsCrFlKZIICdieSU0zckYX4a@56fx5/Xk@zyEVev36rfv6/aUzTlGR3AzBCndQfjHsFytEK2OBBi8JM@hP8fc0g6KHRbudkQStMSHzkscQovZ8sULmeVDkMBjgN8yheBxd0CqJMbEZPfoj@ITV5KqRnf6HMC6p6HV@Hg6E@@Mvi7KKztOWXPqWckudYi@/xQycC/mHtdRfGN9JLYCbUkziycLcGuf2cjjhtjRwvgug1St@oOVpRulBO7nVooRwFQ@ZzRZ1u73Kphc47qQSQE/wDm3q50G8sLsHbUnYnLxwWYxXY/vSNH94pdjWNZ396BEXfBozFAj1Fw "C (gcc) ‚Äì Try It Online")
Following the standard calling convention for Unix-like systems (from the System V AMD64 ABI), this takes in RDI an address at which to place the result, as a null-terminated UTF-32 string, and takes the number `n` in ESI. The starting point is after the first byte.
In assembly:
```
r:  stosd           # Write EAX to the string, advancing the pointer.
f:  mov eax, 0x2588 # (Start here) Set EAX to 0x2588.
    sub esi, 8      # Subtract 8 from the input number in ESI.
    ja r            # Jump back if the number was greater than 8.
    sub eax, esi    # Subtract ESI from EAX, increasing it by 0 to 7.
    stosq   # Write RAX (the 64-bit register containing EAX) to the string,
            #  advancing the pointer. Because it's little-endian,
            #  the first 32 bits are the value of EAX, and the next 32 bits are 0
            #  (as the high bits are zeroed when operating on only EAX)
            #  to add the null terminator.
    ret             # Return.
```
[Answer]
# [Factor](https://factorcode.org), 66 65 64 46 bytes
```
[ [1,b] 8 group [ length ] map 9616 v-n vabs ]
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70sLTG5JL9owU2H0GBPP3crhdzEkgy9osS89NRihfSi_NKCzLx0heLUwtLUvGSgUGY-REVZKkhbsYI1l6mBQrShTlLs0tKSNF2Lm3rREK6CBUS7QrRCTmpeekmGQixQZ4GCpZmhmUKZbp5CWWJSsQJU1yaQTLRCQVFmXglQXWpicgZEYsECCA0A)
* -1 byte from Mama Fun Roll
* -1 more by taking an entirely different approach
* -18(!) by porting Jonathan Allan's amazing [Jelly answer](https://codegolf.stackexchange.com/a/254276/97916).
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 14 bytes
```
‚≠Ü‚™™√óœàÔºÆ‚Å∏‚ÑÖ‚Åª‚Åπ‚Å∂¬π‚Å∂Ôº¨Œπ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRCO4BEil@yYWaAQX5GSWaIRk5qYWa1TqKHjmFZSW@JXmJqUWaWhq6ihYALEzUHNicglQxDczr7RYw9LM0ExHwSc1L70kQyNTEwSs//83MjH7r1uWAwA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Explanation:
```
   œà            Predefined variable null byte
  √ó             Repeated by
    ÔºÆ           Input integer
 ‚™™              Split into substrings of maximum length
     ‚Å∏          Literal integer `8`
‚≠Ü               Map over substrings and join
             Œπ  Current substring
            Ôº¨   Length
       ‚Åª        Subtract from
        ‚Åπ‚Å∂¬π‚Å∂    Literal integer `0x2590`
      ‚ÑÖ         Convert to Unicode
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 50 bytes
*-2 thanks to [@Neil](https://codegolf.stackexchange.com/users/17602/neil)*
```
f=n=>n?Buffer([226,150,144-(q=n>7?8:n)])+f(n-q):''
```
[Try it online!](https://tio.run/##DcxBDoIwEADAr@yN3RQawAoGLSQmvsCj8UCgJRiyhVL9fuU2p/n0v34f/LyGjN1oYrSadcvd/Wut8fgqyyotznlaKJXhprmtu0vD9CZhkbONmiSJ1nlk0JBfgeGmoVIHhCAYHO9uMXJxE7IM7hn8zBOSXPvxwSOeCAQcD1H8Aw "JavaScript (Node.js) ‚Äì Try It Online")
### How?
We use `Buffer()` to build the characters from their UTF-8 encodings.
For instance, the character with code point `9608` (0x2588) is generated with:
```
Buffer([226,150,136]) // 0xE2, 0x96, 0x88
```
That's a bit lengthy, but still shorter than the infamous `String.fromCharCode(9608)`.
[Answer]
# [R](https://www.r-project.org), ~~51~~ ~~49~~ 46 bytes
```
\(n)intToUtf8(9616-c(rep(8,n/8),if(b<-n%%8)b))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMGSpMQi26WlJWm6Fjf1YjTyNDPzSkLyQ0vSLDQszQzNdJM1ilILNCx08vQtNHUy0zSSbHTzVFUtNJM0NSG6NhQnFhTkVGoYWhmb6QANgwovWAChAQ)
Still not as golfy as [Kirill L's approach](https://codegolf.stackexchange.com/questions/254265/fractional-unicode-bars#comment564396_254275), unfortunately...
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 12 bytes
```
…æ8·∫ávL9616ŒµC·πÖ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLJvjjhuod2TDk2MTbOtUPhuYUiLCIiLCIxNyJd)
Yet another port of Jonathan Allan's Jelly answer.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~46~~ 36 bytes
```
->n{?‚ñà*(n/8)<<(n%8>0?9616-n%8:"")}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsGiNNulpSVpuhY3VXTt8qrtH03r0NLI07fQtLHRyFO1sDOwtzQzNNMFMq2UlDRroWrNCkpLihXSoi1iuaAsYyME0xjBNIUzjUzMYiG6FyyA0AA)
A whopping 10 bytes saved by G B.
[Answer]
# [sclin](https://github.com/molarmanful/sclin), 25 bytes
```
O>a8/`"len"map9616- _ c>S
```
[Try it here!](https://replit.com/@molarmanful/try-sclin) Port of @Jonathan Allan's clever Jelly answer!
For testing purposes:
```
[8 32 33 35 246] ( ; n>o ) map
O>a8/`"len"map9616- _ c>S
```
## Explanation
Prettified code:
```
O>a 8/` \len map 9616- _ c>S
```
Assuming input *n*.
* `O>a` range [0, *n*)
* `8/`` chunk into lengths of max 8
* `\len map` get lengths of each chunk
* `9616- _` subtract from 9616
* `c>S` convert to fractional block char
---
# [sclin](https://github.com/molarmanful/sclin), 38 bytes
```
8/%"‚ñà"rot ** >o""Q"9616- _ c>S >o"&#
```
[Try it here!](https://replit.com/@molarmanful/try-sclin) Outputs the bars.
For testing purposes:
```
[8 32 33 35 246] ( ; ""n>o ) map
8/%"‚ñà"rot ** >o""Q"9616- _ c>S >o"&#
```
## Explanation
Prettified code:
```
8/% "‚ñà" rot ** >o dup ( 9616- _ c>S >o ) &#
```
* `8/%` divmod by 8
* `"‚ñà" rot **` repeat `‚ñà` <div part> times
* `>o` output
* `dup (...) &#` execute if <mod part> is truthy (i.e. greater than 0)...
	+ `9616- _ c>S` convert to fractional block char
	+ `>o` output
[Answer]
# Mathematica, 59 bytes
```
FromCharacterCode[9616-Tr[1^#]&/@Range@#~Partition~UpTo@8]&
```
[View it on Wolfram Cloud!](https://www.wolframcloud.com/obj/f1ee3d30-f224-4566-9de9-237aa5b00f9d)
[Answer]
# [///](https://esolangs.org/wiki////), 73 bytes
```
/d/iii//ddii/‚ñà//ddi/‚ñâ//dd/‚ñä//dii/‚ñã//di/‚ñå//d/‚ñç//ii/‚ñé//i/‚ñè/
```
[Try it online!](https://tio.run/##K85JLM5ILf6vz6Wv/18/RT8zM1NfPyUFSD6a1gFmARmdIAaQ7gLSYJluEANI9wBpINWrrw8W7gPSQKpf/38mkeA/AA "/// ‚Äì Try It Online")
Input is a unary.
[Answer]
# [Rust](https://www.rust-lang.org), 61 bytes
```
|n,r|{*r=[9608].repeat((!-n/8)as _);r.push((9615-!-n%8)as _)}
```
A `fn(i32,&mut Vec<u32>)`, where the first argument is `n`, and `r` is a mutable reference to a vector where the output will be stored.
[Attempt This Online!](https://ato.pxeger.com/run?1=rZJBa8IwGIZhR3_FpzBJRq1rO7sarf9hl11EpOsSFGzsknQM1PsYyG677OLB_Sh33C9Zqpna9roQKLzP-37fG-jnVmRSbXZtxiGJphxhWNRmVAEjwDjiZOq5lqCSNJNMwT2N-5nnDnD4lSnWCnbhkltiubgS4bDrXwcjW9CURgqheou3AxxJGOOesNNMThDq-k6npcGlAavDkO-Lu16tBvrkexWVCkLQc4G-pDRW9JFAUyqx1MXAnNyY93nImPY-07g-HPWOlCEdbhqOT3okJRVqTJ_qSIPTfDueREIibCdRivTzCGFinmA7ns9m2kBIP3_3eDBA2IIG1xsXq4YF3IxemfZ5c-Rox8_He8OwvebttXVBC_baa0HrHrRy3PH_9KLduT3q5Yh7c4aKKbdzjipV3SItZj2vRCvxTsWwLhXzK47_vW_5PvNnbTaH7y8)
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 30 bytes
```
.+
$*
1{1,8}
$.&
T`8-1`‚ñâ-‚ñè
```
[Try it online!](https://tio.run/##K0otycxL/P9fT5tLRYvLsNpQx6KWS0VPjSskwULXMOHRtE7dR9P6//@34DI24jI25jI25TIyMQMA "Retina 0.8.2 ‚Äì Try It Online") Link includes test cases. Explanation:
```
.+
$*
```
Convert to unary.
```
1{1,8}
$.&
```
Convert groups of up to 8 to decimal.
```
T`8-1`‚ñâ-‚ñè
```
Map digits to the appropriate Unicode character.
[Answer]
# [Sequences](https://github.com/nayakrujul/sequences), 30 bytes
```
iH8/nx$\‚ñâ$""Jfh8%H?9616h-VF:
```
Sequences was definitely not made for this!
**Explained:**
```
iH8/nx$\‚ñâ$""Jfh8%H?9616h-VF:
iH                            // Get an integer input and store in `h`
  8/                          // Divide by 8
    n                         // Convert to integer (floor)
     x$  $                    // This many times:
       \‚ñâ                     //   Push the string "‚ñâ"
                              // Implicitly put into a list
          ""J                 // Join by empty strings
             f                // Output with no newline
              h               // Push `h`
               8%H            // Mod by 8 and store in `h`
                  ?           // If this is truthy (h != 0)
                       h      //   Push `h`
                   9616 -     //   Subtract from 9616
                         V    //   Get chr of the result
                          F   //   Output with a newline
                           :  // Else: (do nothing)
```
In Sequences there is no way of multiplying an integer with a string, so we have to settle for making a list of that string, repeated, and then join it by an empty string.
Also, Sequences uses the 96 printable ASCII characters as its codepage, but because we have `‚ñâ` in our code, we have to use UTF-8.
[Answer]
# [Haskell](https://www.haskell.org), ~~[44](https://codegolf.meta.stackexchange.com/questions/13376/is-a-crossed-out-4-still-a-4)~~ 40 bytes
```
f n|n<9=[toEnum$9616-n]
f n='‚ñà':f(n-8)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m708I7E4OzUnZ8GCpaUlaboWNzXSFPJq8mwsbaNL8l3zSnNVLM0MzXTzYrmA4rbqj6Z1qFulaeTpWmhC1WvmJmbmKdgq5CYW-CpoFJSWBJcU-eQp6CmkAbFGnJGmpkK0oZ6ekUEsRAPMIgA)
-4 bytes by ignoring `n=0`
[Answer]
# [Go](https://go.dev), ~~91~~ ~~81~~ 73 bytes
```
func f(n int)(s string){
for;n>8;n-=8{s+="‚ñâ"}
s+=string(9616-n)
return}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=Lc4xCsIwFAbgPacInRJMBVst0VJ3N8FRREJpStG-liSdQg_gBVxciuAhPIqrJzGxnd4bfr7_fzzLZni3Ir-IssC1qABVddsoMw9kbYJXZ2TIPzvZQY4lAVyBoURjbVQFJbVINiqFLU8hzLjVsyz43m9Bj9w3Rsg6WSQhUKQK0ynoJ_DwB30dcQhovMnw8eRwy1kcsThm8YpFy6T3BfjMwAeUALfRhS3aO9tcgQDzqyhFPZroYRjvDw)
* -10 bytes by @jdt
* -8 bytes by @Neil
[Answer]
# Java 11, ~~58~~ ~~48~~ 39 bytes
```
n->"‚ñà".repeat(--n/8)+(char)(9615-n%8)
```
-9 bytes thanks to *@Neil*.
Doesn't support `n=0`.
[Try it online.](https://tio.run/##LY9BbsIwEEX3nGIUqZKtjINCSEhBcAPYdElZuMa0pmESOQNVhbLvCXrAXiR1gM1IM6P/3/9HfdHquP/sTaXbFtba0XUE4IitP2hjYTOsAC/sHb2DEeEDJBfh2I3CaFmzM7ABgmVPahX9/f5EibeN1SyUonEpY2E@tJfiuUhzRU@l7BeDsjm/VUH5MLjUbg@nQBd30nan5Z18qP0N6uZkv4Zg2901xQlmOMUcC5xhiekMs3DJMMtxMi06eVOG1N8t21NSnzlpgitXJFwczeGVo5iSUEY@mnT9Pw)
**Explanation:**
```
n->                  // Method with integer parameter and String return-type
  "‚ñà".repeat(        //  Repeat this character
             --n/8)  //  `n-1` integer-divided by 8 times
                     //  (by first decreasing `n` by 1 with `--n`)
  +(char)            //  Append an integer casted to a character:
         (9615-n%8)  //   9615 minus (`n-1` modulo 8)
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~14~~ ~~11~~ 10 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
L8√¥‚Ç¨g≈Ωb¬∂Œ±√ß
```
[Try it online!](https://tio.run/##AR4A4f9vc2FiaWX//0w4w7Tigqxnxb1iwrbOscOn/0r/MTc "05AB1E ‚Äì Try It Online") (I've put `J` for join in the footer, but apparently outputting a list of characters is ok)
* -3 thanks to S ®…†…†an
* -1 thanks to Kevin Cruijssen
### Explained
```
L8√¥‚Ç¨g≈Ωb¬∂Œ±√ß  # Implicit integer input          17
L           # Inclusive range                 [1, 2, ..., 17]
 8√¥         # Split into groups of 8          [1, ..., 8], [9, ..., 16], [17]
   ‚Ç¨g       # Length of each                  [8, 8, 1]
     ≈Ωb¬∂    # 9616
        Œ±   # Absolute difference from 9616   [9608, 9608, 9615]
         √ß  # chr of each                     ["‚ñà", "‚ñà", "‚ñè"]
            # Implicit output
```
[Answer]
# [C (clang)](http://clang.llvm.org/), ~~54~~ 50 bytes
-4 bytes thanks to [@Neil](https://codegolf.stackexchange.com/users/17602/neil)!
```
f(*o,n){for(;n>8;n-=8)*o++=9608;*o++=9616-n;*o=0;}
```
[Try it online!](https://tio.run/##LY3NCsIwEITvPsUSKCT9gVSwRGN8EfUQY1MCMZW24qH01Y3bn7nsMHyzYwrjdWhitDRt88BG23ZUhouQoVCCpW2WqWPFhdxcWRUBveJyii4M8NIuUAbjDlB9PfjWaF/TKgdCmFzSGXt87FXw@xrgBNA5daCglHjOCg4cTZaxhVjfLSzFag5u@zXr3WHXUpLw/RNOkPj@Fggi@byycdNuij9jvW76WHz/ "C (clang) ‚Äì Try It Online")
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 43 bytes
```
:8,:1%-v
v1-"‚ñà"$>:?!
>~{8%:"‚ñà"+$?!~}>o<
```
[Try it online!](https://tio.run/##S8sszvj/38pCx8pQVbeMq8xQV@nRtA4lFTsre0Uuu7pqC1UrsIC2ir1iXa1dvs3///91y4xNAQ "><> ‚Äì Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 45 bytes
```
f=n=>n>8?'‚ñà'+f(n-8):Buffer([226,150,144-n])
```
[Try it online!](https://tio.run/##VY07DoJAFAB7T/E6dsNHQUSioomJJ7AkFAi7iCFvDawab@Dfbg@4F0ESbexmisns0mPaZHW5lzaKnLUtjzCa4zxcGFpdDJMTtEM6WR44ZzWJPS@w3NHAcn3fxoS2/T78gvF/EHf21uql1VOrh1Z3rW5aXY0YbTdJLBh5sDlL1sCplFtxkPA99LioCUIE7hQQZhEEfgemSSET2IiKOZUoCDpSrGVdYkGos0/zFeZkSMGEbk5p@wE "JavaScript (Node.js) ‚Äì Try It Online")
52 bytes without `Buffer`:
```
f=n=>n>7?'‚ñà'+f(n-8):['‚ñè‚ñé‚ñç‚ñå‚ñã‚ñä‚ñâ'[n-1]]
```
[Answer]
# [C (clang)](http://clang.llvm.org/), ~~46~~ 44 bytes
```
f(*o,n){for(;*o=n>0;*o++=9608-(n<0)*n)n-=8;}
```
[Try it online!](https://tio.run/##LY1BCoMwFET3nuITEBJjIBQqtmov0nZhUyOB9KeopQvx6k0TdTYDw5sZJZRtsfde08zlyGbtBlplrsGLDMZ5cypkKSjWkmXIUDRltXiDE7xag5TBnEDQ2E3WqdZ2tMiBEFatacQeH30t5X0LwjjQmBpoQFbBajhG55ytwLa2ojQ0czD7VNR7CFVNSSoPTzhDascbkoDk8WTnlmTxP6Vt249efP8 "C (clang) ‚Äì Try It Online")
From jdt's solution, support 0
[Answer]
# [jq](https://stedolan.github.io/jq/), 43 bytes
```
[9616-((range(1;./8)|8),(.-1)%8+1)]|implode
```
[Try it online!](https://tio.run/##DchBDsIgFAXA/buHCUSpPmgR4lGMCxMb06aFii45u78ks5r5I3KPnt4oVZ7pPSreunPQNeiT6gz1IRypH3VatyW/RhHCwqHHAI8rAiJ4AQm2bhzcANv7f95@U05fMWUH "jq ‚Äì Try It Online")
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), 23 bytes
```
@+9608+{ùï©>7?0‚àæùïäùï©-8;7-ùï©}
```
[Try it at BQN REPL](https://mlochbaum.github.io/BQN/try.html#code=RWlnaHRzIOKGkCBAKzk2MDgre/Cdlak+Nz8w4oi+8J2VivCdlaktODs3LfCdlal9CkVpZ2h0c8KoICjihpUzMCk=)
```
@+9608+{ùï©>7?0‚àæùïäùï©-8;7-ùï©}
       {              }  # recursive function ùïä with argument ùï©
        ùï©>7?             # if x is greater than 7
            0‚àæ           #   prepend zero onto
              ùïäùï©-8       #   result of recursive call with agument ùï©-8
                  ;      # otherwise
                   7-ùï©   #   7-ùï©
      +                  # now, add the result of this to
@                        #   the null character
 +9608                   #   +9608
```
We could use the literal character '‚ñâ' instead of `@+9608`, but this would prevent the code from being encoded with the [BQN](https://mlochbaum.github.io/BQN/) [single byte character system](https://github.com/mlochbaum/BQN/blob/master/commentary/sbcs.bqn), so the UTF8-encoded code would end-up [longer](https://mothereff.in/byte-counter#%27%E2%96%88%27%2B%7B%F0%9D%95%A9%3E7%3F0%E2%88%BE%F0%9D%95%8A%F0%9D%95%A9-8%3B7-%F0%9D%95%A9%7D).
[Answer]
# [Thunno](https://github.com/Thunno/Thunno) `J`, \$ 12 \log\_{256}(96) \approx \$ 9.88 bytes
```
R8Ap.L9616_C
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_wYKlpSVpuhZrgiwcC_R8LM0MzeKdIUJQmaXRSl5KsYuMLCFcAA)
Yet another port of Jonathan Allan's Jelly answer.
]