Is there a smaller tautogram checker?

Question

I got into code-golfing recently and tried to write the smallest tautogram checker.

A tautogram is a sentence in which all words start with the same letter, for example: Flowers flourish from France.

Given a sentence as input, determine whether it is a tautogram.

Test Cases

Flowers flourish from France
    True

This is not a Tautogram
    False

I came up with this python code (because it is my main language):

print(True if len(list(set([x.upper()[0] for x in __import__('sys').argv[1:]]))) == 1 else False)

Usage:

python3 tautogram.py Flowers flourish from France
# True
python3 tautogram.py This is not a Tautogram
# False

The sentence may contain commas and periods, but no other special characters, only upper and lower case letters and spaces.

Its size is 98 bytes. Is there a smaller solution in any language?

Answer 1

05AB1E, 5 bytes

l#€нË

Try it online!

---

l      # Lowercase input.
 #     # Split on spaces.
  €н   # a[0] of each.
    Ë  # All equal?

Did this on mobile excuse the no explanation.

Answer 2

Python 2, 47 bytes

lambda s:len(set(zip(*s.lower().split())[0]))<2

Try it online!

Came up with this on mobile. Can probably be golfed more.

Answer 3

PowerShell, 57 50 41 bytes

(-split$args|% s*g 0 1|sort -u).count-eq1

Try it online!

Takes input and splits it on whitespace. Loops through each word, and grabs the first letter by taking the substring starting at position 0 and going for 1 character. Then sorts the letters (case-insensitive by default) with the -unique flag to pull out only one copy of each letter, and verifies the count of those names are -equal to 1. Output is implicit.

-9 bytes thanks to mazzy.

Answer 4

Clojure, 80 bytes

Try it online!. TIO doesn't support Clojure's standard String library though, so the first version will throw a "Can't find lower-case" error.

(fn[s](use '[clojure.string])(apply =(map first(map lower-case(split s #" ")))))

Ungolfed:

(defn tautogram? [s]
  (use '[clojure.string])
  (->> (split s #" ") ; Get words
       (map lower-case)
       (map first) ; Get first letter of each word
       (apply =))) ; And make sure they're all the same

I made a version that avoids the import:

(fn [s](apply =(map #(if(<(-(int %)32)65)(int %)(-(int %) 32))(map first(take-nth 2(partition-by #(= %\ )s))))))

 ; -----

(defn tautogram? [s]
  (->> s
       (partition-by #(= % \ )) ; Split into words
       (take-nth 2) ; Remove spaces
       (map first) ; Get first letter
       ; Convert to uppercased letter code
       (map #(if (< (- (int %) 32) 65) ; If attempting to uppercase puts the letter out of range,
               (int %) ; Go with the current code
               (- (int %) 32))) ; Else go with the uppercased  code
       (apply =))) ; And check if they're all equal

But it's 112 Bytes.

Answer 5

Haskell, 71 bytes

f s|c<-fromEnum.head<$>words s=all(`elem`[-32,0,32]).zipWith(-)c$tail c

Try it online!

---

Haskell, 61 58 bytes (using Data.Char.toLower)

• Saved three bytes thanks to nimi.

import Data.Char
(all=<<(==).head).(toLower.head<$>).words

Try it online!

Answer 6

05AB1E (legacy), 5 bytes

#€¬uË

Try it online!

#     // split on spaces
 €¬   // get the first letter of each word
   uË // check if they're the same (uppercase) letter

Answer 7

Perl 5 (-p), 20 bytes

$_=!/^(.).* (?!\1)/i

TIO

following comments in case bad punctuation (31 bytes)

$_=!/^\W*+(.).*(?=\b\w)(?!\1)/i

31 bytes

otherwise there's another approach, also with 31 bytes:

$h{ord()%32}++for/\w+/g;$_=2>%h

31 bytes other

Answer 8

Brachylog, 5 bytes

ḷṇ₁hᵛ

Try it online!

         The input
ḷ        lowercased
 ṇ₁      and split on spaces
   hᵛ    is a list of elements which all start with the same thing.

Answer 9

JavaScript (Node.js), 54 bytes

s=>!s.match(/\b\w+/g).some(p=s=>p-(p=Buffer(s)[0]&31))

Try it online!

Or 47 bytes if each word (but the first) is guaranteed to be preceded by a space.

Answer 10

Japt -¡, 5 bytes

¸mÎro

Try it

¸mÎro     :Implicit input of string
¸         :Split on spaces
 m        :Map
  Î       :  Get first character
   r      :Reduce by
    o     :  Keeping the characters that appear in both, case-insensitive
          :Implicit output as boolean

Answer 11

C# (Visual C# Interactive Compiler), 41 bytes

n=>n.Split().GroupBy(c=>c[0]|32).Single()

Throws an exception if false, nothing if true.

Try it online!

Answer 12

Perl 6, 19 bytes

{[eq] m:g/<<./}o&lc

Try it online!

Answer 13

Java, (36 bytes)

s->!s.matches("(?i)(.).* (?!\\1).*")

TIO