O desafio

Construir uma N-nivelado Cantor Set .

O conjunto ternário Cantor é criado excluindo repetidamente os terços médios abertos de um conjunto de segmentos de linha.

O programa recebe um parâmetro N(um número inteiro) e depois imprime (no console ou de maneira semelhante) um conjunto de N níveis Cantor. A impressão pode conter apenas caracteres de undescore ( _) e com espaços. O parâmetro pode ser positivo ou negativo e o sinal indica a orientação de construção do conjunto de cantores: se N > 0o conjunto de cantores for construído para baixo e se N < 0o conjunto de cantores for construído para cima. Se N = 0então, o programa imprime uma única linha ( _).

Por exemplo:

N = 2

_________
___   ___
_ _   _ _

N = -2

_ _   _ _
___   ___
_________

N = 3

___________________________
_________         _________
___   ___         ___   ___
_ _   _ _         _ _   _ _

N = -3

_ _   _ _         _ _   _ _
___   ___         ___   ___
_________         _________
___________________________

Critérios de vitória

Como é um desafio de código de golfe, o código mais curto vence.

Editado: Modifique 0 entrada por sugestão de ugoren.

GolfScript, 49 42 40 caracteres

~.abs.3\?'_'*\{.3%..,' '*\++}*](0>2*(%n*

Com agradecimentos a hammar por 42-> 40.

Infelizmente, minha melhor tentativa de uma abordagem mais teórica dos números é muito mais longa:

~.abs:^3\?,{3^)?+3base(;1+1?.'_'*^@-)' '*+}%zip\0>2*(%n*

ou

~.abs 3\?:^,{6^*+3base.1+1?.('_'*@,@-' '*+}%zip\0>2*(%n*

e desconfio que o tamanho basee zipo impossibilitem de alcançar.

Python, 116 113 104 103 caracteres

n=input()
d=n>0 or-1
for i in range(n*d+1)[::d]:
 s='_'*3**i
 while i<n*d:s+=len(s)*' '+s;i+=1
 print s

Algoritmo mais antigo com 113 caracteres

r=input()
u='_'
l=[u]
for _ in abs(r)*u:o=len(l[0]);l=[s+o*' '+s for s in l]+[u*o*3]
print'\n'.join(l[::r>0 or-1])

Rubi (97)

Baseado na versão python de Steven Rumbalski:

n,r=$*[0].to_i,[?_]
n.abs.times{z=r[0].size;r=r.map{|s|s+' '*z+s}+[?_*z*3]}
puts n<0?r:r.reverse

Tentativas anteriores, com o mesmo comprimento (112)

Crie linhas a partir de peças:

c=->x,n{n<1??_*x :(z=c[s=x/3,n-1])+' '*s+z}
r=(0..m=(n=$*[0].to_i).abs).map{|i|c[3**m,i]}
puts n<0?r.reverse: r

Comece com uma linha, faça furos nela:

r=[?_*3**a=(n=$*[0].to_i).abs]
a.times{|c|r<<r[-1].gsub((x=?_*o=3**(a-c-1))*3,x+' '*o+x)}
puts n<0?r.reverse: r

Perl, 93 caracteres

@x=($t=$x=_ x 3**($a=abs($n=<>)),map$x.=$"x($x=~s/(.)../$1/g).$x,1..$a);say for$n<0?sort@x:@x

Pensei em tentar ver como a solução GolfScript de Peter Taylor seria portada para Perl. Recursos notáveis ​​incluem o uso de em sortvez de reversesalvar três caracteres, usando o fato de que um espaço é classificado anteriormente _.

Lisp comum, 217 210 caracteres

(defun m(x)(flet((c(n v)(if(= n 0)`((,v))(cons(substitute v nil(make-list(expt 3 n)))(mapcar #'append(c(1- n)v)(c(1- n)" ")(c(1- n)v))))))(format t "~{~{~a~}~%~}"(let((r(c(abs x)'_)))(if(< x 1)(reverse r)r)))))

Expandido:

(defun m(x)
  (flet((c(n v)
    (if(= n 0)
       `((,v))
       (cons(substitute v nil(make-list(expt 3 n)))
            (mapcar #'append
                    (c(1- n)v)
                    (c(1- n)" ")
                    (c(1- n)v))))))
   (format t "~{~{~a~}~%~}"(let((r(c(abs x)'_)))(if(< x 1)(reverse r)r)))))

Eu acho que se o código Lisp conseguir superar qualquer contagem inicial para outro idioma (C, 219), estou indo bem :)

C ( 163 161 caracteres)

i,l,N;f(n,m,s){if(n){s=--n<l?m:s;f(n,m,s);f(n,s,s);f(n,m,s);}else
putchar(m);}main(n,v)int**v;{for(i=N=abs(n=atoi(1[v]));i+1;i--)l=n<N?N-i:i,f(N,95,32),f(0,10);}

Empresta alguns truques da resposta de ugoren , mas a lógica principal é bem diferente. Não consegui seguir o loop for dele, portanto, é possível hibridar e economizar um pouco mais.

C, 219 193 179 143 136 131 caracteres

Segui outra das idéias de Petyer Taylor, além de uma melhoria minha, economizando mais 6.
Integrou algumas dicas do @PeterTaylor, além de copiar sua função principal, com pequenas alterações, que salvam um personagem (é justo copiá-lo? Como nenhum de nós vencerá esse, acho que não é tão ruim).
Pensei em uma melhoria significativa em como minha recursão funciona e, depois de ver a resposta de Peter Taylor, implementei-a para recuperar a liderança. Ao ler sua resposta novamente, vi que fiz quase exatamente o que ele fez. Então isso parece a hibridização que ele sugeriu.
Também simplificou o loop main, mantendo o mesmo comprimento.
E levou o truque de Peter para imprimir nova linha, em vez de puts("")- salva um personagem.

Removido intda declaração da variável - um aviso, mas salva 4 caracteres.
O novo algoritmo não calcula 3 ^ x antecipadamente, mas usa um único loop para imprimir 3 ^ x caracteres.
Pode salvar mais um definindo int*v, mas 64 bits não funcionará.
A contagem de caracteres exclui o espaço em branco (que pode ser removido).

o,i,n;
p(c) {
    n-- ?
        p(c),p(o>n?c:32),p(c)
    :
        putchar(c);
    n++;
}
main(c,v)int**v; {
    for(n=abs(c=atoi(v[1]));i<=n;i++)o=c+n?n-i:i,p(95),puts("");
}

Algoritmo mais antigo, 219 caracteres:

p(l,o,i,m,c,j) {
    for(;i<(m=l);i++)
        for(j=0,c=95;m/o||!putchar(c);j++)
            i/m%3-1||(c=32),m/=3;
    puts("");
}
main(c,v,n,i,l,o)int**v;{
    (n=atoi(v[1]))<0?n=-n:(c=0);
    for(i=n,l=1;i;i--)l*=3;
    o=c?1:l;
    for (;i<=n;i++)p(l,o,0),c?o*=3:(o/=3);
}

J, 44 39 38 37 bytes

' _'{~0&>_&(]|.)(,:1)1&(,],.0&*,.])~|

Usa a iteração para criar o próximo conjunto começando com 1 (representando _) inicialmente.

Uso

   f =: ' _'{~0&>_&(]|.)(,:1)1&(,],.0&*,.])~|
   f 0
_
   f 1
___
_ _
   f _1
_ _
___
   f 2
_________
___   ___
_ _   _ _
   f _2
_ _   _ _
___   ___
_________
   f 3
___________________________
_________         _________
___   ___         ___   ___
_ _   _ _         _ _   _ _
   f _3
_ _   _ _         _ _   _ _
___   ___         ___   ___
_________         _________
___________________________

Explicação

' _'{~0&>_&(]|.)(,:1)1&(,],.0&*,.])~|  Input: integer n
                                    |  Absolute value of n
                (,:1)                  The array [1]
                     1&(          )~   Repeat abs(n) times starting with x = [1]
                                 ]       Identity function, gets x
                            0&*          Multiply x by 0
                               ,.        Join the rows together
                         ]               Identity function, gets x
                          ,.             Join the rows together
                     1  ,                Prepend a row of 1's and return
      0&>                              Test if n is negative, 1 if true else 0
         _&(   )                       If n is negative
             |.                          Reverse the previous result
            ]                            Return that
                                       Else pass the previous result unmodified
' _'                                   The string ' _'
    {~                                 Select from the string using the result
                                       as indices and return

R , 141 139137 bytes

m=abs(n<-scan());write("if"(n<m,rev,c)(c(" ","_")[Reduce(`%x%`,rep(list(matrix(c(1,1,1,1,0,1),3)),m),t(1))[,1+2^m-2^(m:0)]+1]),1,3^m,,"")

Experimente online!

-15 bytes também graças ao uso de Giuseppe '('como função de identidade; writeem vez de catimprimir a saída; uso inteligente de %x%.

-2 bytes graças a Kirill L. usando em cvez de '('como a função de identidade.

Python, 177 164 caracteres

N=input()
n=abs(N)
c=lambda x:0if x<1 else x%3==1or c(x/3)
r=["".join([["_"," "][c(x/3**i)]for x in range(3**n)])for i in range(n+1)]
print"\n".join(r[::N>0 or-1])

Perl, 113 caracteres

$i=abs($I=<>);@w=$_='_'x3**$i;while($i--){$x=3**$i;s/(__){$x}/'_'x$x.' 'x$x/eg;push@w,$_}say for$I>0?reverse@w:@w

Expandido:

$i=abs($I=<>);
@w=$_='_'x3**$i;
while($i--){
    $x=3**$i;
    s/(__){$x}/'_'x$x.' 'x$x/eg;
    push@w,$_
}
say for$I>0?reverse@w:@w

JavaScript 121 bytes

Função recursiva interna e, em seguida, cuide da saída para trás, se necessário

n=>(f=(n,t=n&&f(n-1),r=t[0])=>n?[r+r+r,...t.map(x=>x+t[n]+x)]:['_',' '],f=f(n<0?-n:n),f.pop(),n<0?f.reverse():f).join`\n`

Menos golfe

n=>{
  var f = n => { // recursive function
    var t = n && f(n-1), r = t[0]
    return n 
      ? [r+r+r, ...t.map(x => x+t[n]+x)]
      : ['_',' ']
  };
  f = f(n < 0 ? -n : n);
  f.pop(); // last row is all blanks
  if (n<0) f.reverse();
  return f.join`\n`
}

Teste

var F=
n=>(f=(n,t=n&&f(n-1),r=t[0])=>n?[r+r+r,...t.map(x=>x+t[n]+x)]:['_',' '],f=f(n<0?-n:n),f.pop(),n<0?f.reverse():f).join`\n`

function go()
{
  var n=+I.value
  O.textContent = F(n)
}

go()

<input id=I type=number value=3 oninput='go()'>
<pre id=O></pre>

Lote, 265 262 242 236 235 bytes

@echo off
set/pn=
set c=%n%,-1,0
if %n% lss 0 set c=0,1,%n:-=%
for /l %%i in (%c%)do call:l %%i
exit/b
:l
set s=_
for /l %%j in (1,1,%n:-=%)do call:m %1 %%j
echo %s%
:m
set t=%s%
if %1 lss +%2 set t=%s:_= %
set s=%s%%t%%s%

Edit: Salvo 12 19 bytes graças a @ l4m2. Economizou 8 bytes removendo a %a%variável desnecessária .

JavaScript (Node.js) , 148 bytes

n=>f=(L=n<0&&n,R=n>0&&n)=>[...Array(r=3**(n>0?n:-n))].map(_=>((j++).toString(3)+1).indexOf(1)>(L>0?L:-L)?'_':' ',j=r+r).join``+`
${L++<R?f(L,R):''}`

Experimente online!

Python 2 , 102 bytes

lambda n:'\n'.join(eval("[i+' '*len(i)+i for i in"*abs(n)+"'_'"+"]+['___'*len(i)]"*abs(n))[::n<1or-1])

Experimente online!

Prolog (SWI) , 265 232 213 bytes

S-E-R:-between(S,E,R).
[]/R/R.
[H|T]/B/R:-T/[H,32,H|B]/R.
N+R:-(N>0->O is N-1,O+S,S/[]/R;R=`_`).
N*[H|T]:-1-N-_,writef("%n",[H]);N*T.
_*[]:-nl.
-N:-(0-N-J,K is N-J;N-0-I,J is -I,K is I-N),L is 3^K,J+R,L*R,1=0;1=1.

Experimente online!

PowerShell , 111 bytes

filter f{if($s=[math]::Sign($_)){($x=$_-$s|f|%{$_+' '*($l=$_|% Le*)+$_})|?{$s-1};'_'*3*$l;$x|?{$s+1}}else{'_'}}

Experimente online!

Menos golfe:

filter f{
    if($sign=[math]::Sign($_)){
        $x=$_-$sign|f|%{
            $_+' '*($length=$_|% Length)+$_
        }
        $x|?{$sign-1}  # output $x if $_ is negative
        '_'*3*$length
        $x|?{$sign+1}  # output $x if $_ is positive
    }
    else{
        '_'
    }
}