È semplice. Non sopporto quando le persone usano gli spazi quando nominano i file. Talvolta rovina i comandi della console e rende brutta l'output di ls.

La sfida è scrivere un programma (solo caratteri ASCII) che

1. rinomina tutti i file (comprese le directory) nella directory corrente in versioni con spazi rimossi o sostituiti da '_'
2. in caso di collisione, è necessario aggiungere un identificatore univoco (fino a te)
3. scende ricorsivamente in tutte le sottodirectory

È possibile assumere nomi di percorsi in stile UNIX. Chi avrebbe comunque bisogno di questo programma su un computer Windows?

Questo è il golf del codice, vince il programma più breve (caratteri #ascii). Dal momento che odio gli spazi così tanto, ogni spazio deve essere contato due volte.

Fornisci la tua lingua, il punteggio, il programma e una breve descrizione di come eseguirlo.

Il programma deve essere compilato ed eseguito con ragionevole sforzo sulla mia macchina Linux.

EDIT: Poiché Etan ha richiesto una struttura di file per il test, ecco lo script che attualmente uso per creare un albero di file adatto:

#!/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

Coreshils Zsh + GNU - 48 byte (1 spazio)

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

È strano che odi (ASCII) gli spazi ma che vada bene con le schede e le nuove righe, ma immagino che ci voglia tutto.

zmv risolve molti problemi di ridenominazione dei file in modo conciso (e solo leggermente oscuro). Tuttavia, insiste sul fatto che gli obiettivi siano unici; mentre puoi facilmente aggiungere suffissi univoci, aggiungere un suffisso solo se fosse necessario richiede di ripetere tutto il lavoro. Quindi invece eseguo il ciclo manualmente e faccio affidamento su GNU mv per aggiungere un identificatore univoco in caso di collisione ( --backupopzione, inoltre --no-target-directorynel caso in cui una destinazione sia una directory esistente, altrimenti mvsi sposterebbe il sorgente all'interno di quella directory).

(od)è un qualificatore glob per ordinare l'output con le directory che compaiono dopo il loro contenuto (come find -depth). Dinclude file dot nel glob. :he :tsono modificatori della storia simili a dirnamee basename.

mvsi lamenta che viene chiamato per rinominare i file a se stessi, perché il glob include nomi di file senza spazi. È la vita.

Versione non golfata:

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

Bash 116 byte, 16 spazi

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

Non ho eliminato gli errori per guadagnare un paio di byte in più. Questo non avrà alcuna collisione.

Se ci si findpuò aspettare GNU non posix , questo può essere ulteriormente abbreviato:

Bash 110 byte, 15 spazi

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

La rimozione di spazi anziché la loro sostituzione utilizza due byte in meno:

Bash 108 byte, 15 spazi

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

Nota: se è possibile utilizzare le schede anziché gli spazi, è necessario solo 1 spazio (quello nella regola di corrispondenza per la sostituzione alla riga 2).

Grazie a Dennis per aver trovato un bug sulla doppia virgoletta (e aver fornito la soluzione)

Python 180 byte

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 spazi se usi la tab per il rientro :-)

Se l'ordine dei suffissi dei file scontrati non ha bisogno di dare un precedente al file preesistente, allora per me funziona quanto segue:

bash / find / mv 84 byte, 16 spazi

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

bash / find / mv 82 byte, 14 spazi

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

Coccole &&per risparmiare due byte di spazio.

bash / find / mv 60 byte, 11 spazi

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

Elimina la protezione dagli errori in modo da ottenere errori da MV su file che non hanno spazi per iniziare.

Modifica: sono state eliminate le citazioni {}come ricordato da Dennis. Ha anche permesso finddi urlare portabilità e deprecazione nella versione più corta in cui si mvsta già urlando di spostare un file su se stesso.

Modifica 2: aggiunto -Tal mvcomando per evitare di annidare le directory invece di rinominare come indicato da pqnet. Espansione delle parentesi graffe usata al costo di un personaggio oltre a utilizzare uno spazio.

NodoJS - 209 byte, 3 spazi bianchi

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 byte

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

Bash + Perl rename64

( renameè lo script Perl su Debian e derivati, non il comando util-linux.)

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

POSIX sh+ GNU find+ GNU mv67 byte ASCII + uno spazio (letterale)

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

Non so se si adatta, ma con questo ogni sequenza di spazi viene elisa in un singolo _- mi piace comunque. In realtà qualsiasi sequenza tranne gli spazi iniziali / finali che sono - quelli vengono automaticamente troncati (che è anche, a mio avviso, un comportamento benefico) . Grazie a Gilles per averlo segnalato.

Questo utilizza solo il separatore di campo interno per separare i campi.

È abbastanza ... loquace ...

...Oddio. Sapevo che la cosa delle schede era economica, ma pensavo che fosse almeno intelligente. Ora sono solo in ritardo alla festa ...

PHP, 147 145 byte, 2 1 spazio 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);}}}

funzione ricorsiva. Corri cons(".");

Scorrere i globrisultati per il percorso specificato:

• se directory, ricorrere
• sostituire gli spazi con trattino basso
• se le stringhe differiscono
  • mentre viene preso il nuovo nome file, aggiungi il trattino basso
  • rinomina file / directory

Ruby 121

require 'find'

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

Python, 187

165, più 22 punti di penalità per gli spazi.

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 il trucco di Emanuele :

Solo un singolo spazio in questo!

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

(Sostituisci gli spazi con le schede.)

(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) \.

Sulla base di nderscore versione ottimizzata di CPU1 's risposta .

Bash 4+ 111 byte

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 caratteri

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)

secondo il commento di @ edc65

Groovy, gestire le collisioni, 259 caratteri

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 (testato su zsh) + comandi Linux di base 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