Clojure Присвоение ввода с клавиатуры переменной в Clojure

(doseq [x '(1 2 3)] (println x))

(defn spisok []
  (def order `(0)) (def q 0)
  (println " Vvedite N = ")
    (let [n (read-string (read-line))]
      (while (<= q n) 
        (def j 0) (def t (Math/round (rand n)))
          (doseq [i order] (if (not (= t i)) (inc j)))
    (if (= j (count order)) (def order (concat order (list t))))
      (def q (count order)))
        (def order (rest order))
          (print " S = ") (doseq [i order] (print " " i))))

(defn spisok []  
     (def q 0) (def order `(0))
    (println " Vvedite N = ")
    (let [n (read-string (read-line))]       
      (while (<= q n)
       (def j 0) (def t (Math/round (rand n)))
         (doseq [i order] (if (not (= t i)) (def j (+ 1 j))))
      (if (= j (count order)) (def order (concat order (list t))))
        (def q (count order)))
          (def order (rest order))
    (print " S = (") (doseq [k order] (print " " k)) (print " )\n")))

(def order (rest order)) (println " S = " order)))

(defn spisok [] 
  (while (< 1 2) 
  (def order `(0))
  (println " Vvedite N = ")
    (let [n (read-string (read-line))]       
      (while (<= (count order) n)
       (def j `()) (def t (Math/round (rand n)))
         (doseq [i order] (if (not (= t i)) (def j (conj j 1))))
      (if (= (count j) (count order)) (def order (concat order (list t)))))
          (println " S = " (rest order)))))

(defn arab_rim []
(def arab [1000 900 500 400 100 90 50 40 10 9 5 4 1 ])
(def rim  ["M" "CM" "D" "CD" "C" "XC" "L" "XL" "X" "IX" "V" "IV" "I"])
(while (< 1 2) 
(def e -1) (def Rim "")
    (println " Vvedite Arab = ")
  (let [Arab (read-string (read-line))]
       (def Arab1 Arab)  
      (while (< 0 Arab1)
        (def e (inc e))     
        (while (<= (nth arab e) Arab1)              
          (def Rim  (str Rim (nth rim e)))                 
          (def Arab1 (- Arab1 (nth arab e)))))
          (println " Rim  = " Rim))))

(defn rim_arab []
  (def rimarab {:I 1 :V 5 :X 10 :L 50 :C 100 :D 500 :M 1000})
  (while (< 1 2) 
  (println " Введите Rim = ")
    (let [rim (read-line)]
      (def f1 (replace rim "IV" "IIII")) (def f2 (replace f1 "IX" "VIIII"))
      (def f3 (replace f2 "XL" "XXXX"))  (def f4 (replace f3 "XC" "LXXXX"))
      (def f5 (replace f4 "CD" "CCCC"))  (def f6 (replace f5 "CM" "DCCCC"))
        (def Arab 0) (doseq [i f6] (def Arab (+ Arab (get rimarab i))))
          (println " Arab = " Arab))))

(def rimarab {"I" 1 "V" 5 "X" 10 "L" 50 "C" 100 "D" 500 "M" 1000})

(doseq [i (map str rim)] (def Arab (+ Arab (get rimarab i))))

(defn rim_arab []
  (def rimarab {"I" 1 "V" 5 "X" 10 "L" 50 "C" 100 "D" 500 "M" 1000})
  (while (< 1 2) 
  (println " Введите Rim = ")
    (let [rim (read-line)]
      (def f (.replace rim "IV" "IIII")) (def f (.replace f "IX" "VIIII"))
      (def f (.replace f "XL" "XXXX"))   (def f (.replace f "XC" "LXXXX"))
      (def f (.replace f "CD" "CCCC"))   (def f (.replace f "CM" "DCCCC"))
        (def Arab 0) (doseq [i (map str f)] (def Arab (+ Arab (get rimarab i))))
          (println " Arab = " Arab))))

(defn rim_arab []
(def w {"IV" "IIII" "IX" "VIIII" "XL" "XXXX" "XC" "LXXXX" "CD" "CCCC" "CM" "DCCCC"})
(def q (keys w)) (def r_a {"I" 1 "V" 5 "X" 10 "L" 50 "C" 100 "D" 500 "M" 1000}) 
 (while (< 1 2) (println " Введите Rim = ")
  (let [rim (read-line)] (def f rim)
   (doseq [j q] (def f (.replace f j (get w j))))
    (def Arab 0) (doseq [i (map str f)] (def Arab (+ Arab (get r_a i))))
     (println " Arab = " Arab))))

(defn rim_arab []
(def r_a {"I" 1 "V" 5 "X" 10 "L" 50 "C" 100 "D" 500 "M" 1000})
(def q ["IV" "IX" "XL" "XC" "CD" "CM"])
(def w ["IIII" "VIIII" "XXXX" "LXXXX" "CCCC" "DCCCC"]) 
(def e [0 1 2 3 4 5])
 (while (< 1 2) (println " Введите Rim = ")
  (let [rim (read-line)] (def f rim)
   (doseq [j e] (def f (.replace f (nth q j) (nth w j))))
    (def Arab 0) (doseq [i (map str f)] (def Arab (+ Arab (get r_a i))))
     (println " Arab = " Arab))))

(doseq [j (range 6)] (def f (.replace f (nth q j) (nth w j))))

;arab_rim_2.clj
(defn arab_rim_2 []
 (def arab [1000 900 500 400 100 90 50 40 10 9 5 4 1 ])
 (def rim  ["M" "CM" "D" "CD" "C" "XC" "L" "XL" "X" "IX" "V" "IV" "I"])
 (def kol_vo [3 1 1 1 3 1 1 1 3 1 1 1 3])
  (while (< 1 2) (def K -1) (def Rim "")
   (println " Vvedite Arab = ")
    (let [Arab (read-string (read-line))] (def Arab_1 Arab)  
     (doseq [i kol_vo] (def K (inc K))
      (repeat i (if (<= 0 (- Arab_1 (nth arab K)))
                  (def Rim  (str Rim (nth rim K)))                               
                  (def Arab_1 (- Arab_1 (nth arab K)))
                  )))      
       (print " Arab  = " Arab) (print " ==> ") (println " Rim  = " Rim))))

;arab_rim_2.clj
(defn Q   [] (- Arab_1 (nth arab K))) (defn IF  [] (<= 0 (Q)))
(defn A_R [] (def Rim (str Rim (nth rim K))) (def Arab_1 (Q)))
(defn INC [] (def K (inc K)))
(defn arab_rim_2 []
 (def arab    [1000 900 500 400 100 90 50 40 10 9 5 4 1 ])
 (def rim     ["M" "CM" "D" "CD" "C" "XC" "L" "XL" "X" "IX" "V" "IV" "I"])
 (def kol_vo  [3 1 1 1 3 1 1 1 3 1 1 1 3])
  (while (< 1 2) (def K 0) (def Rim "") (println " Vvedite Arab = ")
   (let [Arab (read-string (read-line))] (def Arab_1 Arab)  
    (doseq [i kol_vo] (loop [x i] (if (IF) (recur (A_R)))) (INC))         
     (print " Arab  = " Arab) (print " ==> ") (println " Rim  = " Rim))))

(sort (cons 4 '(1 2 3)))
=>user (1 2 3 4)

(seq (conj [1 2 3] 4))
=>user (1 2 3 4)

(ns vector_1)
;------------------------------------------------------------------------------
(defn del [v n] (into (subvec v 0 n) (subvec v (inc n))))
(defn vector_1 []
   (while (= 1 1)
       (println " Введите N = ")
        (let [n (read-string (read-line))] (def q n)         
          (def m (vec (rest (range (+ n 1))))) (def w [])
            (doseq [j  m]
                (def t (Math/round (rand q)))
                  (if (= t q) (def t (dec t)) t)               
                   (def w (conj  w (m t)))                                  
                     (def m (del m t))                     
                       (def q (dec q))                          
         )
         (println "    Vector =" w)   
      )
   )
)

(ns vector_1)
;------------------------------------------------------------------------------
(defn del [v n] (into (subvec v 0 n) (subvec v (inc n))))
(defn upr [t] (def w (conj  w (m t))) (def m (del m t)))
(defn vector_1 []
   (while (= 1 1)
       (println " Введите N = ")
        (let [n (read-string (read-line))]
          (def m (vec (reverse (rest (range (+ n 1)))))) (def w [])
            (doseq [j  m]
                (def t (Math/round (rand j)))
                  (if (= t j) (upr (dec t)) (upr t))                                                                             
         )
         (println "N =" n " is " "Vector =" w)   
      )
   )
)

(ns vector_1)
;------------------------------------------------------------------------------
(defn del [v n] (into (subvec v 0 n) (subvec v (inc n))))
(defn upr [t m w] (def w (conj  w (m t))) (def m (del m t)))
(defn vector_1 []
   (while (= 1 1)
       (println " Введите N = ")
        (let [n (read-string (read-line))]
          (def m (vec (reverse (rest (range (+ n 1)))))) (def w [])
            (doseq [j  m]
                (def t (Math/round (rand j)))
                  (if (= t j) (upr (dec t) m w) (upr t m w))                                                                             
         )
         (println "N =" n " is Vector =" w)   
      )
   )
)