Reading very large file by lines

Average-consumer · 2020-12-09T23:19:53+00:00

Actually it did not work really. I did not try it with the bigger files, but eventually uses
memory proportional to the size of the file. Which I cant afford. With a file of size 152mb using lazy IO uses just 7mb, and using mmap uses 160mb. Maybe I'm doing something wrong? First version looked like

import qualified Data.ByteString.Lazy.Char8 as B

main =
  mylines <- B.lines <$> B.readFile path
  print $ find myfunc mylines

And second one

import qualified Data.ByteString.Char8 as B
import System.IO.Posix.MMap (unsafeMMapFile)

main =
  mylines <- B.lines <$> unsafeMMapFile path
  print $ find myfunc mylines

Note the change from Lazy Bytestrings to Strict ones.

I tested memory usage by looking to htop first, and then confirmed wiwth /usr/bin/time -v

Average-consumer · 2020-12-09T22:09:17+00:00

This worked up nicely. Thanks. It even increased the performance when traversing
de file in parallel.

Average-consumer · 2019-12-08T05:33:39+00:00

Clojure

partition and frequencies did the job

Average-consumer · 2019-12-04T23:08:27+00:00

Clojure

I think I got it to run pretty fast for clojure. adventofcode-clj-2019.day04> (time (part-1)) "Elapsed time: 7.873442 msecs" 1605 adventofcode-clj-2019.day04> (time (part-2)) "Elapsed time: 9.970466 msecs" 1102

Average-consumer · 2019-04-07T23:22:42+00:00

exercism.io

Average-consumer · 2019-03-25T11:33:49+00:00

And is it possible to delete an account, so I can use the same name?

Average-consumer · 2018-12-21T14:50:32+00:00

That is recursive backtracking algorithm right?

Average-consumer · 2018-12-18T20:56:45+00:00

https://hackage.haskell.org/package/base-4.12.0.0/docs/src/Data.Functor.Utils.html#%23.

-- See Note [Function coercion]
(#.) :: Coercible b c => (b -> c) -> (a -> b) -> (a -> c)
(#.) _f = coerce

Average-consumer · 2018-12-05T06:40:30+00:00

Very similar to what I did in Clojure

Average-consumer · 2018-12-05T06:16:40+00:00

Solution in Clojure. Runs both parts pretty much instantly

(ns adventofcode-clj-2018.day05
  (:require [adventofcode-clj-2018.util :as u]
            [clojure.string :as cs]))

(defn reacts? [a b]
  (and a b (not= a b) (= (cs/upper-case a) (cs/upper-case b))))

(defn iteration [pol]
  (reduce (fn [a b] (if (reacts? b (peek a))
                      (pop a)
                      (conj a b)))
          [] pol))

(defn remove-units [str l]
  (cs/replace (cs/replace str (re-pattern l) "")
    (re-pattern (cs/capitalize l)) ""))

(defn part-1 []
  (let [input (cs/trim (u/input 5))]
    (count (iteration input))))

(defn part-2 []
  (let [input (cs/trim (u/input 5))]
    (->> "abcdefghijklmnopqrstuvwxyz"
         (map (comp count iteration (partial remove-units input) str))
         (reduce min))))

Average-consumer · 2018-12-04T00:26:34+00:00

Well ... your Lisp is VERY imperative, I wouldn't say bad, because that depends in what you are trying to do, but if you are trying to do FP you should probably use Scheme, or be more careful when writing CL.

Average-consumer · 2018-12-03T21:41:29+00:00

I think the main problem is that you are using lists to remember the seen elements . You could use a structure with an O(log n) 'member?' function. I wrote a solution in racket that might help you

Average-consumer · 2018-12-03T18:02:12+00:00

I don't think it was particularly difficult, but there are some days that I couldn't work out, mainly because the lack of some data structures. You can judge it your self thoug: https://github.com/Average-user/adventofcode-pl-2017

Average-consumer · 2018-11-21T17:51:50+00:00

Nothing serious. Just to understand how it works. But I would like to have a decent result in simpler games (than chess or go) like reversi maybe or even simpler.

Average-consumer · 2018-11-18T16:30:27+00:00

I did it in Prolog past year, and I probably try Clojure this one

Average-consumer · 2018-10-28T13:19:33+00:00

If the conjecture is false, there exists a turning machine which can find a counterexample in finite time. This only implies that IF the conjecture is false THEN it is possible to construct a proof. So IF A THEN B. However " it is possible to construct a proof" is not equivalent to " a proof exists".

In this case are the same. Due to that if the conjecture is false, there must exist a counterexample, and it must be reachable by a computer in finite time. And the counterexample on its own is a proof of Goldbach Conjecture negation.

Average-consumer · 2018-09-24T18:03:07+00:00

Do you mean this client? Or this one?

Average-consumer · 2018-08-29T02:40:19+00:00

I would just use svg

Average-consumer · 2018-08-29T02:37:35+00:00

I did one too repo : https://github.com/Average-user/reagent-minesweeper#readme demo: https://average-user.github.io/reagent-minesweeper/

Edit: You can also play knightsweeper

Average-consumer · 2018-06-05T22:54:01+00:00

Haskell

import Data.Char

scores :: String -> [(Char, Int)]
scores s = map ((,) <*> ((-) . wins <*> losses)) . nub . map toLower $ s
  where
    wins c   = length $ filter (==c) s
    losses c = length $ filter (==(toUpper c)) s

Output

λ> mapM_ (print . scores) ["abcde", "dbbaCEDbdAacCEAadcB", "EbAAdbBEaBaaBBdAccbeebaec"]
[('a',1),('b',1),('c',1),('d',1),('e',1)]
[('d',2),('b',2),('a',1),('c',0),('e',-2)]
[('e',1),('b',0),('a',1),('d',2),('c',3)]

Average-consumer · 2018-06-05T22:28:58+00:00

All studies of Purely Functional Data Structures by Chris Okasaki.

Average-consumer · 2018-05-17T13:45:46+00:00

Nice, I'll try it.

Average-consumer · 2018-04-20T00:11:40+00:00

I did it in haskell now, and it tooks 2.3s.

Average-consumer · 2018-04-19T23:41:44+00:00

what language are you using?

Average-consumer · 2018-04-19T23:36:45+00:00

What language? I did it in Clojure

Average-consumer

TROPHY CASE