Problema

Inspirado en un desafío anterior haciendo algo similar

Dada una nsalida de entrada entera positiva, una forma que sigue este patrón:

entrada n=1:

* *
 *
* *

entrada n=2:

**  **
 ****
  **
 ****
**  **

entrada n=3:

***   ***
 *** ***
  *****
   ***
  *****
 *** ***
***   ***

y así...

Tiene estas propiedades:

n*2+1 líneas altas

los "brazos" son nanchos excepto cuando se fusionan

la línea central es nancha

si nes incluso las líneas arriba y abajo del centro son n*2anchas

si nes impar, las líneas arriba y abajo del centro son n*2-1anchas

Reglas

Nuevas líneas finales aceptadas
Se aplican lagunas estándar
Los bytes más cortos ganan
La salida puede imprimirse o una cadena o conjunto de cadenas

Ediciones

n=0 no necesita ser manejado
Espacios finales permitidos

code-golf string ascii-art LiefdeWen
fuente

2

¿Está bien si la salida tiene en 1lugar de *y en 0lugar de espacio?

JungHwan Min

¿Pueden nuestros patrones ser indexados en 0?

Leaky Nun

@JungHwanMin Lo permitiré pero entonces no puedes ganar, podría ser influido si eres el más votado.

LiefdeWen

@LeakyNun 0 Indexado está bien

LiefdeWen

9

Carbón , 13 12 bytes

Gracias a @ErikTheOutgolfer por un byte

ＦＮ«ＰX⁺*×*Ｉθ→

Pruébalo en línea!

Esta es mi primera respuesta al carbón, y estoy bastante seguro de que no está tan bien como podría ser, pero pensé que comenzaría en algún lado.

 ＦＮ«            # For input() (i in range(0,input()))
     Ｐ           # Print
       X          # In an 'X' shape
        ⁺*×*Ｉθ   # '*'+'*'*int(first_input)
               →  # Move the cursor right one

nmjcman101
fuente

Puedes usar Ｉpara -1.

Erik the Outgolfer

@EriktheOutgolfer ¡Sabía que tenía que haber una manera de hacerlo! ¡Gracias!

nmjcman101

Y sí, en realidad parece tan golfista como puede ser.

Erik the Outgolfer

@EriktheOutgolfer No fue antes de que vinieras de todos modos :)

nmjcman101

1

@thomasrutter Charcoal tiene su propia página de códigos personalizada con 256 bytes , donde cada uno de esos caracteres es 1 byte. Por lo tanto, no está codificado en ASCII, donde algunos de estos caracteres serían de hecho varios bytes. nmjcman101 +1 por cierto. Estaba probando mi primera respuesta de Carbón también ayer, pero realmente no funcionó en los pocos minutos que tenía antes de irme a casa del trabajo. Entonces me has superado. Aprendí algunas cosas de tu respuesta, así que gracias por eso.

Kevin Cruijssen

13

MATL , 16 bytes

EQXyG:Y+tP+g42*c

Pruébalo en línea!

Explicación

Considere la entrada 2como un ejemplo. El contenido de la pila se muestra con los más recientes a continuación.

EQ    % Implicitly input n. Push 2*n+1
      %   STACK: 5
Xy    % Identity matrix of that size
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1]
G:    % Push [1 2 ... n]
      %   STACK: [1 0 0 0 0;
                  0 1 0 0 0;
                  0 0 1 0 0;
                  0 0 0 1 0;
                  0 0 0 0 1],
                 [1 2]
Y+    % 2D convolution, extending size
      %   STACK: [1 2 0 0 0 0;
                  0 1 2 0 0 0;
                  0 0 1 2 0 0;
                  0 0 0 1 2 0;
                  0 0 0 0 1 2]
tP+   % Duplicate, flip vertically, add
      %   STACK: [1 2 0 0 2 1;
                  0 1 2 1 2 0;
                  0 0 1 4 0 0;
                  0 1 2 1 2 0;
                  1 2 0 0 1 2]
g     % Convert to logical
      %   STACK: [1 1 0 0 1 1;
                  0 1 1 1 1 0;
                  0 0 1 1 0 0;
                  0 1 1 1 1 0;
                  1 1 0 0 1 1]
42*   % Multiply by 42.
      %   STACK: [42 42  0  0 42 42;
                   0 42 42 42 42  0;
                   0  0 42 42  0  0;
                   0 42 42 42 42  0;
                  42 42  0  0 42 42]
c     % Convert to char. Char 42 is '*'. Char 0 is displayed as space
      %   STACK: ['**  **';
                  ' **** ';
                  '  **  ';
                  ' **** ';
                  '**  **']

Luis Mendo
fuente

Eres más rápido que yo ...

Leaky Nun

@LeakyNun Muy raramente :-)

Luis Mendo

Desearía que Jelly tuviera convolución 2D ... Tuve que agregar 0 en cada fila y luego aplicar la suma vectorizada ...

Leaky Nun

1

@LeakyNun Ya sabes lo que dicen sobre la convolución ...

Luis Mendo

1

@LuisMendo En mi corazón, eres el ganador por usar la convolución, trae tan buenos recuerdos.

LiefdeWen

9

Jalea , 15 bytes

Ḥ‘Ḷ⁶ẋ;€”*ẋ$»Ṛ$Y

Pruébalo en línea!

Erik el Outgolfer
fuente

Muy agradable. 8 bytes menos que yo.

Leaky Nun

@LeakyNun El enfoque directo ayuda bastante.

Erik the Outgolfer

Un enfoque muy agradable

Jonathan Allan

@JonathanAllan Sí, especialmente si aprendes »vectoriza ...

Erik the Outgolfer

1

Me gusta mucho tu nombre de usuario! Pero desearía que usaras "vi" o "vim" en su lugar, para que pudieras elegir "Erik the vi King" ... (fanático de Monty Python aquí ...)

Olivier Dulac

4

V , 18 17 bytes

Guardado un byte gracias al truco de entrada de @ DJMcMayhem.

Àé*ÄJÀälÀñ2ÙÀl2x>

Pruébalo en línea!

Explicación

Àé*ÄJÀäl

Esto inserta [n]*'*'+[n]*' '+[n]*'*'

        Àñ        ' [arg] times
          2Ù      ' Duplicate the current line down twice
            Àl    ' Move right [arg] times
              2x  ' Delete two characters
                > ' Indent this line one space

Cada iteración del bucle del búfer va

|**   ***

A

***   ***
 |** ***
***   ***

¿Dónde |está el cursor con un *debajo?

nmjcman101
fuente

Guau. Usted Waaay me outgolfed. ¡Buen trabajo! Algunos consejos: puede hacer en Àé*ÄJÀällugar de Àá*Àá Àá*, y puede hacerlo <M-c>, es decir ã(mnemotécnico: centro ) para moverse al centro de la línea, que es un byte más corto que Àl. Pruébalo en línea!

DJMcMayhem

@DJMcMayhem Estoy tratando de hablar contigo en diferentes lugares. Creo que voy a robar la primera sugerencia, pero los <M-c>descansos para números más altos

nmjcman101

3

05AB1E , 18 bytes

Å4bS{I·ƒDÂ~„ *èJ,À

Pruébalo en línea!

Explicación

Ejemplo para n=2

Å4                   # push a list of 4s with length as the input
                     # STACK: [4,4]
  b                  # convert each to binary
                     # STACK: [100, 100]
   S{                # split into digit list and sort
                     # STACK: [0, 0, 0, 0, 1, 1]
     I·ƒ             # input*2+1 times do
        D            # duplicate top of stack
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 0, 0, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
         Â~          # or each item in the duplicate with its reverse
                     # 1st iteration: [0, 0, 0, 0, 1, 1], [1, 1, 0, 0, 1, 1]
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], [0, 1, 1, 1, 1, 0]
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], [0, 0, 1, 1, 0, 0]
           „ *èJ     # use the resulting binary list to index into the string " *"
                     # 1st iteration: [0, 0, 0, 0, 1, 1], "**  **"
                     # 2nd iteration: [0, 0, 0, 1, 1, 0], " **** "
                     # 3rd iteration: [0, 0, 1, 1, 0, 0], "  **  "
                ,    # print
                 À   # rotate list left

Emigna
fuente

3

V , 23 bytes

Àé*ÄJÀälÀñÙãlxx>ñyHæGVp

Pruébalo en línea!

Hexdump:

00000000: c0e9 2ac4 4ac0 e46c c0f1 d9e3 6c78 783e  ..*.J..l....lxx>
00000010: f179 48e6 4756 70                        .yH.GVp

Por alguna razón, este desafío es significativamente más difícil en V que el anterior. Dado que nuestro enfoque general de n veces, crecer una 'x' no funcionará aquí, en su lugar construiremos la parte superior de la X, la copiaremos y voltearemos, luego uniremos las dos partes.

Explicación:

Àé*ÄJÀäl                " Insert ('*' * n) + (' ' * n) + ('*' * n) 
                        " The obvious way would be 'Àé*ÀÁ ÀÁ*', but this 
                        " non-obvious way saves us a byte
        Àñ      ñ       " 'n' times:
          Ù             "   Duplicate this line (below us)
           ãl           "   Move to the center of this line
             xx         "   Delete two characters
               >        "   And indent this line with one space.

Hacer la sangría al final del ciclo, nos permite aprovechar las terminaciones implícitas . Esto también crea convenientemente n + 1 líneas, que es exactamente la mitad superior de la 'X'. Digamos que la entrada fue 4. Entonces, en este punto, el búfer se ve así:

****    ****
 ****  ****
  ********
   ******
    ****

Y estamos en la última línea. Entonces, nosotros:

                yH      " Copy the whole buffer and move to the first line
                  æG    " Reverse every line
                    Vp  " And paste what we just copied *over* the current
                        " line, deleting it in the process

DJMcMayhem
fuente

Hice ãxxlo mismo al principio también, pero creo que se rompe para, por ejemplo, n = 8?

nmjcman101

@ nmjcman101 Ah, tienes razón. Está bien si lo hace ãl, o si sangra antes de centrar, pero eso en realidad no guarda ningún byte. Sin embargo, no entiendo por qué funciona para números más pequeños.

DJMcMayhem

3

C #, 139 130 115 bytes

-1 byte creando una cadena y llamando WriteLine, guardando así el cheque para la nueva línea.
-6 bytes gracias a Kevin y sus técnicas de golf maestro!
-2 bytes reemplazando n*3-ncon n*2.
-15 bytes después de que Kevin me indicó amablemente en la dirección correcta: puedo devolver la cadena en lugar de imprimirla, guardando así la llamada a System.Console.WriteLine(). Y algunos otros consejos también ...

n=>{var s="";for(int i,j=0;j<=n*2;j++,s+='\n')for(i=0;i<n*3;)s+=i>=j&i<j+n|i<=n*3-j-1&i++>=n*2-j?'*':' ';return s;}

Pruébalo en línea!

Sin golf:

class Program
{
    static void Main(string[] args)
    {
        System.Func<int, string> g = n =>
        {
            var s = "";
            for (int i, j = 0; j <= n*2; j++, s += '\n')
                for (i = 0; i < n*3;)
                    s += i >= j & i < j+n | i <= n*3-j-1 & i++ >= n*2-j ? '*' : ' ';
            return s;
        };

        System.Console.Write(f(1));
        System.Console.Write(f(2));
        System.Console.Write(f(3));
        System.Console.Write(f(5));
        System.Console.Write(f(8));

        System.Console.ReadKey();
    }
}

Simplemente itera a lo largo de las filas y columnas del espacio necesario para imprimir la X grande e imprime una '*'o una ' 'según la condición.

Charlie
fuente

1

+1! Algunas cosas pequeñas para jugar al golf. Todo &&puede ser &y ||puede ser |en este caso. for(int j=0;puede ser for(int j=0,i;y luego puede eliminar elint frente del ien el bucle interno. Además, después del primer cambio de &y |, también puede eliminar el i++interior del ciclo for y cambiar i==n*3-1?...a i++==n*3-1?....

Kevin Cruijssen

@KevinCruijssen muchas gracias! Cambié el bucle interno y ahora creo una cadena para poder llamar WriteLine, guardado solo 1 byte. Así que ahora no estoy seguro de qué hacer con tu último consejo.

Charlie

1

Por cierto, ¿por qué System.Console.WriteLine? Devolver la cadena: n=>{string s="";for(int i,j=0;j<n*2+1;j++,s+="\n")for(i=0;i<n*3;)s+=i>=j&i<j+n|i<=n*3-j-1&i++>n*2-j-1?'*':' ';return s;}es más corta [ 120 bytes ] (y también elimina los corchetes al poner todo dentro del bucle for. Aquí hay un enlace TIO para mostrar que funciona. Además, siéntase libre de agregar esto (o el suyo) Enlace TIO a su respuesta. :)

Kevin Cruijssen

1

@KevinCruijssen ¡No sabía que TIO podía manejar el código C #! Agregué el WriteLineen el código porque el OP me pidió que emitiera la X grande, no solo para devuelva , así que sentí que la salida de la X (llamando al WriteLinemétodo) debería ser parte del código. Sin embargo, todavía no estoy acostumbrado a las reglas del golf de código, y no sé qué licencias puedo tomar al escribir código. Acabo de ver que algunas de las otras respuestas aquí imprimen la X en el código, y algunas otras lo imprimen en el pie de página. ¿Cuál es el enfoque válido en este caso?

Charlie

1

Por lo general, se permite devolver una cadena y usar una función en lugar de un programa de manera predeterminada, a menos que se indique lo contrario. Además, en la pregunta dice "La salida puede imprimirse o una cadena o matriz de cadenas ", por lo que se permite devolver una cadena. :) Ah, y una última cosa que puedes jugar al golf: j<n*2+1puede ser j<=n*2. También he creado un puerto Java 8 de su respuesta con el mismo conteo de bytes, acreditando su sorprendente respuesta, por supuesto.

Kevin Cruijssen

3

Haskell , 88 87 86 bytes

-1 gracias a @Laikoni

(!)=replicate
x n=[zipWith max(reverse m)m|m<-[i!' '++n!'*'++(n*2-i)!' '|i<-[0..n*2]]]

Pruébalo en línea!

bartavelle
fuente

1

zipWith max m(reverse m)se puede acortar a zipWith max(reverse m)m. Esto es lo mismo que zipWith max=<<reverse$m, y luego se mpuede incluir: ¡ Pruébelo en línea!

Laikoni

2

Jalea , 24 23 16 bytes

Ḥ‘Ḷ⁸+þṬ+Ṛ$a”*o⁶Y

Pruébalo en línea!

Monja permeable
fuente

2

MATLAB, 153126 bytes (17.6% ↓)

Gracias a @ comentario de LuisMendo, la función de disp()caracteres de salida puede sin comillas simples, por lo que podría evitar el uso fprintfcon formatsy omitir unos pocos bytes. Además, su comentario me recuerda que necesito usar char(32)para presentar un espacio en lugar de char(0)(nulo).

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=10
disp([a+32 ''])

Pruébalo en línea!

MATLAB, 153 bytes

n=input('')
r=2*n+1
c=3*n
a=0
for i=0:n-1 
a=a+[zeros(r,i),diag(1:r),zeros(r,c-r-i)];
end
a((a+flipud(a))>0)=42
fprintf([repmat('%c',1,c),'\n'],char(a)')

Ejemplo de resultado: n = 10

**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********

Guoyang Qin
fuente

2

Python 2 , 93 90 89 83 bytes

^{-3 bytes gracias a Leaky Nun}
^{-1 byte gracias a Zachary T}
^{-6 bytes gracias a xnor}

n=input()
x=n*'*'+n*'  '
exec"print`map(max,x,x[::-1])`[2::5];x=' '+x[:-1];"*(n-~n)

[¡Pruébalo en línea!] [TIO-j3xwsktf]

Comienza con una cadena como '*** 'for n=3, aplicando map/maxpara seleccionar los *espacios para cada posición, luego agrega un espacio y elimina el último carácter de la cadena y vuelve a hacer todo esto.

varilla
fuente

90 bytes

Leaky Nun

¿No puedes reemplazar n*2*' 'con n*' '?

Zacharý

El map(maxpuede hacerse directamente sin un zip. Además, n*2+1es n-~n.

xnor

1

Haskell , 70 bytes

f n=[[last$' ':['*'|y<-[1..n],(c-n-y)^2==r^2]|c<-[1..3*n]]|r<-[-n..n]]

Pruébalo en línea!

Emite una lista de cadenas.

Para cada posición de fila r, columna c, utiliza una fórmula para determinar si cae en una de las dos bandas diagonales y así es *.

xnor
fuente

1

Java 8, 119 118 bytes

n->{String r="";for(int i=0,j;i<=n*2;i++,r+="\n")for(j=0;j<n*3;r+=j>=i&j<i+n|j<=n*3-i-1&j++>=n*2-i?"*":" ");return r;}

Port de la sorprendente respuesta C # de @CarlosAlejo , después de que lo ayudé a jugar al golf algunas cosas. ¡Así que asegúrate de votarlo también!

Pruébalo aquí

Kevin Cruijssen
fuente

1

Javascript (ES2017), 155 157 bytes

n=>[...e=[...Array(n+1)].map((a,i)=>[...d=((b=''.padEnd(n))[c='slice'](i)+'*'.repeat(n)+b[c](0,i))[c](n/2)].reverse().join``+d[c](n%1)),...e.reverse()[c](1)]

Devuelve una matriz de cadenas. Realizo operaciones en matrices y luego lo reflejo. Esto probablemente podría optimizarse con matrices como las otras respuestas, pero quería ser único.

Editar: como señaló Neil, para los valores pares de n, la línea central no era nancha, por lo que agregué un módulo para detectar pares / impares al cortar la columna.

n=5
['*****     *****',
 ' *****   ***** ',
 '  ***** *****  ',
 '   *********   ',
 '    *******    ',
 '     *****     ',
 '    *******    ',
 '   *********   ',
 '  ***** *****  ',
 ' *****   ***** ',
 '*****     *****']

Sin golf

n => {
  e = [...Array(n+1)].map((a, i) => {   // Create and iterate over array with n+1 elements
    b = ''.padEnd(n)                    // String of n spaces
    d = (b.slice(i) + '*'.repeat(n) + b.slice(0, i)).slice(n/2) // Create row string
    return [...d].reverse().join`` + d.slice(1) // Mirror and combine row horizontally
  })
  return [...e,...e.reverse().slice(1)] // Mirror and combine vertically
}

Cuadrante

n=5
   *****
  ***** 
 *****  
*****   
****    
***

Reflejado horizontalmente

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****

Reflejado verticalmente

n=5
*****     *****
 *****   ***** 
  ***** *****  
   *********   
    *******    
     *****     
    *******    
   *********   
  ***** *****  
 *****   ***** 
*****     *****

andrewarchi
fuente

Esto produce una salida incorrecta para pares n: la línea central no es nancha.

Neil

0

Mathematica, 148 bytes

T=Table;(a=Join[T[T["*",i],{i,(n=#)+2,2n,2}],T[Join[t=T["*",n],T[" ",y],t],{y,1,n,2}]];Column[Row/@Join[Reverse@a,{T["*",n]},a],Alignment->Center])&

J42161217
fuente

0

R, 102 bytes

Código:

n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)

Prueba:

> n=scan();x=matrix(" ",M<-3*n,N<-2*n+1);for(i in 1:N)x[c(i-1+1:n,M+2-i-1:n),i]="*";cat(x,sep="",fill=M)
1: 10
2: 
Read 1 item
**********          **********
 **********        ********** 
  **********      **********  
   **********    **********   
    **********  **********    
     ********************     
      ******************      
       ****************       
        **************        
         ************         
          **********          
         ************         
        **************        
       ****************       
      ******************      
     ********************     
    **********  **********    
   **********    **********   
  **********      **********  
 **********        ********** 
**********          **********

djhurio
fuente

0

CJam, 24 bytes

{:T2*){S*T'**+}%_W%..e>}

Este es un bloque que toma un número de la pila y genera una lista de líneas en la pila.

Explicación:

{                        e# Stack:           | 2
 :T                      e# Store in T:      | 2, T=2
   2*                    e# Multiply by 2:   | 4
     )                   e# Increment:       | 5
      {                  e# Map over range:  | [0
       S                 e#   Push space:    | [0 " "
        *                e#   Repeat string: | [""
         T               e#   Push T:        | ["" 2
          '*             e#   Push char '*': | ["" 2 '*
            *            e#   Repeat char:   | ["" "**"
             +           e#   Concatenate:   | ["**"
              }%         e# End:             | ["**" " **" "  **" "   **" "    **"]
                _        e# Duplicate:       | ["**" " **" "  **" "   **" "    **"] ["**" " **" "  **" "   **" "    **"]
                 W%      e# Reverse:         | ["**" " **" "  **" "   **" "    **"] ["    **" "   **" "  **" " **" "**"]
                   ..e>  e# Overlay:         | ["**  **" " ****" "  **" " ****" "**  **"]
                       } e# End

Fruta Esolanging
fuente

0

Python 2 , 110 bytes

x=a=0
n=c=input()
while x<2*n+1:
    print ' '*a+'*'*n+' '*c+'*'*(2*n-2*a-c)
    x+=1
    a=n-abs(n-x)
    c=max(0, n-2*a)

Este programa divide cada línea en 4 partes, primeros espacios, primeras estrellas, segundos espacios y luego segundas estrellas. Para cada línea horizontal de la X, calcula cuántas estrellas o espacios se necesitan para cada una de las 4 secciones de la línea, luego construye e imprime esa cadena.

jacoblaw
fuente

0

Retina , 144 bytes

.+
 $&$* $&$* $&
 
$`#$'¶
¶\d+$

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1
( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3
+` (# +#)
$1 
+` #...
#
##

Pruébalo en línea! Explicación:

.+
 $&$* $&$* $&

Agregue 2n + 1 espacios antes del valor de entrada (uno para cada línea de salida).

$`#$'¶

Reemplaza cada espacio con a #y recoge los resultados. Esto proporciona una línea diagonal de #s, espacio acolchado en ambos lados, con el valor de entrada con sufijo.

¶\d+$

Elimine el valor de entrada original, ya que ahora tenemos una copia en cada línea.

( *)#( *)(\d+)
$1$3$**$2#$3$* #$2$3$**$1

Construya dos líneas diagonales de n *s, con una columna separadora de nespacios envueltos en un par de #s.

( +)(\*+)( *)(# +#)\3\2\3 +
$3$2$1$4$1$2$3

En esas líneas donde las *s están más cerca del medio, intercambia las dos mitades. Esto le da un aspecto parecido > | | <.

+` (# +#)
$1

Mueva los | |s tan a la izquierda como sea posible, dando una especie de >> > <apariencia.

+` #...
#

Para cada espacio entre los #s, elimine los tres caracteres siguientes. Esto une el > <en un X.

##

Eliminar el ahora innecesario #s.

Neil
fuente

Dibuja un gran ASCII X

Problema

Reglas

Ediciones

Respuestas:

Carbón , 13 12 bytes

MATL , 16 bytes

Explicación

Jalea , 15 bytes

V , 18 17 bytes

05AB1E , 18 bytes

V , 23 bytes

C #, 139 130 115 bytes

Haskell , 88 87 86 bytes

Jalea , 24 23 16 bytes

MATLAB, 153126 bytes (17.6% ↓)

MATLAB, 153 bytes

Python 2 , 93 90 89 83 bytes

Haskell , 70 bytes

Java 8, 119 118 bytes

Javascript (ES2017), 155 157 bytes

Mathematica, 148 bytes

R, 102 bytes

CJam, 24 bytes

Explicación:

Python 2 , 110 bytes

Retina , 144 bytes