Valid Parentheses

gistfile1.txt

(ns app                                                                                                                                                                       
  (:require [clojure.string :refer [replace]]))                                                                                                                               
                                                                                                                                                                              
(def s1 "[[][{]]")                                                                                                                                                            
(def s2 "[[]][][{]}[]")                                                                                                                                                       
(def s3 "[[{}][]]")                                                                                                                                                           
(def s4 "([)]")                                                                                                                                                               
                                                                                                                                                                              
(def pattern #"\[\]|\{\}|\(\)")                                                                                                                                               
                                                                                                                                                                              
(defn is-valid?                                                                                                                                                               
  [s]                                                                                                                                                                         
  (let [has-patterns (->> s (re-find pattern))]                                                                                                                               
    (if has-patterns                                                                                                                                                          
      (-> s (replace pattern "") process)                                                                                                                                     
      (if (empty? s)                                                                                                                                                          
        [:valid]                                                                                                                                                              
        [:in-valid s]))))                                                                                                                                                     
                                                                                                                                                                              
(is-valid? s4)