DouKaku?

import os

def remove_backup(root_path):
    for w in os.walk(root_path):
        for f in w[2]:
            if f.endswith('~'):
                os.remove('%s/%s' % (w[0], f))

 import java.io.File;
import java.io.FileFilter;

public class FileCleaner {

    private File rootDir;

    public FileCleaner(String rootDir) {
        this(new File(rootDir));
    }

    public FileCleaner(File rootDir) {
        this.rootDir = rootDir;
    }

    public void deleteFilesBySuffix(String suffix) {
        FileFilter filter = new FileFilter() {
            public boolean accept(File pathname) {
                return pathname.isFile() && pathname.getName().endsWith("~");
            }
        };
        deleteTargetFiles(rootDir, filter);
    }

    private void deleteTargetFiles(File dir, FileFilter filter) {
        File[] fileList = dir.listFiles();
        for (int i=0; i<fileList.length; i++) {
            File file = fileList[i];
            if (file.isDirectory()) {
                deleteTargetFiles(file, filter);
            } else {
                if (filter.accept(file)) {
                    file.delete();
                    System.out.println(file + " を削除しました。");
                }
            }
        }
    }

    public static void main(String[] args) {
        if (args.length == 0) {
            System.err.println("ディレクトリを指定してください。");
            return;
        }
        new FileCleaner(args[0]).deleteFilesBySuffix("~");
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h> 
#include <dirent.h>
#include <unistd.h>

void remove_backup(const char *dn){
    DIR *dp;
    struct dirent *de;
    char path[PATH_MAX];
    struct stat st;
    if(!(dp = opendir(dn))) return;
    while((de = readdir(dp))){
        if(!strcmp(de->d_name, ".") || !strcmp(de->d_name, "..")) continue;
        snprintf(path, PATH_MAX, "%s/%s", dn, de->d_name);
        stat(path, &st);
        if(S_ISREG(st.st_mode) && de->d_name[strlen(de->d_name) - 1] == '~')
            unlink(path);
        else if(S_ISDIR(st.st_mode))
            remove_backup(path);
    }
}

class Dir
  def delete_rec(pat)
    self.each do |e|
      next if e == '.' or e == '..'
      p = self.path + '/' + e
      File.delete(p) if pat =~ e and File.writable?(p)
      Dir.open(p).delete_rec(pat).close if File.directory?(p)
    end
    self
  end
end

Dir.open(ARGV[0]).delete_rec(/~$/).close

<?php
remove_file('.', '~$');
function remove_file($dir, $regex){
    $d = dir($dir);
    while (($file = $d->read()) !== false) {
        if ($file == '.' || $file == '..') continue;
        $path = $d->path . "/$file";
        if (is_dir($path)){
            remove_file($path, $regex);
        }else if (preg_match("/$regex/", $path)){
            echo "delete $path\n";
            unlink($path);
        }
    }
    $d->close();
}
?>

perl -MFile::Find -e "find(sub {/.*~$/ && unlink \$File::Find::name;}, '.');"

(use file.util)
(define (remove-backup dir)
  (directory-fold "." (lambda (path seed) (and (#/~$/ path) (sys-unlink path))) #f))
(define (main args) (for-each remove-backup (cdr args)) 0)

require 'find'

Find.find(".") do |fn|
  if File.file?(fn) && ?~ == fn[-1]
    File.unlink(fn)
  end
end

Dir.glob('**/*~') do |path|
  File.unlink(path)
end

for /D /R %%d in (*~) do (echo "%%d")

import os.path
import os
from optparse import OptionParser


parser = OptionParser(usage="%prog <folder to start>", description='remove files end with "~" recursively.')
(opsions, args) = parser.parse_args()
if len(args) != 1:
  parser.error("need argument <folder to start>")

path = os.path.abspath(args[0])
def remove_them(parser, dirname, names):
  for name in names:
    t = os.path.join(dirname, name)
    if name.endswith('~'):
      try:
        os.remove(t)
      except e:
        print e, " skip to remove: ", t

os.path.walk(path, remove_them, parser)

fun! DeleteBackupFiles(dir)
  for v in split(globpath(a:dir, "*~"), "\n")
    call delete(v)
  endfor
endfun
call DeleteBackupFiles("/tmp")

using System;
using System.IO;

namespace Doukaku.CS
{
	public class DelNyoro
	{
		static void Main(string[] args)
		{
			foreach(string dir in args)
			{
				if (Directory.Exists(dir))
				{
					foreach (string nyoroFile in Directory.GetFiles(dir, "*~", SearchOption.AllDirectories))
						File.Delete(nyoroFile);
				}
				else
					Console.WriteLine(string.Format("Directory %s is not exists.", dir));
			}
		}
	}
}

del /s *~

import Control.Monad
import System
import System.Directory

main :: IO ()
main = do [root] <- getArgs
          removeBackup root

removeBackup :: FilePath -> IO ()
removeBackup dir
    = getDirectoryContents dir >>= mapM_ (removeIfBackupFile dir)
    where
      removeIfBackupFile :: FilePath -> FilePath -> IO ()
      removeIfBackupFile _ "."  = return ()
      removeIfBackupFile _ ".." = return ()
      removeIfBackupFile dir file
          = do let path = dir ++ "/" ++ file

               isDir <- doesDirectoryExist path

               if last path == '~' then
                   if isDir then
                       removeDirectoryRecursive path
                   else
                       removeFile path
                 else
                   when isDir $ removeBackup path

import java.io.File;

public class DelteFile {
	
	public static void main(String[] args) throws Exception {
		for (int i = 0; i < args.length; i++) delete(new File(args[i]));
	}
	
	private static void delete(File f) throws Exception {
		if (f.isDirectory()) {
			for (int i = 0; i < f.listFiles().length; i++) {
				delete(f.listFiles()[i]);
			}
		} else {
			if (f.getName().endsWith("~")) {
				if (!f.delete()) {
					throw new Exception("何らかの原因で削除できず");
				}
			}
		}
	}
}

main(){system("find . -type f -name '*~' | xargs rm");}

#! /bin/bash

shopt -s dotglob #for dotfile

function rm_g(){
    local file proc_dir=$1
    for file in ${proc_dir}/*; do
        [ ${file:(-1):1} == '~' ] && rm $file
        [ -d $file ] && rm_g $file
    done
}

rm_g ~/tmp

-module(delbackup).
-export([delbackup/1]).

delbackup(RootPath) ->
        check_dir(RootPath).

check_dir(Path) ->
        case file:list_dir(Path) of
                {ok, FileList} ->
                        check_file(Path, FileList);
                {error, Reason} ->
                        io:format("Error. ~s (~p)~n", [Path, Reason])
        end.

check_file(Path, [File|RestFile]) ->
        FilePath = Path ++ "/" ++ File,
        io:format("~s~n", [FilePath]),
        IsDir = filelib:is_dir(FilePath),
        IsFile = filelib:is_file(FilePath),
        case {IsDir, IsFile} of
                {true, _} ->
                        check_dir(FilePath);
                {_, true} ->
                        check_backup(FilePath);
                _Other ->
                        ok
        end,
        check_file(Path, RestFile);
check_file(_Path, []) ->
        ok.

check_backup(FilePath) ->
        case regexp:match(FilePath, "~$") of
                {match, _, _} ->
                        file:delete(FilePath),
                        io:format("delete ~s~n", [FilePath]);
                _Else ->
                        ok
        end.

find . -name '*~' -exec /bin/rm {} \;

find $dir -type f -name \*~ -print0 | xargs -0 rm -f

# dma.pl
$ARGV[0] or die "Usage: $0 DIRECTORY...\n";

foreach my $dir (@ARGV) {
    dfswalk($dir, sub {
            my $path = shift;
            if ($path =~ /~$/ and -f $path) {
                unlink($path) or warn("$path: $!\n");
            }
    });
};

sub dfswalk
{
    my ($dir, $fn) = @_;
    
    unless (opendir(D, $dir)) {
        warn "$dir: $!\n";
        return;
    }
    foreach my $name (readdir(D)) {
        next if ($name eq '.' or $name eq '..');
        my $path = sprintf("%s/%s", $dir, $name);
        
        &$fn($path);
        if (-d $path) {
            dfswalk($path, $fn);
        }
    }
    closedir(D);
}

#!/bin/sh
find . -name '*~' -print | xargs rm

BEGIN{system("find . -type f -name '*~' | xargs rm")}

using System;
using System.IO;
class Program
{
  static void Main()
  {
    string dir = @"C:\test";
    foreach (string s in Directory.GetFiles(dir, "*~", SearchOption.AllDirectories))
      File.Delete(s);
  }
}

open System;;
open System.IO;;
open Array;;
open Printf;;

let del path =
    let dirFiles = Directory.GetFiles(path,