[Question]
  [
# Task
Given a string `s`, output a truthy value if the ASCII code of each letter is divisible by the length of `s`, and a falsey otherwise.
## Input/Output
Input is a nonempty string containing only ASCII `[32-126]`. Output is a standard truthy/falsey value. Note that you can switch the values, for example returning `0`/`False` if divisible and vice versa
## Test cases
```
Input         Output
Hello         False       (72 101 108 108 111), 5
lol           True        (108 111 108), 3
Codegolf      False       (67 111 100 101 103 111 108 102), 8
A             True        (65), 1
nope          False       (110 111 112 101),4
8  8          True        (56 32 32 56), 4
```
  
[Answer]
# [Befunge-98 (FBBI)](https://github.com/catseye/FBBI), 31 bytes
Output is via exit code, `1` for truthy, `0` for falsey cases.
```
#v~\1+
v>53p
>:#v_1q
^  >' %#@_
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tPj/X7msLsZQm6vMztS4gMvOSrks3rCQK05BwU5dQVXZIf7//5z8HAA "Befunge-98 (FBBI) – Try It Online")
---
Code running with inputs `lol` and `ab`:
[![Code with input lol](https://i.stack.imgur.com/aZPF6.gif)](https://i.stack.imgur.com/aZPF6.gif)
[![Code with input ab](https://i.stack.imgur.com/N7R0s.gif)](https://i.stack.imgur.com/N7R0s.gif)
small numbers represent literal byte values
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
ÇsgÖP
```
[Try it online!](https://tio.run/##yy9OTMpM/f//cHtx@uFpAf//5@TnAAA "05AB1E – Try It Online")
**Commented**
```
        # implicit input    "lol"
Ç       # push ASCII value  [108, 111, 108]
 s      # swap (with input) [108, 111, 108], "lol"
  g     # length            [108, 111, 108], 3
   Ö    # is divisible?     [1, 1, 1]
    P   # product           1
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~42~~ 39 bytes
```
(<1).sum.(map=<<flip(mod.fromEnum).length)
```
```
f s=sum[fromEnum c`mod`length s|c<-s]<1
```
3 fewer bytes thanks to ovs and xnor!
[Try it online!](https://tio.run/##BcExDoAgDADArzTE1cEdRl9hTCAIQmyLobD593pXgjwJUTWDOJl05N5o50kQPbXLY@J7FJAv2lVOuymFyuDg7ZUHLJDBYEOjPw "Haskell – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), 4 bytes
```
tn\~
```
* For divisible strings the output is a vector containing only `1`s, which is [truthy](https://codegolf.stackexchange.com/a/95057/36398).
* Otherwise the output is a vector containing several `1`s and at least one `0`, which is [falsy](https://codegolf.stackexchange.com/a/95057/36398).
[Try it online!](https://tio.run/##y00syfn/vyQvpu7/f/Wc/Bx1AA) Or [verify all test cases](https://tio.run/##bY7BCsIwDIbve4pcpA5k5@FFRA8@gEcFx5atgdiUNUV20FevlSFMMJDwJ3z8@e@NcrrBt1bQSVVVD0uMsCbXkyNFYBFfJnWXV9oZHaPayWSWepiXLfgYLKilAEFHckPxNH3DIWOZQw74B7ku3qLriuMyBgXPzVScF7fZYIy4ARXwo3SxRWgc/OTMse@eqSX9mJbJnJBZTGFYOM@DdDgI91nuc9cAtXkD) including truthiness/falsihood test.
### How it works
```
t   % Implicit input. Duplicate
n   % Number of elements
\   % Modulo
~   % Negate. Implicit display
```
[Answer]
# JavaScript, 32 bytes
Ouput is reversed.
```
s=>Buffer(s).some(c=>c%s.length)
```
[Try it online!](https://tio.run/##bc0xDoMwEAXRPqdASEh2Edc0RiJpcg1kdg1o449YJ9c31Mjtm2K26T9pONY9PxNmKuyL@uH1Y6bDqHWKL5ngh9CpE0oxL7YEJIWQE0TDpv2QCFprHzcXSEXf1yVCuJLGiiXsVOG@afqLywk)
[Answer]
# [Rockstar](https://codewithrockstar.com/), ~~205~~ ~~192~~ ~~175~~ 162 bytes
Well, this was fun. Rockstar has no way of reading the length of a string directly, can't convert characters to codepoints and has no modulo operator. Surprised it worked out this short!
```
listen to S
cut S
X's0
D's0
while S at X
N's32
while N-127
cast N into C
if C is S at X
let M be N/S
turn down M
let D be+N-S*M
let N be+1
let X be+1
say not D
```
[Try it here](https://codewithrockstar.com/online) (Code will need to be pasted in)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~8~~ 7 bytes
-1 byte thanks to [@isaag](https://codegolf.stackexchange.com/users/20080/isaacg)
```
!%#lQCM
```
[Try it online!](https://tio.run/##K6gsyfj/X1FVOSfQ2ff/f/Wc/Bz1f/kFJZn5ecX/dVMA "Pyth – Try It Online")
```
!%#lQCM
!        - logical negation of
  #      - filtering
     CM  - ascii values of input with
 % lQ    - func(x): return x % len(input) 
```
[Answer]
# [PHP](https://php.net/), ~~56~~ 52 bytes
```
for(;$c=ord($argn[$i++]);$c%strlen($argn)?die(f):1);
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKxVkm3zi1I0VBKL0vOiVTK1tWM1gWKqxSVFOal5EGFN@5TMVI00TStDTev//z1Sc3Ly/@UXlGTm5xX/13UDAA "PHP – Try It Online")
Output is reversed
Execution stops with `f` if any char is not divisible, or empty string (falsy in PHP) if all are divisible
EDIT: saved 4 bytes thanks to @640KB
[Answer]
# [Python 2](https://docs.python.org/2/), ~~41~~ 39 bytes
```
lambda s:all(ord(i)%len(s)<1for i in s)
```
[Try it online!](https://tio.run/##BcExDoAgDADAr3QxtKOORie/4YKBapNKCbD4@npXv/FYWZz30zW@V4rQ16iK1hIKTZoLdtpmtgYCUqCT1yZlIGM4LOXblAOR/w "Python 2 – Try It Online")
-2 bytes thanks to @ovs
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 11 bytes
```
{~+/(#x)!x}
```
[Try it online!](https://tio.run/##y9bNz/7/P82quk5bX0O5QlOxovZ/mrqGkkdqTk6@krWCUk5@Dohyzk9JTc/PSQOxHUFEXn5BKoi2UFCwUNL8DwA "K (oK) – Try It Online")
[Answer]
# [Rust](https://www.rust-lang.org/), 36 bytes
```
|s|s.iter().all(|x|1>x%s.len()as u8)
```
[Try it online!](https://tio.run/##jczBCoJAEMbxu0@xCsUslNBNKoQIpHeIiBVnRZjccnZBaH12W4OgS@Ech//36xzbUbfippoWpHhGIpxFtjB69pw2FjuQqSIC3/tN3i84JQypYuEyOU653EVDFIxpti@2omhheXbZRa7z0hjKQYffx1bM2NkrPmKoyjoGDWVyQiKTSLkSWhFj8H6VZOjd2c79y46mwtqQnmUe5oitueMsLRMi@waH8QU "Rust – Try It Online")
Takes the input as a `&[u8]`, outputs a `bool`.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~43~~ ~~37~~ ~~36~~ 32 bytes
```
->a{a.bytes.all?{|n|n%a.size<1}}
```
if only map could be used on strings..
-10 bytes from ovs.
-1 byte from Dingus.
[Try it online!](https://tio.run/##dVBLi8IwEL7PrxgKgkItndbWHqwiwrJ72svexEOKqQRCUvo4@Prt3Ym2uxcd8iWT4ZtvHnVXnPu8kCdl4MtUXYujfXctfwE@pdb2L/ohdCMHf7qMkEJiZE8QzXxMQFuN//ZTd2MCTgeaozM1hp09ypPV5QvxdDkww6FIPGYyIs7OYIv4rlCaMIPA2Eri6@aJwqcgPaaY@QvIELM3ekmKceROkrLwAnJpjgBl3s/X4iqC4tzKJhBab643czMTETTqIld0v/elrVGhMrj3Hqv0fI8XxPc4O7tbhmuVH9eDdwCssNyrA7gy/S8 "Ruby – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-pF`, 20 bytes
```
$_=!grep ord()%@F,@F
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lYxvSi1QCG/KEVDU9XBTcfB7f9/j9ScnHyunPwcLuf8lNT0/Jw0LkeuvPyCVC6Lf/kFJZn5ecX/dXMK3AA "Perl 5 – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 40 bytes
```
{0}==##&@@ToCharacterCode@#~Mod~Tr[1^#]&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n277v9qg1tZWWVnNwSEk3zkjsSgxuSS1yDk/JdVBuc43P6UupCjaME45Vu1/QFFmXomCvkO6gxZcXbG@Q7WSR2pOTr6SjlJOfg6QBGlNz89JAzIdgdhCQcECLFemVPv/PwA "Wolfram Language (Mathematica) – Try It Online")
thanks to @att for saving some bytes
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~54~~ 53 bytes
```
l;r;f(char*s){l=strlen(s);for(r=0;*s;)r|=*s++%l;l=r;}
```
[Try it online!](https://tio.run/##bY/BSsQwEIbv@xRjoJC0XayKsBIryCL4DraHpU3WQkxKJodi7bPXJK3dPRhIZjLzzz98zf7cNPOsuOWSNp8nmyIbVYnOKqEpMi6NpbYseIqc2Z8yxSxLFFel5dPcaQdfp05Ttht34E80ACfQ4UcNJYzkXShlSA5EGRXC0bTibJQM@Wt4tOlFiAeAA5l4tAm@YujF4EQbfWAscrjL4fKuymWhXZdVw9t9NTwd/X0Mnlf/h@AdRzwQ0LCh060Y/FzB1/QZsPsWRtK/3ex2LaRbhUOWRTWDBfkK23st6FFQ860feXx3Y/pPgF5wI6ljl3JvfUNSUpEEKwL7F0ha8Kn2cC4HzD259y0B63Vq2k3zLw "C (gcc) – Try It Online")
Returns falsey if the ASCII value of each character is divisible by the length of the input string or truthy otherwise.
### Explanation:
```
l;r;f(char*s){l=strlen(s);for(r=0;*s;)r|=*s++%l;l=r;}  
l;r;                                                  // Declare 2 int variables
    f(                                                // Function f taking
      char*s){                                        //   string parameter s  
              l=strlen(s);                            // Store length of s in l
                          for(                        // Loop
                              r=0;                    //   initialising r to 0
                                  *s;)                //   until end of s  
                                      r|=             // Bitwise or r with 
                                         *s           //   the ASCII value of the next
                                                      //   character...  
                                           ++         // Aside: push s pointer forward
                                             %l;      //  ... mod the string length
                                                l=r;  // Return r (r will be 0
                                                      //   iff every character was
                                                      //   divisible by the length of the   
                                                      //   input string)
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), ~~8~~ 5 bytes
```
₌CLœΠ
```
Thanks @Lyxal for saving 3 bytes
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%82%8CCL%C5%93%CE%A0&inputs=%5B%22A%22%5D%20&header=&footer=)
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), ~~40~~ 33 bytes
```
$l=$args.Count
!($args|?{+$_%$l})
```
7 bytes saved thanks to *mazzy*
[Try it online!](https://tio.run/##K8gvTy0qzkjNydFNzi9K/a@SZlv9XyXHViWxKL1Yzzm/NK@ES1EDzKuxr9ZWiVdVyanV/F/LxaVSomCroOQB1JmvxKWmkqbgUAIVy8nPQRNxzk9JTc/PSUMTdkTj5@UXpKIJWSgoWMCE/gMA "PowerShell Core – Try It Online")
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 7 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?") ([SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set"))
Anonymous tacit prefix function
```
⍱≢|⎕UCS
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1Hvxkedi2oe9U0NdQ7@n/aobcKj3r5HXc2Petc86t1yaL3xo7aJQMngIGcgGeLhCVSj7pGak5OvzpWmnpOfA6Kc81NS0/Nz0kBsRxCRl1@QCqItFBQs1AE "APL (Dyalog Extended) – Try It Online")
`⍱` are not any of the following true (non-zero)?
`≢` the length
`|` divides (lit. division remainder when dividing)
`⎕UCS` the code points
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 25 bytes
```
a=>a.All(x=>x%a.Length<1)
```
[Try it online!](https://tio.run/##jZBBa8MwDIXP8a8QhUECa2DnNIFSGD10MLbDDmMHzVFdg2Jttjs6Sn975iSs9LBB30GgxyfpIR3mWjz1@2CdgefvEKmr1GVXbqz7rJRSDjsKH6gJVtKSEd6qo4IkzRgCPHoxHrvRmfxBIWK0Gr7EtvCA1uUh@rT79Q3Qm1CcuaPKMoD7vdOLibiFdxFuYJssqHusGyyXzPmhbg43WG7Imbhb3BV9ipZl2UpcEKbyxdtIKTHlw2A@WxOzzIqiOl8a9B/Nwlezv0@4emA5kn@iT4TtSF6sOqmpnvof "C# (.NET Core) – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-e`](https://codegolf.meta.stackexchange.com/a/14339/), 6 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
c vNÎÊ
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWU&code=YyB2Ts7K&input=IkhlbGxvIg)
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 4 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
$h÷╓
```
Input as a list of characters.
[Try it online.](https://tio.run/##y00syUjPz0n7/18l4/D2R1Mn//8freShpKOUCsQ5UJyvFMsVDWWBREA8ZygvBao2HS6ro5QGVuEIJvOg4gVgdSARCyBLAYotlGIB)
**Explanation:**
```
$     # Get the codepoint of each character in the (implicit) input-list
 h    # Push the length of this list (without popping the list itself)
  ÷   # Check for each codepoint if it's divisible by this length
   ╓  # Pop and push the minimum of the list
      # (after which the entire stack joined together is output implicitly as result)
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 12 bytes
```
!$+(A_Ma)%#a
```
[Try it online!](https://tio.run/##K8gs@P9fUUVbwzHeN1FTVTnx////efkFqQA "Pip – Try It Online")
## Explanation
```
!$+(A_Ma)%#a a → input
   (A_Ma)    Map a to Unicode/ASCII codepoints
         %#a Modulo the list by it's length
 $+          Sum up the remainders
!            Not(returns 0 for any positive number, 1 for 0)
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
LḍOP
```
[Try it online!](https://tio.run/##y0rNyan8/9/n4Y5e/4D////n5OcAAA "Jelly – Try It Online") or [Verify all cases!](https://tio.run/##y0rNyan8/9/n4Y5e/wCuw@2PmtZkPWrc/v//fyUPoFS@ko6CUk5@Dohyzk9JTc/PSQOxHUFEXn5BKoi2UFCwUAIA "Jelly – Try It Online")
**Commmented:** (At least I think it works like this)
```
   P  # product of ...
L     #   does the length 
 ḍ    #   ... divide ...
  O   #   the char codes
```
[Answer]
# [R](https://www.r-project.org/), ~~39~~ 38 bytes
*Edit: -1byte thanks to the new rule that we can output TRUE for FALSE and FALSE for TRUE*
```
function(s)any(utf8ToInt(s)%%nchar(s))
```
[Try it online!](https://tio.run/##K/qfk5qXXpIRn5JZlpmSWhyfk1pSklpUbPs/rTQvuSQzP0@jWDMxr1KjtCTNIiTfM68EyFdVzUvOSCwCsjRxaNdQ8kjNyclX0uTCJZ@Tn4NH1jk/JTU9PycNjxJHPHJ5@QWpeKQtFBQs8EiHBkQ5BgDl/wMA "R – Try It Online")
Or try the [original 39-byte version](https://tio.run/##fcsxDoMwDAXQvaegSEjJDbJ0QF1gYyhLF4SIA5Esu0oM109zAbx9/fd/Kgi0y7H4eEUPeUEQgZRfJZy0SWQy2a6I5nlKcB8eSWrRdbQda6rJ3vxNOwAit/Zx58io6Js97IxBmfSKEf9AYdc0TuF5@vZT9fIH) that outputs TRUE for TRUE...
[Answer]
# [Python 3](https://docs.python.org/3/), ~~55~~ 52 bytes
```
N=input();print(not sum([ord(i)%len(N) for i in N]))
```
[Try it online!](https://tio.run/##BcExCoBQCADQq7gEOjdGV/AC0VaRYCrmHzq9vRdf3W5zN69iMQppiRQrNC94x4Ob54FCk56GTHB5goAY8E7Ura4/)
[Answer]
# [Zsh](https://www.zsh.org/), 31 bytes
```
for c (${(s::)1})((r||=#c%$#1))
```
[Try it online!](https://tio.run/##JcqxCsIwEAbg/X@Kg8ZyN3YtOIiLryExZ4TDk6QO1fjsKcXxg@9Tc1cW7uqFInH4cp1nmX7CXFo7DvEQhkmkC7CXSoxLMnOc/ZbuboqnvxJOMDe4KvRRIFAKlcaRUsxOerW6Umt/LeW95LVv "Zsh – Try It Online")
If we accept a "list of characters" as arguments, then we don't have to split the string for **19 bytes**:
```
for c;((r||=#c%$#))
```
[Try it online!](https://tio.run/##JchBCsJADAXQ/T9FoLUkV6i4EDdeQ8aJIwQjk7poHc8@Ii7f26J0ZeGuXintmWtrhyHtxkGkC/DrIMY5mzlOfs03N8XDnxlHmBtcFXqvECiNb455lvjQNFFOxUkvFiu19tdSX0tZ@xc "Zsh – Try It Online")
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 20 bytes
```
.,0@{(3$%@+\}3$*;!\;
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/X0/HwKFaw1hF1UE7ptZYRctaMcb6//@c/BwA "GolfScript – Try It Online")
This outputs 1 if the string is divisible and 0 if it isn't.
Let S be the string and L its length.
```
.,0@                  # The stack from bottom up will be: L  0  S
    {       }3$*      # Execute this block L times
     (                # Separate first char from the string as a number
      3$%             # Previous number mod L
         @+\          # Add result to the acumulator
                ;     # Discard the ""
                 !    # 1 iff the acumulator is 0
                  \;  # Discard L
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 8 bytes
```
¬⊙θ﹪℅ιＬθ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMvv0TDMa9So1BHwTc/pTQnX8O/KCUzLzFHI1NTR8EnNS@9JEOjUBMErP//t1BQsOD6r1uWAwA "Charcoal – Try It Online") Link is to verbose version of code. Output is a Charcoal boolean, i.e. `-` for true, nothing for false. Explanation:
```
  θ         Input string
 ⊙          Is there a character where
     ι      Current character
    ℅       Ordinal
   ﹪        Modulo (i.e. is not divisible by)
       θ    Input string
      Ｌ     Length
¬           Boolean NOT
            Implicitly print
```
`⬤θ¬﹪℅ιＬθ` also works of course.
[Answer]
# [Factor](https://factorcode.org/), 62 bytes
```
: f ( s -- ? ) dup length [ mod ] curry [ + ] map-reduce 0 = ;
```
[Try it online!](https://tio.run/##JYy9asMwFIX3PsXBU0ux6WhsSggptF68lEwlgyJfOaKypF5JAVP67M4lHc7v8Bmlc@Dt@DmM7x0Us1oTvok9OSwqX@7WmOJ1tsEnJPop5DUlRKac18jWZ/QPw9jhzV5tsmdHdcpyz2nrYPCIhLrGDk@YSoQjPwv2C0uYcIIuzKusZ@mLijXTVDThBa/ot19UH@RcqFC54MQPYaI5OCN1L/IhkkQLtBX@hGL@KWi2Gw "Factor – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 81 bytes
```
(s)=>{var bs = ASCIIEncoding.ASCII.GetBytes(s);return bs.All(b=>b%s.Length==0);};
```
[Try it online!](https://tio.run/##ZY47C8IwFIX3/opQEFLQ4B5TaOur0M3BuYmXGgg3kpsWRPztNbSj4zl852FoZ8jO2XlEc6AYLA5bVnvvoMeSrUZLRztZstoBU2zmVKjyM/WBaUq6ujVte0LjHwkVixIXiPU7AiVUBohjwMSKyjmuVak3JDrAIT6V2hfyK@d1hll8jTE15ldwzucyazxSeiLuwUboLAL/O8SXUFHI@Qc "C# (Visual C# Interactive Compiler) – Try It Online")
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 27 26 bytes
```
s=>s.All(c=>c%s.Length<1);
```
[Try it online!](https://tio.run/##ZczLCsIwEIXhfZ9iKAgpaMB1m4AXRKF71zoMdWCYSCf19WOwS7eH/3xoOzQuzWVRHCzPrNMWjikJPTTCOtzszB82fgpBgGIhmj@IOAwRN@ZH0im/hn3Xl7UH1veSa9peSSS1fXNKapX095kzjazk/mT3O3UV@QI "C# (Visual C# Interactive Compiler) – Try It Online")
]