El reto

Construye un conjunto de Cantor N-Nivelado .

El conjunto ternario de Cantor se crea eliminando repetidamente los tercios medios abiertos de un conjunto de segmentos de línea.

El programa recibe un parámetro N(un número entero) y luego imprime (en la consola o de manera similar) un conjunto Cantor de N niveles. La impresión solo puede contener undescore ( _) y espacios en blanco. El parámetro puede ser positivo o negativo y el signo indica la orientación de construcción del conjunto de Cantor: si N > 0el conjunto de Cantor se construye hacia abajo y si N < 0el conjunto de Cantor se construye hacia arriba. Si N = 0entonces el programa imprime una sola línea ( _).

Por ejemplo:

N = 2

_________
___   ___
_ _   _ _

N = -2

_ _   _ _
___   ___
_________

N = 3

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

N = -3

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

Criterios ganadores

Como es un desafío de código de golf, gana el código más corto.

Editado: Modificar 0 entradas por sugerencia de ugoren.

GolfScript, 49 42 40 caracteres

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

Gracias a hammar por 42-> 40.

Mi mejor intento hasta ahora en un enfoque más teórico de los números es lamentablemente mucho más largo:

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

o

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

y sospecho que la longitud de basey ziphará que sea imposible ponerse al día.

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 más antiguo con 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])

Rubí (97)

Basado en la versión 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

Intentos anteriores, ambos de la misma longitud (112)

Construir líneas a partir de piezas:

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

Comience con una línea, haga agujeros en ella:

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

Pensé que trataría de ver qué tan bien la solución GolfScript de Peter Taylor se portaría a Perl. Las características notables incluyen el uso de en sortlugar de reverseguardar tres caracteres, usando el hecho de que un espacio se clasifica antes _.

Lisp común, 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)))))

Me imagino que si el código Lisp logra superar cualquier conteo inicial para otro idioma (C, 219), estoy bien :)

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);}

Toma prestados un par de trucos de la respuesta de ugoren , pero la lógica central es bastante diferente. No pude seguir su ciclo for, por lo que es posible hibridar y guardar algunos más.

C, 219 193 179 143 136 131 caracteres

Seguí otra de las ideas de Petyer Taylor, más una mejora mía, ahorré 6 más.
Integró algunos consejos de @PeterTaylor, más copió su función principal, con ligeros cambios, que salvan a un personaje (¿es justo copiarlo? Dado que ninguno de nosotros ganará este, supongo que no está tan mal).
Pensé en una mejora significativa en cómo funciona mi recursión, y después de ver la respuesta de Peter Taylor, la implementé para recuperar el liderazgo. Al leer su respuesta nuevamente, vi que hice casi exactamente lo que él hizo. Así que esto parece la hibridación que sugirió.
También simplificó el bucle main, manteniendo la misma longitud.
Y tomó el truco de Peter para imprimir una nueva línea, en lugar de puts(""): guarda un personaje.

Eliminado intde la declaración de variables: una advertencia, pero guarda 4 caracteres.
El nuevo algoritmo no calcula 3 ^ x por adelantado, pero usa un solo bucle para imprimir 3 ^ x caracteres.
Puede guardar uno más definiendo int*v, pero 64 bits no funcionará.
El recuento de caracteres excluye los espacios en blanco (que se pueden eliminar).

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 anterior, 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&*,.])~|

Utiliza la iteración para construir el siguiente conjunto comenzando con 1 (que representa _) inicialmente.

Uso

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

Explicación

' _'{~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 139 137 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,,"")

Pruébalo en línea!

-15 bytes gracias también por el uso de Giuseppe '('como función de identidad; writeen lugar de catimprimir la salida; uso inteligente de %x%.

-2 bytes gracias a Kirill L. utilizando en clugar de '('como la función de identidad.

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

Función recursiva interna, luego cuide la salida hacia atrás si es necesario

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 golf

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`
}

Prueba

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%

Editar: Guardado 12 19 bytes gracias a @ l4m2. Se guardaron 8 bytes al eliminar la %a%variable innecesaria .

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):''}`

Pruébalo en línea!

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])

Pruébalo en línea!

Prólogo (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.

Pruébalo en línea!

Potencia Shell , 111 bytes

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

Pruébalo en línea!

Menos golfizado:

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{
        '_'
    }
}