Introducción:

Inspirado por este comentario de @MagicOctopusUrn en @Emigna respuesta 05AB1E 's para mi ' Fue sólo un error ' desafío :

8F9ÝÀNð×ý}».∊Lo hice hizo una nave espacial fauces! Y estaba muy entusiasmado por sugerir una edición de 12 bytes. - Urna de pulpo mágico Jul 17 '17 a las 20:10

Que es un programa 05AB1E (heredado) que resulta en esto:

1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890

Pruébalo en línea.

Reto:

Entrada: una cadena no vacía

Salida: desde afuera hacia adentro, agregue un espacio más entre cada carácter en cada línea, similar a como se hizo en la salida anterior, igual a length - 1. Entonces, para una entrada, 1234567890la salida en realidad sería esta:

1234567890
1 2 3 4 5 6 7 8 9 0
1  2  3  4  5  6  7  8  9  0
1   2   3   4   5   6   7   8   9   0
1    2    3    4    5    6    7    8    9    0
1     2     3     4     5     6     7     8     9     0
1      2      3      4      5      6      7      8      9      0
1       2       3       4       5       6       7       8       9       0
1        2        3        4        5        6        7        8        9        0
1         2         3         4         5         6         7         8         9         0
1        2        3        4        5        6        7        8        9        0 
1       2       3       4       5       6       7       8       9       0
1      2      3      4      5      6      7      8      9      0
1     2     3     4     5     6     7     8     9     0
1    2    3    4    5    6    7    8    9    0
1   2   3   4   5   6   7   8   9   0
1  2  3  4  5  6  7  8  9  0
1 2 3 4 5 6 7 8 9 0
1234567890

¿Por qué? La longitud de 1234567890es 10. Entonces comenzamos generando 10 líneas: la primera línea sin espacios; segundo con un delimitador de espacio; tercero con dos; etc. Y luego (sin tener la línea media con length - 1espacios duplicados), volvemos a la entrada inicial mientras bajamos.

Reglas de desafío:

• Se garantiza que la entrada no está vacía (una longitud >= 1). (Para las entradas de un solo carácter simplemente sacamos ese carácter).
• Se permite cualquier cantidad de espacios finales / iniciales / nuevas líneas, siempre que la salida en sí (en cualquier lugar de la pantalla) sea correcta. (Las líneas vacías entre las líneas de salida tampoco están permitidas).
• La entrada solo contendrá caracteres ASCII imprimibles, excluyendo espacios en blanco (rango de puntos de código [33, 126])
• I / O es flexible. La entrada puede tomarse como STDIN, argumento o parámetro de función. Puede ser una lista / matriz / secuencia de caracteres en lugar de una cadena. La salida también puede ser una lista / matriz / secuencia de caracteres en lugar de cadenas; puede imprimirse en STDOUT; devuelto como cadena delimitada por nueva línea; etc.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

Input: @
Output:
@

Input: test
Output:
test
t e s t
t  e  s  t
t   e   s   t
t  e  s  t
t e s t
test

Input: ?!
Output:
?!
? !
?!

Input: Spaceship
Output:
Spaceship
S p a c e s h i p
S  p  a  c  e  s  h  i  p
S   p   a   c   e   s   h   i   p
S    p    a    c    e    s    h    i    p
S     p     a     c     e     s     h     i     p
S      p      a      c      e      s      h      i      p
S       p       a       c       e       s       h       i       p
S        p        a        c        e        s        h        i        p
S       p       a       c       e       s       h       i       p
S      p      a      c      e      s      h      i      p
S     p     a     c     e     s     h     i     p
S    p    a    c    e    s    h    i    p
S   p   a   c   e   s   h   i   p
S  p  a  c  e  s  h  i  p
S p a c e s h i p
Spaceship

Input: 05AB1E
Output:
05AB1E
0 5 A B 1 E
0  5  A  B  1  E
0   5   A   B   1   E
0    5    A    B    1    E
0     5     A     B     1     E
0    5    A    B    1    E
0   5   A   B   1   E
0  5  A  B  1  E
0 5 A B 1 E
05AB1E

Input: )}/\
Output:
)}/\
) } / \
)  }  /  \
)   }   /   \
)  }  /  \
) } / \
)}/\

Japt , 8 6 bytes

Toma la entrada como una matriz de caracteres, emite una matriz de cadenas.

£qYçÃê

Intentalo

Explicación

£          :Map each element at (0-based) index Y
 q         :  Join input with
  Yç       :   Space repeated Y times
    Ã      :End Map
     ê     :Palindromise

Original, 8 bytes

I / O es una cadena. Usa la -Rbandera. Incluye espacios finales en cada línea.

¬£múYÄÃê

Intentalo

Explicación

             :Implicit input of string U
¬            :Split
 £           :Map each character at 0-based index Y
  m          :  Map original U
   ú         :    Right pad with spaces to length ...
    YÄ       :     Y+1
      Ã      :End map
       ê     :Palindromise
             :Implicitly join with newlines

R , 105 99 85 84 79 bytes

-6 gracias a @Kevin Cruissen y @Giuseppe

-14 de cambiar a un método basado en expresiones regulares

-1 gracias a @Giuseppe

-5 gracias a @digEmALl

function(w,n=nchar(w)-1)write(trimws(Map(gsub,"",strrep(" ",n-abs(n:-n)),w)),1)

Pruébalo en línea!

JavaScript (ES6), 53 bytes

Toma la entrada como una matriz de caracteres.

f=(s,p=i='',o=s.join(p)+`
`)=>s[++i]?o+f(s,p+' ')+o:o

Pruébalo en línea!

Carbón , 10 bytes

Ｅθ⪫θ× κ‖Ｏ↓

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

Ｅθ          Map over characters of input string
  ⪫θ        Join characters of input string using
    ×       a literal space repeated 
      κ     current index number of times
            Implicitly print each result on its own line
       ‖Ｏ↓  Reflect vertically with overlap

Lienzo , 8 bytes.

┐² ×＊］──

Pruébalo aquí!

los versión de 7 bytes era demasiado buena para este desafío.

Python 2 , 72 70 68 66 65 bytes

^{-2 bytes gracias a Kevin Cruijssen
-3 bytes gracias a ovs}

w=input();c=s=-1
while c:print(' '*~c).join(w);s*=w[:c]>'';c+=s|1

Pruébalo en línea!

05AB1E , 10 9 bytes

Guardado 1 bytes gracias a Adnan

εINð×ý}û»

Pruébalo en línea!

Explicación

ε            # apply to each in input
 I           # push the input
  Nð×        # push <index> spaces
     ý       # merge the input on the spaces
      }      # end loop
       û     # palendromize
        »    # join on newlines

Ruby , 54 49 bytes

->a{(-(z=a.size-1)..z).map{|i|a*(?\s*(z-i.abs))}}

Pruébalo en línea!

Toma la entrada como una matriz de caracteres, emite una matriz de cadenas.

Japt , 9 8 bytes

-1 byte de @Shaggy

ÊƬqXîÃê

ÊƬqXîÃê        Full program, implicity input U
ÊÆ              Rage from 0 to U length and map
  ¬             split U at ""
   qXîà     join U using " " times range current value
        ê       horizontal mirror

Pruébalo en línea!

PowerShell , 66 54 bytes

-12 bytes gracias a mazzy

0..($x=($a=$args).count-1)+$x..0|gu|%{$a-join(' '*$_)}

Pruébalo en línea!

Toma información a través de salpicaduras, que en TIO se manifiesta como argumentos de línea de comandos separados para cada personaje.

Primero establecemos $a=$argscomo argumento de entrada. Luego establecemos $xigual a la .countde esa matriz -1. Luego necesitamos recorrer las letras para construir la nave espacial. Eso se hace construyendo un rango de 0a $x, luego de $xregreso a 0, luego usandoGet-Unique para extraer solo el rango apropiado.

Cada iteración, tomamos nuestros argumentos de entrada y -joinlos juntamos con el número correspondiente de espacios. Cada una de esas cadenas se deja en la tubería, y un implícito Write-Outputnos da nuevas líneas de forma gratuita cuando se completa el programa.

05AB1E (heredado) , 9 bytes

εINúíJ}û»

Entrada como lista de caracteres.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ε     }    # Map each character in the input to:
 I         #  Take the input
  Nú       #  Prepend each with the 0-indexed amount of spaces
           #   i.e. ["t","e","s","t"] & 3 → ["   t","   e","   s","   t"]
    í      #  Reverse each item
           #   i.e. ["   t","   e","   s","   t"] → ["t   ","e   ","s   ","t   "]
     J     #  Join them together to a single string
           #   i.e. ["t   ","e   ","s   ","t   "] → "t   e   s   t   "
       û»  # Palindromize the list, and join by newlines
           #  i.e. ["test","t e s t ","t  e  s  t  ","t   e   s   t   "]
           #   → "test\nt e s t \nt  e  s  t  \nt   e   s   t   \nt  e  s  t  \nt e s t \ntest"

Haskell , 60 59 bytes

(init<>reverse).(scanl(?)<*>tail)
a?_=do u<-a;u:[' '|' '<u]

Pruébalo en línea!

Explicación

Para una cadena (p. Ej. "abc") Aplicamos primero

scanl (?) <*> tail

que es lo mismo que

\str -> scanl (?) str (tail str)

Esto se aplica repetidamente (?)(agrega un espacio a cada carácter en el rango [33 ..] ) strhasta que haya tantas cadenas como strcaracteres:["abc","a b c ", "a b c "]

Ahora solo necesitamos concatenar el resultado (menos el último elemento) con su contraparte invertida:

init<>reverse

MATL , 25 22 13 bytes

zZv"Gtz@he!1e

Pruébalo en línea!

¡Gracias a Luis Mendo por sugerir un golf de 5 bytes, que luego me inspiró a ahorrar 4 bytes más!

Explicación, con entrada de ejemplo 'abc':

         # Implicit input, 'abc'
z        # find number of nonzero elements (length of string)
         # stack: [3]
Zv       # symmetric range
         # stack: [[1 2 3 2 1]]
"        # begin for loop, iterating over [1 2 3 2 1] as the loop indices
G        # push input
         # stack: ['abc']
tz       # dup and push length
         # stack: ['abc', 3]
@        # push loop index, i (for example, 2)
         # stack: ['abc', 3, 2]
h        # horizontally concatenate
         # stack: ['abc', [3, 2]]
e!       # reshape to matrix of 3 rows and i columns, padding with spaces, and transpose
         # stack: [['abc';'   ';'   ']]
1e       # reshape to matrix of 1 row, leaving last value on stack
         # stack: ['a  b  c  ']
         # implicit end of for loop
         # implicit end of program, display stack contents

Jalea , 9 bytes

jⱮLḶ⁶ẋƲŒḄ

Pruébalo en línea!

Devuelve una lista de líneas; salida prettified sobre TIO.

Pyth , 12 bytes

Solo mi presentación obligatoria de Pyth. Estoy bastante orgulloso de esto, por lo que es probable que llegue pronto una explicación.

+P_=jRQ*L;_U

Pruébalo aquí!

+P_=jRQ_.e*d

Pruébalo aquí!

Stax , 10 bytes

Ç·9ƒù▌╘Ä┘e

Ejecutar y depurarlo

Salidas con espacios en blanco al final de cada línea.

Explicación:

%R|pmx{]n(m Full program, unpacked, implicit input
%           Length of input
 R          1-based range
  |p        Palindromize
    m       Map:
     x{   m   Map over characters of input:
       ]        Character -> string
        n(      Right-pad to length given by outer map value
              Implicit flatten and output

Java (JDK 10) , 115 bytes

s->{for(int l=s.length(),i=-l;++i<l;)System.out.printf(s.replaceAll(".","%-"+(i<0?l+i:l-i)+"s")+"%n",s.split(""));}

Pruébalo en línea!

• -2 bytes gracias a Kevin Cruijssen

K (oK) , 25 24 bytes

Solución:

,/'(1+a,1_|a:!#x)$\:+,x:

Pruébalo en línea!

Explicación:

Puerto de mi solución K4 :

,/'(1+a,1_|a:!#x)$\:+,x: / the solution
                      x: / save input as x
                     ,   / enlist
                    +    / flip
                 $\:     / pad ($) right by each-left (\:)
   (            )        / do this together
              #x         / count length of input,           e.g. 3
             !           / range 0..length,                 e.g. 0 1 2
           a:            / save as a
          |              / reverse it,                      e.g. 2 1 0
        1_               / drop first,                      e.g. 1 0
      a,                 / join to a,                       e.g. 0 1 2 1 0
    1+                   / add 1,                           e.g. 1 2 3 2 1
,/'                      / flatten (,/) each (')

Notas:

• -1 byte gracias a ngn

Pascal (FPC) , 143 135 bytes

var s:string;i,j,l:word;begin read(s);l:=length(s);repeat i:=i+1;for j:=1to l do write(s[j],'':l-abs(l-i)-1);writeln until i=l*2-1 end.

Pruébalo en línea!

Probablemente solo gane contra Lenguage ...

PHP, 88 89 bytes

for(;++$i<2*$e=count($a=str_split($argn));)echo join(str_pad("",~-$e-abs($i-$e)),$a),"\n";

requiere PHP 5 o posterior para str_split. Ejecutar como tubería con -nRo probarlo en línea .

K4 , 23 bytes

Solución:

,/'(1+a,1_|a:!#x)$\:$x:

Ejemplo:

q)k),/'(1+a,1_|a:!#x)$\:$x:"Spaceship"
"Spaceship"
"S p a c e s h i p "
"S  p  a  c  e  s  h  i  p  "
"S   p   a   c   e   s   h   i   p   "
"S    p    a    c    e    s    h    i    p    "
"S     p     a     c     e     s     h     i     p     "
"S      p      a      c      e      s      h      i      p      "
"S       p       a       c       e       s       h       i       p       "
"S        p        a        c        e        s        h        i        p        "
"S       p       a       c       e       s       h       i       p       "
"S      p      a      c      e      s      h      i      p      "
"S     p     a     c     e     s     h     i     p     "
"S    p    a    c    e    s    h    i    p    "
"S   p   a   c   e   s   h   i   p   "
"S  p  a  c  e  s  h  i  p  "
"S p a c e s h i p "
"Spaceship"

Explicación:

Tiene espacios en blanco al final de cada línea.

,/'(1+a,1_|a:!#x)$\:$x: / the solution
                     x: / save input as x,                 e.g. "abc"
                    $   / string,                          e.g. (,"a";,"b";,"c")
                 $\:    / pad ($) right by each-left (\:)
   (            )       / do this together
              #x        / count length of input,           e.g. 3
             !          / range 0..length,                 e.g. 0 1 2
           a:           / save as a
          |             / reverse it,                      e.g. 2 1 0
        1_              / drop first,                      e.g. 1 0
      a,                / join to a,                       e.g. 0 1 2 1 0
    1+                  / add 1,                           e.g. 1 2 3 2 1
,/'                     / flatten each

C #, 113 105 98 bytes

s=>{for(int l=s.Length,i=-l;++i<l;)WriteLine(Join("",s.Select(c=>$"{c}".PadRight(i<0?l+i:l-i))));}

Pruébalo en línea!

Scala , 82 bytes

for(i<-(0 to a.size)union(-a.size to 0))println(a.map(_+" "*Math.abs(i)).mkString)

Pruébalo en línea

¡Scala tiene muchos atajos que me están ayudando aquí y eso es bastante legible! Prueba Scala

Oracle SQL, 115 bytes

No es un lenguaje de golf pero ...

SELECT TRIM(REGEXP_REPLACE(v,'(.)',LPAD('\1',1+LENGTH(v)-ABS(LEVEL-LENGTH(v)))))FROM t CONNECT BY LEVEL<2*LENGTH(v)

Suponiendo que el valor está en la columna vde la tablat :

Violín de SQL

Configuración del esquema de Oracle 11g R2 :

CREATE TABLE t ( v ) AS
  SELECT 'test' FROM DUAL;

Consulta 1 :

SELECT TRIM(REGEXP_REPLACE(v,'(.)',LPAD('\1',1+LENGTH(v)-ABS(LEVEL-LENGTH(v)))))
FROM   t
CONNECT BY LEVEL<2*LENGTH(v)

Resultados :

(SQLFiddle imprime los valores alineados a la derecha en la columna por alguna razón ... no hay espacios iniciales)

| TRIM(REGEXP_REPLACE(V,'(.)',LPAD('\1',1+LENGTH(V)-ABS(LEVEL-LENGTH(V))))) |
|---------------------------------------------------------------------------|
|                                                                      test |
|                                                                   t e s t |
|                                                                t  e  s  t |
|                                                             t   e   s   t |
|                                                                t  e  s  t |
|                                                                   t e s t |
|                                                                      test |

Código de máquina 8086, 56 53 bytes

00000000  bf 35 01 57 ba 01 00 52  be 82 00 b3 ff ac 59 51  |.5.W...R......YQ|
00000010  aa 3c 0d 74 07 b0 20 e2  f7 43 eb f1 b0 0a aa 59  |.<.t.. ..C.....Y|
00000020  00 d1 e3 08 38 cb d6 08  c2 51 eb dc c6 05 24 5a  |....8....Q....$Z|
00000030  b4 09 cd 21 c3                                    |...!.|
00000035

Montado de:

org 0x100
use16
        mov di, buffer
        push di
        mov dx, 1
        push dx
nextl:  mov si, 0x82
        mov bl, -1
nextc:  lodsb
        pop cx
        push cx
stor:   stosb
        cmp al, 0x0d
        je cr
        mov al, ' '
        loop stor
        inc bx
        jmp nextc
cr:     mov al, 0x0a
        stosb
        pop cx
        add cl, dl
        jcxz done
        cmp bl, cl
        salc
        or dl, al
        push cx
        jmp nextl
done:   mov [di], byte '$'
        pop dx
        mov ah, 0x09
        int 0x21
        ret
buffer:

Caso de prueba:

Haskell, 64 60 59 bytes

(""#)
a#s|l<-(:a)=<<s,w<-' ':a=l:[x|w<(' '<$s),x<-w#s++[l]]

Pruébalo en línea!

a#s                         -- take a string of spaces 'a' and the input string 's'
 |l<-(:a)=<<s               -- let 'l' be the current line, i.e. the spaces in 'a'
                            -- appended to each char in 's'
  w<-' ':a                  -- let 'w' be 'a' with an additional space   
 =l                         -- return that 'l'
   :[   |w<(' '<$s)   ]     -- and, if 'w' is shorter than 's',
     x  ,x<-w#s++[l]        -- followed by a recursive call with 'w' 
                            -- and by another copy of 'l'

(""#)                       -- start with an empty 'a'

Bash , 115 , 109 , 105 , 100 , 97 , 96 , 92 , 91 , 90 bytes

-5 y -3 gracias a Kevin Cruissen

read s;for((c=f=1;f;c-=2*(f>=${#s}),f+=c))
{ printf '%-'${f}'.c' `grep -o .<<<"$s"`
echo
}

Pruébalo en línea!

Tenga en cuenta que dado que el \es un char salida al shell, el caso de prueba )}/\debe ser introducido con un extra de \la siguiente manera: )}/\\.

Perl 6 , 43 bytes

{(0....comb-1...0)>>.&{join ' 'x$^a,.comb}}

Pruébalo en línea!

Devuelve una lista de líneas.

Explicación:

 {                                         }  # Anonymous code block
  (0....comb-1...0) # A list from
   0                  # 0
    ...               # to
       .comb-1        # the length of the input string -1
              ...     # back to
                 0    # 0
                   >>.&{                  }  # Map each number to
                        join        ,.comb   # Join the list of characters
                             ' 'x$^a         # With the number of spaces

C (gcc) , 131 129 111 bytes

i;x;f(k,j)char*k,*j;{x=strlen(k)-1;for(i=0;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

Pruébalo en línea!

-20 bytes gracias a ceilingcat !

#import<string.h>
i;x;f(k,j)char*k,*j;{x=strlen(k)-1;for(i=0;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

Pruébalo en línea!

O, si la longitud se puede aceptar como parámetro:

C (gcc), 105 102 bytes

-1 byte gracias a ceilingcat!

i;x;f(k,x,j)char*k,*j;{for(i=!x--;i<x-~x;i+=puts(""))for(j=k;*j;)printf("%c%*s",*j++,i<x?i:2*x-i,"");}

Pruébalo en línea!

PHP, 148 146 143 141 Bytes

function s($s){for(;$i<strlen($s);++$i)f($i,$s);for(--$i;--$i>=0;)f($i,$s);}function f($i,$s){echo chunk_split($s,1,str_repeat(' ',$i))."
";}

Puedes probarlo así:

<?php
error_reporting(0);

$s = 1234567890;
function s($s){for(;$i<strlen($s);++$i)f($i,$s);for(--$i;--$i>=0;)f($i,$s);}function f($i,$s){echo chunk_split($s,1,str_repeat(' ',$i))."
";}

Salida

1234567890
1 2 3 4 5 6 7 8 9 0 
1  2  3  4  5  6  7  8  9  0  
1   2   3   4   5   6   7   8   9   0   
1    2    3    4    5    6    7    8    9    0    
1     2     3     4     5     6     7     8     9     0     
1      2      3      4      5      6      7      8      9      0      
1       2       3       4       5       6       7       8       9       0       
1        2        3        4        5        6        7        8        9        0        
1         2         3         4         5         6         7         8         9         0         
1        2        3        4        5        6        7        8        9        0        
1       2       3       4       5       6       7       8       9       0       
1      2      3      4      5      6      7      8      9      0      
1     2     3     4     5     6     7     8     9     0     
1    2    3    4    5    6    7    8    9    0    
1   2   3   4   5   6   7   8   9   0   
1  2  3  4  5  6  7  8  9  0  
1 2 3 4 5 6 7 8 9 0 
1234567890

Salvadera

Versión ampliada

 function s($s){
    //loop upwards 0-10
    for(;$i<strlen($s);++$i) f($i,$s);
     //decrement so it's odd, from 9 loop downwards to 0
    for(--$i;--$i>=0;)f($i,$s);
 }
 //2nd function to save space
 function f($i,$s){
     //chunk it, split 1 char, insert $i number of spaces
     echo chunk_split($s,1,str_repeat(' ',$i))."
";}

Intento 2, 92 bytes

Después de ver la respuesta de @Titus, reduje la mía a esto:

for(;++$i<2*$e=strlen($s=$argn);)echo chunk_split($s,1,str_repeat(' ',~-$e-abs($i-$e)))."
";

Estaba tratando de pensar en una forma de usar 1 bucle, en lugar de 2 ... Lo creas o no, casi nunca uso el for bucle en código "real". Era el~ bit a bit No, que me faltaba ...

Todavía es un poco más largo en 92 así que no me siento tan mal. Pero lo pondré como un segundo intento de todos modos.

$argn es la entrada de la línea de comando

Ejecutar como pipe con -nR o probarlo en línea.

Salvadera