Início / coding / Perguntas / 79263341
Accepted
user1785730
Asked: 2024-12-09 04:59:31 +0800 CST

Crie listas a partir de colunas

  • 772

Tenho dados em um arquivo de texto formatado assim:

1    2
3    4
5    6
7    8
9    0

Quero criar uma lista para cada coluna, assim:

((1 3 5 7 9) (2 4 6 8 0))

Na verdade, eu encontrei uma solução que funciona:

(defn make-lists []
  (let [lines (clojure.string/split-lines (slurp "input"))]
    (let [l1 (map #(parse-long (first (clojure.string/split % #" "))) lines)
          l2 (map #(parse-long (nth (clojure.string/split % #" ") 3)) lines)]
      (list l1 l2))))

No entanto, acho que há alguns problemas com essa solução. Não tenho certeza de como mapfunciona por baixo dos panos, mas temo que isso resulte em duas iterações sobre a entrada quando, teoricamente, uma deveria ser suficiente.

Infelizmente, há mais de um espaço que separa os dois valores em cada linha nos dados de entrada. E clojure.string/splitproduz um resultado para cada um deles. Portanto, tenho essa procura arbitrária nth 3por l2 no meu código da qual gostaria de me livrar.

Eu apreciaria qualquer ideia de como melhorar esse código.

clojure

2 respostas

  1. Best Answer

    Em geral, você não deve se importar tanto com iterar mais de uma vez sobre algo. É comum, está tudo bem, considere otimizar apenas se você já provou que é um gargalo.

    Sobre espaços - esse argumento str/splité uma expressão regular. Basta usar #" +"em vez de #" ".

    Com isso em mente, é assim que eu faria:

    (->> (clojure.string/split-lines "1    2\n3    4\n5    6\n7    8\n9    0")
     (map #(map parse-long (clojure.string/split % #" +")))
     (apply map list))
    • 4

  2. Só para esclarecer um pouco sobre a primeira resposta, eu gosto de espalhar os passos para começar. Na biblioteca tupelo, há macros let-spye let-spy-prettyque imprimem o resultado de cada passo:

    (ns tst.demo.core
  (:use demo.core tupelo.core tupelo.test)
  (:require
    [tupelo.string :as str]
    ))

(verify    ; like `deftest` but doesn't need a test name symbol
  (let-spy-pretty
    [text        " 1    2
                   3    4
                   5    6
                   7    8
                   9    0 "
     lines-orig  (str/split-lines text)
     lines-clean (mapv str/trim lines-orig)
     data-str    (mapv #(str/split % #" +") lines-clean)
     data-int    (for [pair data-str]
                   (mapv #(parse-long %) pair))
     data-cols   (apply mapv vector data-int)

     ]
    (is= data-cols
      [[1 3 5 7 9]
       [2 4 6 8 0]]
      )))

    com resultado:

    
-------------------------------
   Clojure 1.12.0    Java 21
-------------------------------

Testing tst.demo.core
text =>
" 1    2\n                   3    4\n                   5    6\n                   7    8\n                   9    0 "
lines-orig =>
[" 1    2"
 "                   3    4"
 "                   5    6"
 "                   7    8"
 "                   9    0 "]
lines-clean =>
["1    2" "3    4" "5    6" "7    8" "9    0"]
data-str =>
[["1" "2"] ["3" "4"] ["5" "6"] ["7" "8"] ["9" "0"]]
data-int =>
[[1 2] [3 4] [5 6] [7 8] [9 0]]
data-cols =>
[[1 3 5 7 9] [2 4 6 8 0]]

Ran 2 tests containing 1 assertions.
0 failures, 0 errors.

    Gosto de usar (str/trim ...)no início do processo para me livrar de todos os espaços iniciais/finais (e novas linhas!) antes de analisar/segmentar a linha, analisar para int/float, etc. Também gosto de usar mapvem vez de mapis, pois não é preguiçoso e sempre produz um resultado vetorial (mais fácil de cortar/colar em testes de unidade sem aspas).

    Depois que tudo estiver funcionando, basta substituir let-spy-prettypor lete formatar normalmente. Eu geralmente não me incomodo em condensar os passos individuais com ->ou algo assim, então fica mais óbvio para leitores subsequentes do código como a transformação acontece passo a passo (especialmente se eles precisarem modificar algo ou adicionar instruções de impressão de depuração).

    • 0

relate perguntas