DouKaku?

while ARGF.gets
  puts $_ unless $_[0] == ?#
end

print grep!/^#/,<>

% ruby -ne 'puts $_ unless $_ =~ /^#/'

vim -c "%g/^#/d _|wq" file.txt

ruby -pe "next if /^#/"

import fileinput
map(open("out.txt", "w").write, filter(lambda v: not v.startswith("#"), fileinput.input()))

import java.io.*;

public class RemoveLine {
	public static void main(String args[]) {
		if (args.length < 1) return;
		
		try {
			BufferedReader reader = new BufferedReader(new FileReader(args[0]));
			String line = reader.readLine();
			while (line != null) {
				if (!line.startsWith("#"))
					System.out.println(line);
				line = reader.readLine();
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

#include <stdio.h>
#include <stdlib.h>

#define MAXLENGTH 80

int main( int argc, char *argv[] )
{
        FILE *fh_input;
        FILE *fh_output;

        char line[MAXLENGTH];

        if ( argc != 3 ) {
                printf( "%s <input> <output>\n", argv[0] );
                exit(1);
        }

        fh_input = fopen( argv[1], "r" );
        if( fh_input == NULL ) {
                printf( "%s: file open error!\n", argv[1] );
                exit(1);
        }

        fh_output = fopen( argv[2], "w" );
        if( fh_output == NULL ) {
                printf( "%s: file open error!\n", argv[2] );
                exit(1);
        }

        while( fgets( line, MAXLENGTH, fh_input ) != NULL ) {
                if( line[0] != '#' ) {
                        fputs( line, fh_output );
                }
        }

        fclose( fh_output );
        fclose( fh_input );

        exit(0);
}

<?php
function removeComment($infile, $outfile, $startwith ='#') {
    $r = "";
    foreach(file($infile) as $line) {
        if (strncmp($line, $startwith, strlen($startwith))) {
            $r .= $line;
        }
    }
    file_put_contents($outfile, $r);
}

main = getContents >>= putStr . unlines . filter (('#' /=) . head) . lines

import sys
[l.startswith('#') or sys.stdout.write(l) for l in sys.stdin]

module Main (main) where
main :: IO ()
main = putStr . unlines . filter (null ||| ('#'/=) . head) . lines =<< getContents
infixr 2 |||
(|||) :: (a -> Bool) -> (a -> Bool) -> (a -> Bool)
(p ||| q) x = if p x then True else q x

#!/usr/local/bin/gosh
(port-for-each (any-pred #/^#/ print) read-line)

gets$9;gsub /^#.+$/,""

!/^[^#]/ {print;}

<?php
$handle = fopen('hoge.txt','r');
while(!feof($handle)){
	$buffer = fgets($handle);
	if(substr($buffer,0,1) != '#'){
		$array[] = $buffer;
	}
}
fclose($handle);
file_put_contents('hoge.txt',$array)
?>

(defun erase-comment-out-line (infile outfile)
  (with-open-file (in infile :direction :input)
    (with-open-file (out outfile :direction :output
					    :if-exists :supersede)
      (do ((line (read-line in nil 'eof)
		 (read-line in nil 'eof)))
	  ((eql line 'eof) 'Done)
	(unless (equal (schar line 0) #\#)
	  (write-line line out))))))

# -*- coding: utf-8 -*-

infile = open("intext.txt", "r")
s = infile.read()
infile.close()

outfile = open("outtext.txt", "w")

for x in s.splitlines():
    if x[0] != "#":
        outfile.write(x + "\n")

outfile.close()

using System;
class Program
{
  static void Main()
  {
    string s;
    while ((s = Console.ReadLine()) != null)
      if (!s.StartsWith("#")) Console.WriteLine(s);
  }
}

sed '/^#/d' file >file2

from __future__ import with_statement
import sys

def convert(input, output):
    with open(output, "w") as io:
        for line in open(input):
            if not line.startswith("#"):
                io.write(line)

if __name__ == '__main__':
    convert(sys.argv[1], sys.argv[2])

#include <iostream>
#include <fstream>

void convert(const char* input, const char* output)
{
    std::ifstream fin(input);

    if (fin)
    {
        std::ofstream fout(output);

        std::string s;

        while (std::getline(fin, s))
        {
            if (s.empty() || s[0] != '#')
            {
                fout << s << std::endl;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    if (argc != 3)
    {
        std::cerr << "usage: input output" << std::endl;

        return -1;
    }

    convert(argv[1], argv[2]);

    return 0;
}

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <iterator>
#include <functional>

class line_iterator : public std::iterator<std::input_iterator_tag, std::string>
{
    std::istream* _in;
    std::string _line;

    void getline()
    {
        if (_in && !std::getline(*_in, _line))
        {
            _in = NULL;
        }
    }

public:
    explicit line_iterator(std::istream& in) : _in(&in) { getline(); }

    line_iterator() : _in(NULL) {}

    const std::string& operator*() const { return _line; }

    line_iterator& operator++()
    {
        getline(); return *this;
    }

    line_iterator operator++(int)
    {
        line_iterator tmp = *this; getline(); return tmp;
    }

    friend bool operator==(const line_iterator& lhs, const line_iterator& rhs)
    {
        return lhs._in == rhs._in;
    }

    friend bool operator!=(const line_iterator& lhs, const line_iterator& rhs)
    {
        return lhs._in != rhs._in;
    }
};

struct starts_with_sharp : std::unary_function<std::string, bool>
{
    bool operator()(const std::string& s) const
    {
        return !s.empty() && s[0] == '#';
    }
};

int main(int argc, char* argv[])
{
    if (argc != 3)
    {
        std::cerr << "usage: input output" << std::endl;

        return -1;
    }

    std::ifstream fin(argv[1]);

    std::ofstream fout(argv[2]);

    std::remove_copy_if(
        line_iterator(fin),
        line_iterator(),
        std::ostream_iterator<std::string>(fout, "\n"),
        starts_with_sharp()
    );

    return 0;
}

(require :iterate)
(in-package :iter)
(defun remove-comments (in out)
  (iter (for line in-stream in using #'read-line)
        (unless (char= (aref line 0) #\#)
          (write-line line out))))

(defun test ()
  (with-open-file (in "10.input" :direction :input)
    (with-open-file (out "10.output" :direction :output :if-exists :supersede)
      (remove-comments in out))))

(test)

<?php

$handle = fopen("odai10.txt", "r");
while(!feof($handle))
{
    $buffer = stream_get_line($handle, 4096, "\n");
    if(strpos($buffer, "#") !== 0 )
    {
        $array[] = $buffer;
    }
}
fclose($handle);
file_put_contents("odai10.txt", implode("\n", $array));
?>

my $tmp = <<"EOM";
hello!
# remove this
 # don't remove this
bye!
EOM

open(OUT,">output");

for(grep {!/^#/} split /\n/,$tmp){
	print OUT "$_\n"
}
close(OUT);