Dado como entrada un entero positivo n>=1, genera las primeras nfilas del siguiente triángulo:

                  1
                1 0 1
              0 0 1 0 0
            1 1 1 0 1 1 1
          0 0 0 0 1 0 0 0 0
        1 1 1 1 1 0 1 1 1 1 1
      0 0 0 0 0 0 1 0 0 0 0 0 0
    1 1 1 1 1 1 1 0 1 1 1 1 1 1 1
  0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1

Las filas se alternan entre todos los ceros y todos, excepto que la columna central se voltea.

Casos de prueba

• Entrada :3

• Salida :

      1
    1 0 1
  0 0 1 0 0
  

• Entrada :10

• Salida :

                    1
                  1 0 1
                0 0 1 0 0
              1 1 1 0 1 1 1
            0 0 0 0 1 0 0 0 0
          1 1 1 1 1 0 1 1 1 1 1
        0 0 0 0 0 0 1 0 0 0 0 0 0
      1 1 1 1 1 1 1 0 1 1 1 1 1 1 1
    0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
  1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1
  

Su código debe funcionar para cualquiera n<100. Este es el código de golf , por lo tanto, gana el código más corto en bytes.

¡Se permiten espacios finales / líneas nuevas y líneas nuevas iniciales!

Jalea , 7 bytes

Ṭ=Ḃµ€ŒB

Pruébalo en línea!

-1 byte gracias a Erik the Outgolfer

Explicación

Ṭ=Ḃµ€ŒB  Main link
    €    For each element in (implicit range of) the input:
Ṭ        List 1s and 0s with 1s in the indices in the left argument (generates `[0, 0, ..., 1]`)
 =Ḃ      Is this equal to `(z % 2)` where `z` is the range number? (Every other row is flipped)
     ŒB  Reflect each row

Python 2 , 50 bytes

lambda n:[i*`i%2`+`~i%2`+i*`i%2`for i in range(n)]

Pruébalo en línea!

Esto devuelve las filas como una lista de cadenas.

Python 2 , 67 65 63 bytes (formateado)

n=input()
for i in range(n):k=i*`i%2`;print(n-i)*" "+k+`~i%2`+k

Pruébalo en línea!

Esto genera un espacio final en cada línea.

Jalea , 8 bytes

⁼€=ḂŒḄµ€

Pruébalo en línea!

-2 gracias a HyperNeutrino .

Python 2 , 50 bytes

lambda n:[[i%2]*i+[~i%2]+i*[i%2]for i in range(n)]

Pruébalo en línea!

Python 2 , 53 bytes

lambda n:[(([i%2]*i+[~i%2])*2)[:-1]for i in range(n)]

Pruébalo en línea!

Python 2 , 67 bytes

lambda n:[[[i%2,~i%2][j==i]for j in range(2*i+1)]for i in range(n)]

Pruébalo en línea!

Japt , 12 9 bytes

õÈÇ¥Y^uÃê

¡Pruébalo en línea!

Bastante triste en comparación con Jelly, pero Japt no tiene nada parecido, Ṭasí que debo conformarme con lo que tengo ...

Explicación

 õÈ   Ç   ¥ Y^ uà ê
UõXY{XoZ{Z==Y^Yu} ê}      Ungolfed
                          Implicit: U = input number
Uõ                        Create the range [1..U].    [1, 2, 3, 4]
  XY{              }      Map each item X and 0-index Y in this to
     Xo                     Create the range [0..X).  [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3]]
       Z{      }            Map each item Z in this to
         Z==Y                 Z is equal to Y         [[1], [0, 1], [0, 0, 1], [0, 0, 0, 1]]
             ^Yu              XORed with Y % 2.       [[1], [1, 0], [0, 0, 1], [1, 1, 1, 0]]
                  ê         Bounce.                   [[1],
                                                       [1, 0, 1],
                                                       [0, 0, 1, 0, 0],
                                                       [1, 1, 1, 0, 1, 1, 1]]
                          Implicit: output result of last expression

Mathematica, 77 bytes

Table[CellularAutomaton[51,{{1},0},#,{All,All}][[i]][[#-i+2;;-#+i-2]],{i,#}]&

¡Ningún árbol lo ha reducido a 48 bytes!

Mathematica, 48 bytes

#&@@@NestList[CellularAutomaton@51,{{1},0},#-1]&

Pyth , 14 bytes

¡Gracias a @Jakube por guardar 2 bytes!

ms_+Bm%d2d%hd2

Pruébalo aquí!

Pyth , 15 bytes

Muchas gracias a @Jakube por -1 byte

m++K*d]%d2%td2K

Pruébalo aquí

Pyth , 16 bytes

m++K*d`%d2`%td2K

Pruébalo aquí

R , 73 bytes

Gracias a Giuseppe! Buena atrapada.

n=scan();for(i in 1:n)cat(c(rep(" ",n-i),x<-rep(1-i%%2,i-1)),i%%2,x,"\n")

Pruébalo en línea!

R , 78 bytes

n=scan();for(i in 1:n)cat(x<-c(rep(" ",n-i),rep(1-i%%2,i-1)),i%%2,rev(x),"\n")

Pruébalo en línea!

R , 82 bytes

n=scan();for(i in 1:n){j=i%%2;x=c(rep(" ",n-i),rep(1-j,i-1));cat(x,j,rev(x),"\n")}

Pruébalo en línea!

R , 110 bytes - salida a stdout

m=matrix(x<-rep_len(0:1,n<-scan()),n,n-1);m[upper.tri(m,T)]=" ";for(i in 1:n)cat(rev(m[i,]),1-x[i],m[i,],"\n")

Pruébalo en línea!

R , 130 bytes: salida a un archivo

m=matrix(x<-rep_len(0:1,n<-scan()),n,n-1);m[upper.tri(m,T)]=" ";for(i in 1:n)cat(rev(m[i,]),1-x[i],m[i,],"\n",file="a",append=i>1)

Pruébalo en línea!

Escribir en un archivo ya que no sé cómo encajarlo en la consola si n==99(vea el resultado aquí ).

Pascal , 181 154 bytes

27 bytes guardados gracias a @ThePirateBay

procedure f(n:integer);var i,j:integer;begin for i:=1to n do begin write(' ':(n-i+1)*2);for j:=1to i*2-1do write((ord(j<>i)+i)mod 2,' ');writeln()end end;

Pruébalo en línea!

Sin pelar

procedure f (n: integer);
    var i, j: integer;
    begin
        for i := 1 to n do
        begin
            write(' ': (n-i+1) * 2);
            for j := 1 to i*2-1 do
                write((ord(j<>i) + i) mod 2, ' ')
            writeln()
        end
    end;

Retina , 25 bytes

.+
$*0
0
1$`¶
T`d`10`¶.*¶

Pruébalo en línea! Explicación: La primera etapa convierte la entrada en una cadena de ceros de esa longitud. La segunda etapa toma todos los prefijos de esa cadena (sin incluir la cadena en sí) y les asigna un 1 como prefijo. La tercera etapa alterna los bits en líneas alternas.

05AB1E , 24 21 18 bytes

FNÉN×NÈJûIN>-úˆ}¯»

Pruébalo en línea!

Editar: Bueno, es mi primer golf 05AB1E, así que no me sorprende que las cosas se puedan jugar al golf. Editar historial:

• 18 (ver arriba)
  • Así que no es un espejo se cruzan (ambos .∞yû ), lo que facilita las cosas mucho
  • Como hacer ÈyÉ hacer , 2%y 2%_mucho más corto
• 21: FN2%DN×Dr_sJIN>-úˆ}¯»
  • Cosas implícitas eliminadas: IF-> F, )J->J
  • baaa aabpuede ser hecho por .À(giratoria) , sino también por r(invirtiendo) (más corto)
• 24: IFN2%DN×D.À_s)JIN>-úˆ}¯»

Perl 5 , 58 + 1 (-n) = 59 bytes

say$"x(2*--$_).($/=$i%2 .$")x$i.(1-$i%2).$".$/x$i++while$_

Pruébalo en línea!

# Perl 5 , 59 + 1 (-n) = 60 bytes

say$"x(2*--$_).($i%2 .$")x$i.(1-$i%2).($".$i%2)x$i++while$_

Pruébalo en línea!

Mathematica, 90 bytes

Array[(x=Table[1,f=(2#-1)];x[[⌈f/2⌉]]=0;If[#==1,{1},If[OddQ@#,x/.{1->0,0->1},x]])&,#]&

SOGL V0.12 , 13 bytes

∫:2\r*Kr1κ+╥T

Pruébalo aquí!

Carbón , 18 bytes

ＥＮ⪫ＩＥ⁺¹ι﹪⁺ι¬λ² ‖Ｏ←

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

ＥＮ              For each of the input number of rows
  ⪫             Join with spaces
   Ｉ            Convert to string
    Ｅ⁺¹ι        For each column
        ﹪⁺ι¬λ²  Calculate the digit
‖Ｏ←             Reflect to the left

JavaScript, 140 132 bytes (con el formato adecuado)

n=>{A=Array;a='';b=0;for(x of A(n)){for(c of A(n-b))a+=' ';for(c of A(b))a+=b%2;a+=(b+1)%2;for(c of A(b))a+=b%2;a+='\n';b++}return a}

Pruébalo en línea

JavaScript (ES6) , 74 73 71 68 64 bytes

-7 bytes por @Neil

f=n=>n--?[...f(n), [...Array(n-~n)].map((v,i)=>(n+(i==n))%2)]:[]

Pruébalo en línea!

Función recursiva simple que genera las líneas una por una. Salidas como conjunto de conjunto de números.

Salidas como cadena formateada:

JavaScript (ES6) , 122 119 118 bytes

f=(n,w=2*n+1,N=n,s=" ".repeat((N-n)*2))=>(--n?f(n,w,N)+s+[...Array(n-~n)].map((v,i)=>(n+(i==n))%2).join(" "):s+1)+"\n"

Pruébalo en línea!

Haskell , 54 bytes

Comprensión directa de la lista:

f n=[k++[mod i 2]++k|i<-[1..n],k<-[mod(i+1)2<$[2..i]]]

Pruébalo en línea!

J, 32 bytes

3 :'-.^:(2|y)(=|.)i.>:+:y'&.>@i.

Pruébalo en línea!Esta es una función anónima que devuelve una lista de valores en recuadro.

Me gusta imaginar que la definición de función explícita ahorra bytes en virtud de eliminar mayúsculas y demás, pero probablemente agrega unos pocos bytes en comparación con una respuesta tácita.

Explicación

3 :'-.^:(2|y)(=|.)i.>:+:y'&.>@i.
                              i. For i = 0 ... input - 1
3 :'-.^:(2|y)(=|.)i.>:+:y'        Explicit function: compute nth row
                    >:+:y          2n+1
                  i.               Range [0,2n+1)
             (=|.)                 Equate range to reversed range
                                    (yield 0 0 0 ... 1 ... 0 0 0)
                                   If
                                    n = 1 (mod 2)
                                   Then
                                    Negate each value
                          &.>     Box

05AB1E , 11 bytes

FN°SRNF_}ûˆ

Pruébalo en línea!

Explicación

F             # for N in range [0 ... input-1] do:
 N°           # push 10^N
   S          # split to list of digits
    R         # reverse
     NF_}     # N times do: logical negation
         û    # palendromize
          ˆ   # add to global list
              # implicitly display global list

J , 17 bytes

(2&|~:0=i:)&.>@i.

Pruébalo en línea!

Emite una lista de matrices en caja.

Explicación

(2&|~:0=i:)&.>@i.  Input: n
               i.  Range from 0 to n, exclusive end
           & >     Unbox each and perform on each x
        i:           Range from -x to x, inclusive
      0=             Equal to 0
    ~:               Not equal
 2&|                 x mod 2
           &.>       Perform inverse of unbox (box)

Java 8, 121 111 109 101 bytes

n->{String r[]=new String[n],t;for(int i=0,j;i<n;r[i++]=t+i%2+t)for(j=0,t="";j++<i;t+=i%2);return r;}

Mi actual byte-score (101) también es una fila del triángulo binario. :)

Explicación:

Pruébalo aquí

n->{                         // Method with integer parameter and String-array return-type
  String r[]=new String[n],  //  Result String-array
         t;                  //  Temp String
  for(int i=0,j;             //  Some index-integers
      i<n;                   //  Loop (1) from 0 to `n` (exclusive)
      r[i++]=                //    After every iteration, set the next row to:
        t+                   //     `t` +
        i%2                  //     Center digit (`i` has already been raised by 1 now)
        +t)                  //     + `t` again
    for(j=0,t="";            //   Reset index `j` and the temp-String `t`
        j++<i;               //   Inner loop (2) from 0 to `i` (exclusive)
      t+=i%2                 //    Append `t` with an outer digit
    );                       //   End of inner loop (2)
                             //  End of loop (1) (implicit / single-line body)
  return r;                  //  Return resulting String-array
}                            // End of method

GolfScript , 49 bytes

~.:a;0\{..1+2%.!""+@*+" "a(:a*+.1>-1%\+"\n"+\)}*;

Pruébalo en línea!