diff --git a/2023/src/day01.clj b/2023/src/day01.clj
index a5a4be2..493f712 100644
--- a/2023/src/day01.clj
+++ b/2023/src/day01.clj
@@ -5,42 +5,40 @@
 
 (def input (get-puzzle-input 1))
 
-(def numeric-value-map {"one" 1
-                        "two" 2
-                        "three" 3
-                        "four" 4
-                        "five" 5
-                        "six" 6
-                        "seven" 7
-                        "eight" 8
-                        "nine" 9})
+;; part 1
+(->> input
+     (map #(Integer/parseInt
+            (str (re-find #"\d" %)
+                 (re-find #"\d" (string/reverse %)))))
+     (reduce +))
 
+(def numeric-value-map {"one"   1,
+                        "two"   2,
+                        "three" 3,
+                        "four"  4,
+                        "five"  5,
+                        "six"   6,
+                        "seven" 7,
+                        "eight" 8,
+                        "nine"  9})
 (defn numeric-value [s]
   (or (numeric-value-map s) s))
 
-;; part 1
-(->> input
-     (map (fn [line]
-            {:first (re-find #"\d" line)
-             :last (re-find #"\d" (string/reverse line))}))
-     (map #(str (:first %) (:last %)))
-     (map #(Integer/parseInt %))
-     (reduce +))
+(defn generate-regex-pattern [mapping-fn]
+  (->> (keys numeric-value-map)
+       (map mapping-fn)
+       (#(conj % "\\d"))
+       (string/join "|")
+       re-pattern))
+(def forwards-search-pattern (generate-regex-pattern identity))
+(def backwards-search-pattern (generate-regex-pattern string/reverse))
 
 ;; part 2
-(def forawrd-search-regex (->> (conj (keys numeric-value-map) "\\d")
-                               (string/join "|")
-                               re-pattern))
-
-(def backwards-search-regex (->> (conj (->> numeric-value-map keys (map string/reverse)) "\\d")
-                                 (string/join "|")
-                                 re-pattern))
-
 (->> input
-     (map (fn [line]
-            (let [f (re-find forawrd-search-regex line)
-                  l (string/reverse (re-find backwards-search-regex (string/reverse line)))]
-              (str (numeric-value f) (numeric-value l)))))
-     (map #(Integer/parseInt %))
+     (map #(Integer/parseInt
+            (str (numeric-value (re-find forwards-search-pattern %))
+                 (numeric-value (string/reverse
+                                 (re-find backwards-search-pattern
+                                          (string/reverse %)))))))
      (reduce +))