Divisible strings

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 1

Befunge-98 (FBBI), 31 bytes

Output is via exit code, 1 for truthy, 0 for falsey cases.

#v~\1+
v>53p
>:#v_1q
^  >' %#@_

Try it online!

---

Code running with inputs lol and ab:

^{small numbers represent literal byte values}

Answer 2

05AB1E, 5 bytes

ÇsgÖP

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 3

Haskell, 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!

Answer 4

MATL, 4 bytes

tn\~

• For divisible strings the output is a vector containing only 1s, which is truthy.
• Otherwise the output is a vector containing several 1s and at least one 0, which is falsy.

Try it online! Or verify all test cases including truthiness/falsihood test.

How it works

t   % Implicit input. Duplicate
n   % Number of elements
\   % Modulo
~   % Negate. Implicit display

Answer 5

JavaScript, 32 bytes

Ouput is reversed.

s=>Buffer(s).some(c=>c%s.length)

Try it online!

Answer 6

Rockstar, 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 (Code will need to be pasted in)

Answer 7

Pyth, ⁸ 7 bytes

-1 byte thanks to @isaag

!%#lQCM

Try it online!

!%#lQCM
!        - logical negation of
  #      - filtering
     CM  - ascii values of input with
 % lQ    - func(x): return x % len(input) 

Answer 8

PHP, 56 52 bytes

for(;$c=ord($argn[$i++]);$c%strlen($argn)?die(f):1);

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 9

Python 2, 41 39 bytes

lambda s:all(ord(i)%len(s)<1for i in s)

Try it online!

-2 bytes thanks to @ovs

Answer 10

K (oK), 11 bytes

{~+/(#x)!x}

Try it online!

Answer 11

Rust, 36 bytes

|s|s.iter().all(|x|1>x%s.len()as u8)

Try it online!

Takes the input as a &[u8], outputs a bool.

Answer 12

Ruby, 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!

Answer 13

Perl 5 -pF, 20 bytes

$_=!grep ord()%@F,@F

Try it online!

Answer 14

Wolfram Language (Mathematica), 40 bytes

{0}==##&@@ToCharacterCode@#~Mod~Tr[1^#]&

Try it online!

thanks to @att for saving some bytes

Answer 15

C (gcc), 54 53 bytes

l;r;f(char*s){l=strlen(s);for(r=0;*s;)r|=*s++%l;l=r;}

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 16

Vyxal, 8 5 bytes

₌CLœΠ

Thanks @Lyxal for saving 3 bytes Try it Online!

Answer 17

PowerShell Core, 40 33 bytes

$l=$args.Count
!($args|?{+$_%$l})

7 bytes saved thanks to mazzy

Try it online!

Answer 18

APL (Dyalog Extended), 7 bytes (SBCS)

Anonymous tacit prefix function

⍱≢|⎕UCS

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 19

C# (.NET Core), 25 bytes

a=>a.All(x=>x%a.Length<1)

Try it online!

Answer 20

Japt -e, 6 bytes

c vNÎÊ

Try it

Answer 21

MathGolf, 4 bytes

$h÷╓

Input as a list of characters.

Try it online.

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 22

Pip, 12 bytes

!$+(A_Ma)%#a

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 23

Jelly, 4 bytes

LḍOP

Try it online! or Verify all cases!

Commmented: ^{(At least I think it works like this)}

   P  # product of ...
L     #   does the length 
 ḍ    #   ... divide ...
  O   #   the char codes

Answer 24

R, 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!

Or try the original 39-byte version that outputs TRUE for TRUE...

Answer 25

Python 3, 55 52 bytes

N=input();print(not sum([ord(i)%len(N) for i in N]))

Try it online!

Answer 26

Zsh, 31 bytes

for c (${(s::)1})((r||=#c%$#1))

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!

Answer 27

GolfScript, 20 bytes

.,0@{(3$%@+\}3$*;!\;

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 28

jq, 38 characters

length as$a|explode|map(.%$a)|all(.<1)

Sample run:

bash-5.2$ jq -R 'length as$a|explode|map(.%$a)|all(.<1)' <<< 'Hello'
false

bash-5.2$ jq -R 'length as$a|explode|map(.%$a)|all(.<1)' <<< 'lol'
true

Try it online! / Try all test cases online!

Answer 29

Charcoal, 8 bytes

¬⊙θ﹪℅ιＬθ

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 30

Factor, 62 bytes

: f ( s -- ? ) dup length [ mod ] curry [ + ] map-reduce 0 = ;

Try it online!