Ttykuu

I see my dog run

How is it possible for user's password to be changed after storage was encrypted? (on OS X, Android)

Should I join office cleaning event for free?

What is the offset in a seaplane's hull?

What defenses are there against being summoned by the Gate spell?

Download, install and reboot computer at night if needed

Work Breakdown with Tikz

A newer friend of my brother's gave him a load of baseball cards that are supposedly extremely valuable. Is this a scam?

What do you call something that goes against the spirit of the law, but is legal when interpreting the law to the letter?

Is there really no realistic way for a skeleton monster to move around without magic?

Why are 150k or 200k jobs considered good when there are 300k+ births a month?

GPS Rollover on Android Smartphones

How can I fix this gap between bookcases I made?

Why CLRS example on residual networks does not follows its formula?

What makes Graph invariants so useful/important?

Why is the design of haulage companies so “special”?

Email Account under attack (really) - anything I can do?

What are these boxed doors outside store fronts in New York?

Shell script can be run only with sh command

Banach space and Hilbert space topology

How much RAM could one put in a typical 80386 setup?

How is it possible to have an ability score that is less than 3?

How to make payment on the internet without leaving a money trail?

How did the USSR manage to innovate in an environment characterized by government censorship and high bureaucracy?

check for pangrams in elisp

Minor mode for blog writing in HTMLA small emacs-lisp snippet for opening a register in another windowIs using defvar for a non-global variable ok?Emacs module that generates templates for my blog's static site generatorAccessor functions in elispX-up utility for EVE OnlineTesting whether lambda expression returns true for any list elementRubik's cube mode for emacsStoring facts for logical questionsGet the suffix for the date string

.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty margin-bottom:0;

0

$begingroup$

I'm trying to find pangrams ie sentences that contain all the letters of the alphabet, for instance "The quick brown fox jumps over the lazy dog".

I'm an absolute beginner in elisp, and it ended up being a really difficult exercice for me. My idea what to put all the letters in a set check if all the letters of the alphabet are in this set.

I don't think it was a very good idea because elisp doesn't seem to really have sets, so I ended up using a hashmap, which seems very clunky.

Another things that really bothers me is the two if in is-pangram. I feel that they make the function really difficult to reason about, although it's doing something very basic.

(defun add-to-hashmap (hashmap item)
 "Insert ITEM into HASHMAP and return HASHMAP."
 (puthash item t hashmap)
 hashmap)

(defun iter-hashmap-keys (hashmap)
 "Return a sequence of the keys in HASHMAP"
 (let ((keys '()))
 (maphash
 (lambda (key _) (setq keys (cons key keys)))
 hashmap)
 keys))

(defun get-letters (s)
 "Return the set of letters in S.
The set is a hashmap where keys are ascii characters and values are `t`."
 (setq letters (make-hash-table :test 'equal))
 (seq-reduce
 (lambda (hashmap letter) (add-to-hashmap hashmap (downcase letter)))
 (split-string s "")
 letters))

(defvar ALPHABET
 (let* ((letters (get-letters "abcdefghijklmnopqrstuvwxyz"))
 (_ (remhash "" letters)))
 letters))

(defun is-pangram (s)
 "Return `t` is S is a pangram, `nil` otherwise."
 (setq letters (get-letters s))
 (if (seq-some
 ;; this function returns returns `nil` if the given letter is
 ;; *present* in the set, and `t` otherwise. That way, seq-some
 ;; returns a non-nil value when there's a letter that is *not* in
 ;; the set.
 (lambda (letter) (if (gethash letter letters) nil t))
 (iter-hashmap-keys ALPHABET))
 nil
 t))

(provide 'pangram)
```

lisp elisp

share

asked 7 mins ago

little-dudelittle-dude

22516

$endgroup$

add a comment | 

0

$begingroup$

I'm trying to find pangrams ie sentences that contain all the letters of the alphabet, for instance "The quick brown fox jumps over the lazy dog".

I'm an absolute beginner in elisp, and it ended up being a really difficult exercice for me. My idea what to put all the letters in a set check if all the letters of the alphabet are in this set.

I don't think it was a very good idea because elisp doesn't seem to really have sets, so I ended up using a hashmap, which seems very clunky.

Another things that really bothers me is the two if in is-pangram. I feel that they make the function really difficult to reason about, although it's doing something very basic.

(defun add-to-hashmap (hashmap item)
 "Insert ITEM into HASHMAP and return HASHMAP."
 (puthash item t hashmap)
 hashmap)

(defun iter-hashmap-keys (hashmap)
 "Return a sequence of the keys in HASHMAP"
 (let ((keys '()))
 (maphash
 (lambda (key _) (setq keys (cons key keys)))
 hashmap)
 keys))

(defun get-letters (s)
 "Return the set of letters in S.
The set is a hashmap where keys are ascii characters and values are `t`."
 (setq letters (make-hash-table :test 'equal))
 (seq-reduce
 (lambda (hashmap letter) (add-to-hashmap hashmap (downcase letter)))
 (split-string s "")
 letters))

(defvar ALPHABET
 (let* ((letters (get-letters "abcdefghijklmnopqrstuvwxyz"))
 (_ (remhash "" letters)))
 letters))

(defun is-pangram (s)
 "Return `t` is S is a pangram, `nil` otherwise."
 (setq letters (get-letters s))
 (if (seq-some
 ;; this function returns returns `nil` if the given letter is
 ;; *present* in the set, and `t` otherwise. That way, seq-some
 ;; returns a non-nil value when there's a letter that is *not* in
 ;; the set.
 (lambda (letter) (if (gethash letter letters) nil t))
 (iter-hashmap-keys ALPHABET))
 nil
 t))

(provide 'pangram)
```

lisp elisp

share

asked 7 mins ago

little-dudelittle-dude

22516

$endgroup$

add a comment | 

$begingroup$

I'm trying to find pangrams ie sentences that contain all the letters of the alphabet, for instance "The quick brown fox jumps over the lazy dog".

I'm an absolute beginner in elisp, and it ended up being a really difficult exercice for me. My idea what to put all the letters in a set check if all the letters of the alphabet are in this set.

I don't think it was a very good idea because elisp doesn't seem to really have sets, so I ended up using a hashmap, which seems very clunky.

Another things that really bothers me is the two if in is-pangram. I feel that they make the function really difficult to reason about, although it's doing something very basic.

(defun add-to-hashmap (hashmap item)
 "Insert ITEM into HASHMAP and return HASHMAP."
 (puthash item t hashmap)
 hashmap)

(defun iter-hashmap-keys (hashmap)
 "Return a sequence of the keys in HASHMAP"
 (let ((keys '()))
 (maphash
 (lambda (key _) (setq keys (cons key keys)))
 hashmap)
 keys))

(defun get-letters (s)
 "Return the set of letters in S.
The set is a hashmap where keys are ascii characters and values are `t`."
 (setq letters (make-hash-table :test 'equal))
 (seq-reduce
 (lambda (hashmap letter) (add-to-hashmap hashmap (downcase letter)))
 (split-string s "")
 letters))

(defvar ALPHABET
 (let* ((letters (get-letters "abcdefghijklmnopqrstuvwxyz"))
 (_ (remhash "" letters)))
 letters))

(defun is-pangram (s)
 "Return `t` is S is a pangram, `nil` otherwise."
 (setq letters (get-letters s))
 (if (seq-some
 ;; this function returns returns `nil` if the given letter is
 ;; *present* in the set, and `t` otherwise. That way, seq-some
 ;; returns a non-nil value when there's a letter that is *not* in
 ;; the set.
 (lambda (letter) (if (gethash letter letters) nil t))
 (iter-hashmap-keys ALPHABET))
 nil
 t))

(provide 'pangram)
```

lisp elisp

share

asked 7 mins ago

little-dudelittle-dude

22516

$endgroup$

(defun add-to-hashmap (hashmap item)
 "Insert ITEM into HASHMAP and return HASHMAP."
 (puthash item t hashmap)
 hashmap)

(defun iter-hashmap-keys (hashmap)
 "Return a sequence of the keys in HASHMAP"
 (let ((keys '()))
 (maphash
 (lambda (key _) (setq keys (cons key keys)))
 hashmap)
 keys))

(defun get-letters (s)
 "Return the set of letters in S.
The set is a hashmap where keys are ascii characters and values are `t`."
 (setq letters (make-hash-table :test 'equal))
 (seq-reduce
 (lambda (hashmap letter) (add-to-hashmap hashmap (downcase letter)))
 (split-string s "")
 letters))

(defvar ALPHABET
 (let* ((letters (get-letters "abcdefghijklmnopqrstuvwxyz"))
 (_ (remhash "" letters)))
 letters))

(defun is-pangram (s)
 "Return `t` is S is a pangram, `nil` otherwise."
 (setq letters (get-letters s))
 (if (seq-some
 ;; this function returns returns `nil` if the given letter is
 ;; *present* in the set, and `t` otherwise. That way, seq-some
 ;; returns a non-nil value when there's a letter that is *not* in
 ;; the set.
 (lambda (letter) (if (gethash letter letters) nil t))
 (iter-hashmap-keys ALPHABET))
 nil
 t))

(provide 'pangram)
```

share

asked 7 mins ago

little-dudelittle-dude

22516

share

asked 7 mins ago

little-dudelittle-dude

22516

asked 7 mins ago

little-dudelittle-dude

22516

asked 7 mins ago

little-dudelittle-dude

22516