Concurso (!): No idioma de sua escolha, escreva um programa que percorra a árvore de diretórios de um determinado diretório e produza uma árvore (ou seja, uma matriz de matrizes) correspondente a ele. Suponha que o diretório seja uma variável predefinida D. A menor contagem de caracteres vence.

Regras:

• Você deve usar recursão
• Ver Regras

Nota: Suponha que não haja limites de profundidade de recursão. Em outras palavras, seu código só precisa funcionar para árvores de diretório suficientemente pequenas e, em princípio, para árvores maiores.

Por exemplo:

A árvore de diretórios é

dir1
├── dir11
│   ├── file111
│   └── file112
├── dir12
│   ├── file121
│   ├── file122
│   └── file123
├── file11
├── file12
└── file13

A árvore de saída é

[[[],[]],[[],[],[]],[],[],[]]

Primeiro código de golfe aqui, então deixe-me saber se estou fazendo algo errado.

Diverta-se :)

Mathematica 120 21 20

Recursão explícita (obrigado alephalpha por salvar um caractere):

f=f/@__~FileNames~#&

f["~/StackExchange/dir1"]

{{{}} {}}, {{}, {}, {}}, {}, {}, {}}

TreeForm[%]

Solução supercomplicada anterior:

d="~/StackExchange/dir1"

f@{x___,Longest@s:{y_,___}..,z___}:=f@{x,f@Drop[{s},1,1],z}
f[FileNameSplit/@FileNames[__,SetDirectory@d;"",∞]]/.f->(#&)

Ruby, 38 caracteres

Se você não se importa com algum espaço em branco extra na saída:

f=->n{Dir[n+'/*'].map{|c|f[c]}}
p f[D]

Exemplo de uso:

D='C:/work/dir1'
f=->n{Dir[n+'/*'].map{|c|f[c]}}
p f[D]

Resultado:

[[[], []], [[], [], []], [], [], []]

Se eu não puder ter o espaço em branco, algo assim para a segunda linha:

puts"#{f[D]}".tr' ',''

Python 2.7, 111 caracteres

Pega o caminho de destino de stdin.

import os
def R(d):return[R(f)for f in[d+'/'+e for e in os.listdir(d)]if os.path.isdir(f)]
print R(raw_input())

Powershell - 182 Char

function A([string]$b){write-host -NoNewline '['; ls -path $b|foreach{if($_.PSIsContainer){A($_.FullName)}ELSE{write-host -NoNewline $f'[]';$f=', '}};write-host -NoNewline ']'};A($D)

Relativamente simples. Pode ser reduzido em 10 caracteres se as vírgulas não forem necessárias. Recebe entrada de $ D (como declarado na pergunta), retorna a saída em STD-Out como foi o exemplo da pergunta.

Realmente desejando aliases poderiam usar opções! Estou sendo morto pelos 'write-host -NoNewline's!

Caracteres C # 200

Saída de uma string, não de uma matriz real. Toma um caminho como o primeiro argumento.

using D=System.IO.DirectoryInfo;class P{static string R(D d){var r="[";foreach(D e in d.GetDirectories())r+=R(e);return r+"]";}static void Main(string[] a) {System.Console.WriteLine(R(new D(a[0])));}}

Ungolfed:

using D = System.IO.DirectoryInfo;

class P
{
    static string R(D d)
    {
        var r = "[";
        foreach (D e in d.GetDirectories())
            r += R(e);
        return r + "]";
    }

    static void Main(string[] a)
    {
        System.Console.WriteLine(R(new D(a[0])));
    }
}

C ++, 318 bytes

#include <cstdio>
#include <dirent.h>
#include <string>
#define s std::string
#define n e->d_name
s l(s p){s r;dirent*e;DIR*d;if(d=opendir(p.c_str())){int c=0;while(e=readdir(d))if(s("..")!=n&s(".")!=n)r+=&",["[!c++]+(e->d_type==DT_DIR?l(p+'/'+n):"")+"]";closedir(d);}return r;}main(){puts((s("[")+l(D)+"]").c_str());}

Aqui está uma versão ligeiramente não-destruída:

#include <cstdio>
#include <dirent.h>
#include <string>

#define s std::string
#define n e->d_name

s l(s p) {
    s r;
    dirent*e;
    DIR*d;
    if (d=opendir(p.c_str())) {
        int c=0;
        while (e=readdir(d))
            if (s("..")!=n&s(".")!=n)
                r+=&",["[!c++]+(e->d_type==DT_DIR?l(p+'/'+n):"")+"]";
        closedir(d);
    }
    return r;
}

main() {
    puts((s("[")+l(D)+"]").c_str());
}

Observe que, como - por instruções - D é assumida como uma variável predefinida, o código não é construído sem fornecer de alguma forma o D. Aqui está uma maneira de criar:

g++ -Dmain="s D=\".\";main" -o tree golfed.cpp

Script em lote - 146, 157, 152 127 bytes

set x=
:a
set x=%x%,[
cd %1
goto %errorlevel%
:0
for /f %%a in ('dir/b') do call:a %%a
cd..
:1
set x=%x:[,=[%]
cls
@echo %x:~1%

Correr com:

scriptfile.cmd folderroot