Programming Praxis

9 Responses to “Deblank”

1. Alex B. said

   June 28, 2019 at 10:45 AM

   Python 3:

   def remove_blank_lines(file, encoding='utf8'):
       """Return a list of the non-blank lines in a file"""
       non_blanks = []
       with open(file, 'r', encoding=encoding) as fobj:
           for line in fobj:
               if line.strip():
                   non_blanks.append(line)
       return non_blanks
   
2. Tovervogel said

   June 28, 2019 at 1:29 PM

   As a pseudo-one-liner in Python, abusing list comprehension syntax:

   
import sys; [sys.stdout.write(line) for line in sys.stdin if line.strip()]

3. Bill Wood said

   June 28, 2019 at 6:55 PM

   Rust version:

   fn strip(s: &str) -> String {
       s.chars().filter(|&c| " \t\n\r".find(c).is_none()).collect()
   }
   fn main() {
       println!("{}", strip(
           "this is a test
           of the emergency broadcast        
           system          
           \t!"));
   }
   

   Playground: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=930b30b55bac3d1783827bd1cd70f06b
4. fd said

   June 29, 2019 at 2:21 PM

   gawk /\S/
5. fd said

   June 29, 2019 at 2:23 PM

   There’s supposed to be two backslashes in front of the “S” in that gawk expression. Looks like the text-entry form here stripped one of them.
6. Daniel said

   June 29, 2019 at 10:27 PM

   Here’s a solution with a vim command:

   :v/\S/d
   
7. Zack said

   July 1, 2019 at 8:37 AM

   Intriguing problem, with a practical aspect to it! Here is my approach to it, using Julia:

   function ContainsOnlyWhiteCharacters(text::AbstractString)
   wc = [‘ ‘, ‘\t’, ‘\n’] # white characters

   for char in text
       if !(char in wc); return false; end
   end
   
   return true
   

   end

   function process(fn::AbstractString)
   f = open(fn)
   lines = readlines(f)
   close(f)
   n = length(lines)
   ind = BitArray(undef, n)

   for i = 1:n
       ind[i] = !ContainsOnlyWhiteCharacters(lines[i])
   end
   
   return join(lines[ind], "\n")
   

   end

   Cheers
8. Globules said

   July 3, 2019 at 2:18 AM

   An unimaginative, under-the-top Haskell version. The octal escapes in the printf produce a Unicode thin space.

   import           Data.Char (isSpace)
   import qualified Data.Text.Lazy as T
   import qualified Data.Text.Lazy.IO as IO
   
   main :: IO ()
   main = IO.interact (T.unlines . filter (not . T.all isSpace) . T.lines)
   

   $ printf "a\nb\n\nc\n  \t\nd\n\342\200\211\ne\n" | ./deblank
   a
   b
   c
   d
   e
   
9. mnemenaut said

   July 3, 2019 at 2:49 PM

   
#lang racket
(require 2htdp/image)

   (let ((white (car (image->color-list (text " " 12 "black")))))
(for ([line (port->lines)])
(unless
(for/and ([pixel (image->color-list (text line 12 "black"))])
(equal? pixel white))
(displayln line))))