Es simple. No puedo soportar cuando la gente usa espacios al nombrar archivos. A veces destruye los comandos de la consola y hace que la salida de ls sea fea.

El desafío es escribir un programa (solo caracteres ascii) que

1. cambia el nombre de todos los archivos (incluidos los directorios) en el directorio actual a versiones con espacios eliminados o reemplazados por '_'
2. en caso de colisión, debe agregar un identificador único (depende de usted)
3. desciende recursivamente en todos los subdirectorios

Puede asumir nombres de ruta de estilo UNIX. ¿Quién necesitaría este programa en una máquina Windows de todos modos?

Este es el código de golf, el programa más corto gana (#ascii caracteres). Como odio tanto los espacios, cada espacio tiene que contarse dos veces.

Proporcione su idioma, puntaje, programa y una breve descripción de cómo ejecutarlo.

El programa debe compilarse y ejecutarse con un esfuerzo razonable en mi máquina Linux.

EDITAR: como Etan solicitó una estructura de archivos para las pruebas, aquí está el script que utilizo actualmente para crear un árbol de archivos adecuado:

#!/bin/bash
rm -r TestDir

touchfiles()
{
    touch my_file
    touch my__file
    touch "my file"
    touch "my  file"
    touch " my_file  "
}

mkdir TestDir
cd TestDir

touchfiles

for dir in "Test Sub" Test_Sub "Te stSub" Te_stSub
do
    mkdir "$dir"
    cd "$dir"
    touchfiles
    cd ..
done

Coreutils Zsh + GNU - 48 bytes (1 espacio)

for x   (**/*(Dod))mv   -T  --b=t   $x  $x:h/${${x:t}// }

Es extraño que odies los espacios (ASCII), pero estás bien con pestañas y líneas nuevas, pero supongo que se necesita todo tipo.

zmv resuelve muchos problemas de cambio de nombre de archivos de manera concisa (y solo un poco oscura). Sin embargo, insiste en que los objetivos sean únicos; Si bien puede agregar fácilmente sufijos únicos, agregar un sufijo solo si fuera necesario prácticamente requiere volver a hacer todo el trabajo. Entonces, en cambio, hago un bucle manualmente y confío en GNU mv para agregar un identificador único en caso de colisión ( --backupopción, más --no-target-directoryen caso de que un destino sea un directorio existente, ya que de mvlo contrario se movería la fuente dentro de ese directorio).

(od)es un calificador global para ordenar la salida con directorios que aparecen después de su contenido (como los de find -depth). Dincluye archivos de puntos en el globo. :hy :tson modificadores de historia similares a dirnamey basename.

mvse queja de que se llama para cambiar el nombre de los archivos a sí mismos, porque el globo incluye nombres de archivos sin espacios. Así es la vida.

Versión sin golf:

for x in **/*\ *(Dod); do
  mv --no-target-directory --backup=numbered $x ${x:h}/${${x:t}// /}
done

Bash 116 bytes, 16 espacios

find . -depth -exec bash -c 'B=${0##*/}
M="${0%/*}/${B// /_}"
while [ -e "$M" ]
do M=$M.
done
mv "$0" "$M"' {} \;

No suprimí los errores para ganar un par de bytes más. Esto no tendrá ninguna colisión.

Si findse puede esperar GNU no posix , esto se puede acortar aún más:

Bash 110 bytes, 15 espacios

find -d -exec bash -c 'B=${0##*/}
M="${0%/*}/${B// /_}"
while [ -e "$M" ]
do M=$M.
done
mv "$0" "$M"' {} \;

Eliminar espacios en lugar de reemplazarlos usa dos bytes menos:

Bash 108 bytes, 15 espacios

find -d -exec bash -c 'B=${0##*/}
M="${0%/*}/${B// }"
while [ -e "$M" ]
do M=$M.
done
mv "$0" "$M"' {} \;

Nota: si se pueden usar pestañas en lugar de espacios, solo se necesita 1 espacio (el que está en la regla de coincidencia para la sustitución en la línea 2).

Gracias a Dennis por encontrar un error en la comilla doble (y proporcionar una solución)

Python 180 bytes

from    os  import*
t,c,h='.',chdir,path
def g(p):
    c(p)
    for x   in  listdir(t):
        if h.isdir(x):g(x)
        n=x.replace(' ','')
        while h.exists(n):n+=t
        if' 'in x:rename(x,n)
    c(t*2)
g(t)

solo 2 espacios si usa tab para sangría :-)

Si el orden de los sufijos de archivos colisionados no necesita dar precedente al archivo preexistente, entonces lo siguiente funciona para mí:

bash / find / mv 84 bytes, 16 espacios

find -depth -execdir bash -c '[ "${0//[^ ]}" ] && mv -{T,--b=t} "$0" "${0// }"' {} \;

bash / find / mv 82 bytes, 14 espacios

find -depth -execdir bash -c '[ "${0//[^ ]}" ]&&mv -{T,-b=t} "$0" "${0// }"' {} \;

Acurrucado &&para ahorrar dos bytes de espacio.

bash / find / mv 60 bytes, 11 espacios

find -d -execdir bash -c 'mv -{T,-b=t} "$0" "${0// }"' {} \;

Elimina la protección contra errores para obtener errores de mv en archivos que no tienen espacios para comenzar.

Editar: se eliminaron las citas {}según lo recordó Dennis. También se le findpermite gritar sobre portabilidad y desaprobación en la versión más corta donde mvya se está gritando sobre mover un archivo encima de sí mismo.

Edición 2: se agregó -Tal mvcomando para evitar anidar directorios en lugar de renombrar como lo señala pqnet. Se usó la expansión de llaves al costo de un personaje sobre el uso de un solo espacio.

NodeJS - 209 bytes, 3 espacios en blanco

s=require('fs');function a(d){s.readdirSync(d).forEach(function(f){f=d+'/'+f;i=0;r=f;if(/ /.test(f)){r=f.replace(' ','');while(s.existsSync(r))r+=i++;s.renameSync(f,r)}s.statSync(r).isDirectory()&&a(r)})}a('.');

Bash - 86 bytes

find    .   -d|while    IFS=""  read    f;do    t=${f##*/};mv   --b=t   -T  "$f"    "${f%/*}"/${t// /};done

Bash + Perl rename64

( renamees el script de Perl en Debian y derivados, no el comando util-linux).

find . -depth -name "* *" -execdir rename 'y/ /_/' * \;

POSIX sh+ GNU find+ GNU mv67 bytes ASCII + un espacio (literal)

find    -d  -exec   sh  -cf 'IFS=\ ;IFS=_   set $0;mv   --b=t   "$0"    "$*"'   {}  \;

No sé si encaja, pero con esto cualquier secuencia de espacios se elude a una sola _, me gusta de todos modos. En realidad, cualquier secuencia, excepto los espacios iniciales / finales, es decir, se trunca automáticamente (lo que también es, creo, un comportamiento beneficioso) . Gracias a Gilles por señalar esto.

Esto solo usa el separador de campo interno para separar los campos.

Es bastante ... hablador ...

...Oh hombre. Sabía que la ficha era barata, pero pensé que al menos era inteligente. Ahora llego tarde a la fiesta ...

PHP, 147145 bytes, 2 1 espacio s -> 146

function    s(){foreach(glob("*")as$n){is_dir($n)&&chdir($n)&s()|chdir("..");if($n<$r=strtr($n," ",_)){while(file_exists($r))$r.=_;rename($n,$r);}}}

función recursiva. Corre cons(".");

Recorrer los globresultados para la ruta dada:

• si directorio, recurse
• reemplazar espacios con guiones bajos
• si las cadenas difieren
  • mientras se toma un nuevo nombre de archivo, agregue un guión bajo
  • renombrar archivo / directorio

Rubí 121

require 'find'

Find.find('.') do |file|
  if file.chomp.match(/ /)
    File.rename(file, file.gsub(/ /, '_'))
  end
end

Pitón, 187

165, más 22 puntos de penalización por los espacios.

from os import*
u='_';j=path.join
for t,d,f in walk('.',0):
 for z in f+d:
  n=z.replace(' ',u)
  if n!=z:
   while path.exists(j(t,n)):n+=u
   rename(j(t,z),j(t,n))

166, usando el truco \ t de Emanuele :

¡Solo un espacio en este!

from    os  import*
u='_';j=path.join
for t,d,f   in  walk('.',0):
    for z   in  f+d:
        n=z.replace(' ',u)
        if  n!=z:
            while   path.exists(j(t,n)):n+=u
            rename(j(t,z),j(t,n))

LiveScript - 166

(Reemplace los espacios con pestañas).

(a=->(s=require \fs)readdirSync(it)map (f)->f=it+'/'+f;r=f.replace /\s/g,i='';(while f!=r&&s.existsSync r=>r+=i++);s.statSync(f)isDirectory(s.renameSync f,r)&&a r) \.

Basado en la versión optimizada de nderscore de la respuesta de cPu1 .

Bash 4+ 111 bytes

shopt -s dotglob globstar
for f in **
do
n=${f// /}
while [[ $f != $n && -e $n ]]
do n+=1
done
mv "$f" $n
done

Groovy, 139 caracteres

def c
c={
f->
def g=new File(f.parent,f.name.replaceAll('\\s',''))
f.renameTo(g)
!g.directory ?: g.eachFile(c)
}
new File('.').eachFile(c)

según el comentario de @ edc65

Groovy, manejar colisiones, 259 caracteres

def c
c={
p,l,f->
def g=new File(p,f.name.replaceAll('\\s',''))
f==g?:
(g.exists()?f.renameTo(g.toString()+l.indexOf(f.name)):f.renameTo(g))
!g.directory?:g.eachFile(c.curry(g,g.list().toList()))
}
def r=new File('.')
r.eachFile(c.curry(r,r.list().toList()))

POSIX (Probado en zsh) + comandos básicos de Linux 151

export IFS='
'
for f in $(ls -R1);do export n=$(echo $f|tr ' ' '_');yes n|mv $f $n || yes n|mv $f `echo $n;echo $f|md5sum`
done