1
votes

Est-il possible de lire à partir d'un fichier d'entrée et de convertir chaque ligne du fichier texte en un vecteur de chaînes?

J'ai un fichier texte comme indiqué ci-dessous:

[ ["-" "-" "-" "#" "-" "-" "#" "#" "#" "-" "-" "-" "-"] 
  ["-" "#" "-" "-" "-" "#" "-" "-" "-" "-" "#" "#" "-"] 
  ["#" "#" "#" "#" "-" "#" "-" "#" "-" "#" "-" "#" "#"] 
  ["-" "-" "-" "#" "-" "-" "-" "#" "-" "#" "-" "-" "-"] 
  ["-" "#" "-" "#" "#" "#" "#" "-" "-" "-" "#" "#" "-"] 
  ["-" "#" "-" "-" "-" "-" "-" "-" "#" "-" "-" "-" "-"] 
  ["-" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#"] 
  ["-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "@"]]

Puis-je lire à partir du fichier d'entrée et obtenir une sortie dans ce format

[---#--###---- 
 -#---#----##- 
 ####-#-#-#-## 
 ---#---#-#--- 
 -#-####---##- 
 -#------#---- 
 -############ 
 ------------@
]

J'ai essayé de lire le fichier d'entrée ligne par ligne et de l'ajouter à un vecteur:

    (defn loadFile2 []
        (with-open [rdr (clojure.java.io/reader "map.txt")]
        (reduce conj [] (line-seq rdr)))
    )

    (defn convert_input_to_string []
        "Converts"
        ;(def temp )
        (loop [i 0 temp (loadFile2)]
            (if (< i (count temp))

            (recur (inc i) (assoc temp i (str (join (seq (get temp 
             i))))) )
            temp
            ))
    )

(convert_input_to_string).

Cette approche me donne un vecteur de chaînes:

[ ["-" "-" "-" "#" "-" "-" "#" "#" "#" "-" "-" "-" "-"] 
  ["-" "#" "-" "-" "-" "#" "-" "-" "-" "-" "#" "#" "-"] 
  ["#" "#" "#" "#" "-" "#" "-" "#" "-" "#" "-" "#" "#"] 
  ["-" "-" "-" "#" "-" "-" "-" "#" "-" "#" "-" "-" "-"] 
  ["-" "#" "-" "#" "#" "#" "#" "-" "-" "-" "#" "#" "-"] 
  ["-" "#" "-" "-" "-" "-" "-" "-" "#" "-" "-" "-" "-"] 
  ["-" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#"] 
  ["-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "@"]
]

clojure

0 commentaires

3 Réponses :

2
votes

Allez-y étape par étape.

Lisez les données (comme le fichier est petit, il suffit de slurp). Nommons le fichier grid.txt

(->> (slurp "grid.txt") 
     (clojure.string/split-lines) 
     (map #(map str %)) 
     (map vec) 
     (into []))
[["-" "-" "-" "#" "-" "-" "#" "#" "#" "-" "-" "-" "-"] ["-" "#" "-" "-" "-" "#" "-" "-" "-" "-" "#" "#" "-"] ["#" "#" "#" "#" "-" "#" "-" "#" "-" "#" "-" "#" "#"] ["-" "-" "-" "#" "-" "-" "-" "#" "-" "#" "-" "-" "-"] ["-" "#" "-" "#" "#" "#" "#" "-" "-" "-" "#" "#" "-"] ["-" "#" "-" "-" "-" "-" "-" "-" "#" "-" "-" "-" "-"] ["-" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#"] ["-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "@"]]

Découpez en lignes:

(->> (slurp "grid.txt") 
     (clojure.string/split-lines) 
     (map vec) 
     (into []))
[[\- \- \- \# \- \- \# \# \# \- \- \- \-] [\- \# \- \- \- \# \- \- \- \- \# \# \-] [\# \# \# \# \- \# \- \# \- \# \- \# \#] [\- \- \- \# \- \- \- \# \- \# \- \- \-] [\- \# \- \# \# \# \# \- \- \- \# \# \-] [\- \# \- \- \- \- \- \- \# \- \- \- \-] [\- \# \# \# \# \# \# \# \# \# \# \# \#] [\- \- \- \- \- \- \- \- \- \- \- \- \@]]

Convertissez chacun chaîne en vecteur de caractères:

(->> (slurp "grid.txt") 
     (clojure.string/split-lines) 
     (map vec))
([\- \- \- \# \- \- \# \# \# \- \- \- \-] [\- \# \- \- \- \# \- \- \- \- \# \# \-] [\# \# \# \# \- \# \- \# \- \# \- \# \#] [\- \- \- \# \- \- \- \# \- \# \- \- \-] [\- \# \- \# \# \# \# \- \- \- \# \# \-] [\- \# \- \- \- \- \- \- \# \- \- \- \-] [\- \# \# \# \# \# \# \# \# \# \# \# \#] [\- \- \- \- \- \- \- \- \- \- \- \- \@])

Convertir le niveau supérieur en vecteur:

(->> (slurp "grid.txt") 
     (clojure.string/split-lines))
["---#--###----" "-#---#----##-" "####-#-#-#-##" "---#---#-#---" "-#-####---##-" "-#------#----" "-############" "------------@"]

Notez que ce n'est pas la même chose que votre sortie attendue car les vecteurs internes contiennent des caractères, pas des chaînes.

Si vous vouliez vraiment des chaînes à la place, vous devez ajouter une ligne:

(slurp "grid.txt")
"---#--###----\r\n-#---#----##-\r\n####-#-#-#-##\r\n---#---#-#---\r\n-#-####---##-\r\n-#------#----\r\n-############\r\n------------@"

0 commentaires

0
votes

Si vous pouvez vous permettre de charger tout le fichier d'entrée en mémoire, voici une fonction rapide et sale qui fait exactement cela:

>  (clojure.pprint/pprint (read-vec-of-strings "input.txt"))

[["-" "-" "-" "#" "-" "-" "#" "#" "#" "-" "-" "-" "-"]
 ["-" "#" "-" "-" "-" "#" "-" "-" "-" "-" "#" "#" "-"]
 ["#" "#" "#" "#" "-" "#" "-" "#" "-" "#" "-" "#" "#"]
 ["-" "-" "-" "#" "-" "-" "-" "#" "-" "#" "-" "-" "-"]
 ["-" "#" "-" "#" "#" "#" "#" "-" "-" "-" "#" "#" "-"]
 ["-" "#" "-" "-" "-" "-" "-" "-" "#" "-" "-" "-" "-"]
 ["-" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#" "#"]
 ["-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "-" "@"]]
nil

L'étape (1) charge le fichier entier sous forme d'une seule chaîne en mémoire;
L'étape (2) divise le fichier par sauts de ligne;
L'étape (3) est l'endroit où la magie opère: pour chaque ligne du fichier ( mapv ... lines ), appelez une autre fonction (anonyme) # (mapv str%) qui parcourt chaque caractère de la ligne et les transforme en chaîne (ainsi le caractère \ # devient la chaîne "#" ), et accumule le résultat dans un vecteur.

J'ai enregistré votre fichier d'entrée sous le nom input.txt et j'ai appelé la fonction comme ceci:

(defn read-vec-of-strings [filename]
  (let [contents (slurp filename)                      ;; see (1) below
        lines    (clojure.string/split contents #"\n") ;; see (2) below
        vectors  (mapv #(mapv str %) lines)]           ;; see (3) below
    vectors))

0 commentaires

0
votes

le plus simple serait quelque chose comme ceci:

(with-open [rdr (clojure.java.io/reader "data.txt")]
  (mapv #(clojure.string/split % #"") (line-seq rdr)))

ou au cas où vous auriez besoin de chaînes au lieu de caractères:

(with-open [rdr (clojure.java.io/reader "data.txt")]
  (mapv vec (line-seq rdr)))

les deux renvoient le vecteur de vecteurs d'éléments

0 commentaires