10

Dada una cadena no vacía, siga eliminando el primer y último carácter hasta llegar a uno o dos caracteres.

Por ejemplo, si la cadena era abcde, su programa debería imprimir:

abcde
 bcd
  c

Sin embargo, si lo fuera abcdef, debería detenerse en dos caracteres:

abcdef
 bcde
  cd

Las líneas nuevas y los espacios finales al final de cada línea son opcionales. Puedes tener tantos como quieras o ninguno.

Casos de prueba

ABCDEFGHIJKLMNOPQRSTUVWXYZ -> ABCDEFGHIJKLMNOPQRSTUVWXYZ
                               BCDEFGHIJKLMNOPQRSTUVWXY 
                                CDEFGHIJKLMNOPQRSTUVWX  
                                 DEFGHIJKLMNOPQRSTUVW   
                                  EFGHIJKLMNOPQRSTUV    
                                   FGHIJKLMNOPQRSTU     
                                    GHIJKLMNOPQRST      
                                     HIJKLMNOPQRS       
                                      IJKLMNOPQR        
                                       JKLMNOPQ         
                                        KLMNOP          
                                         LMNO           
                                          MN            

ABCDEFGHIJKLMNOPQRSTUVWXYZ! -> ABCDEFGHIJKLMNOPQRSTUVWXYZ!
                                BCDEFGHIJKLMNOPQRSTUVWXYZ 
                                 CDEFGHIJKLMNOPQRSTUVWXY  
                                  DEFGHIJKLMNOPQRSTUVWX   
                                   EFGHIJKLMNOPQRSTUVW    
                                    FGHIJKLMNOPQRSTUV     
                                     GHIJKLMNOPQRSTU      
                                      HIJKLMNOPQRST       
                                       IJKLMNOPQRS        
                                        JKLMNOPQR         
                                         KLMNOPQ          
                                          LMNOP           
                                           MNO            
                                            N             

A -> A

AB -> AB

Recuerde que esto es code-golf , por lo que gana el código con el menor número de bytes.

code-golf string

— Oliver Ni
fuente

¿Puede la salida ser una lista de cadenas, en lugar de imprimir las cadenas?

— Greg Martin

@GregMartin Sí.

— Oliver Ni

1

¿Necesitamos tener los espacios iniciales en cada línea?

— ETHproductions

@ETHproductions Sí.

— Oliver Ni

99

@Oliver Esa es información importante, debe incluirla en el texto

— Luis Mendo

11

V , 10 bytes

ò^llYpr $x

Pruébalo en línea!

Explicación:

ò^ll         " While there are at least two non-whitespace characters on the current line
    Y        " Yank this line
     p       " Paste it below
      r      " Replace the first character with a space
        $    " Move to the end of the line
         x   " Delete a character

— James
fuente

6

Python, 45 bytes

f=lambda s,p='\n ':s and s+p+f(s[1:-1],p+' ')

Emite recursivamente la cadena, más una nueva línea, más los espacios iniciales para la siguiente línea, más el resultado recursivo para la cadena acortada con un espacio adicional en el prefijo.

Si se permitiera una nueva línea principal, podríamos guardar un byte:

f=lambda s,p='\n':s and p+s+f(s[1:-1],p+' ')

Compare con un programa (49 bytes en Python 2):

s=input();p=''
while s:print p+s;s=s[1:-1];p+=' '

— xnor
fuente

6

ES6 (Javascript), 47, 48, 43 bytes

EDITAR: operador ternario reemplazado con &&, cadena de relleno prefijada con la nueva línea. Gracias @Neil por un excelente consejo!

EDITAR: incluyó el nombre de la función para la invocación recursiva, eliminó un byte usando una nueva línea literal

Golfed

R=(s,p=`
 `)=>s&&s+p+R(s.slice(1,-1),p+' ')

Prueba

R=(s,p=`
 `)=>s&&s+p+R(s.slice(1,-1),p+' ')

console.log(R("ABCDEFGHIJKLMNOPQRSTUVWXYZ"))

ABCDEFGHIJKLMNOPQRSTUVWXYZ
 BCDEFGHIJKLMNOPQRSTUVWXY
  CDEFGHIJKLMNOPQRSTUVWX
   DEFGHIJKLMNOPQRSTUVW
    EFGHIJKLMNOPQRSTUV
     FGHIJKLMNOPQRSTU
      GHIJKLMNOPQRST
       HIJKLMNOPQRS
        IJKLMNOPQR
         JKLMNOPQ
          KLMNOP
           LMNO
            MN

console.log(R("ABCDEFGHIJKLMNOPQRSTUVWXYZ!"))

ABCDEFGHIJKLMNOPQRSTUVWXYZ!
 BCDEFGHIJKLMNOPQRSTUVWXYZ
  CDEFGHIJKLMNOPQRSTUVWXY
   DEFGHIJKLMNOPQRSTUVWX
    EFGHIJKLMNOPQRSTUVW
     FGHIJKLMNOPQRSTUV
      GHIJKLMNOPQRSTU
       HIJKLMNOPQRST
        IJKLMNOPQRS
         JKLMNOPQR
          KLMNOPQ
           LMNOP
            MNO
             N

— zepelín
fuente

1

Noto que @xnor comienza con pigual a una nueva línea y un espacio; tal vez eso también te pueda ayudar.

— Neil

1

Ah, y también puedes usar en s&&lugar de s?...:''.

— Neil

4

Python 2, 50 bytes

def f(i,j=0):
 print' '*j+i
 if i:f(i[1:-1],j+1)

Función recursiva simple que sigue acortando la cadena hasta que desaparece.

Llamar como f ('cadena')

Salida

string
 trin
  ri

— ElPedro
fuente

4

Perl, 31 bytes

30 bytes de código + -pbandera.

s/( *)\S(.+).$/$& 
 $1$2/&&redo

Para ejecutarlo:

perl -pE 's/( *)\S(.+).$/$&
 $1$2/&&redo' <<< "abcdef"

Explicaciones : El \Sy .$corresponde al primer y último carácter, (.+)el medio y ( *)los espacios finales que se agregan cada vez que eliminamos un carácter desde el principio. Por lo tanto, la expresión regular elimina un carácter desde el principio, uno desde el final y agrega un espacio inicial cada vez.

— Dada
fuente

4

Brainfuck , 67 bytes

>>,[.>,]<[>++++++++++.<[-]<[<]>[-]++++++++[-<++++>]<[<]>[.>]>[.>]<]

Esto debería funcionar en todos los sabores de brainfuck.

Pruébalo en línea!

Código sin golf:

# Print and read input_string into memory
>>,[.>,]<
while input_string is not empty [
    # Print newline
    >+++++ +++++.<
    # Remove last character
    [-]
    # GOTO start of input_string
    <[<]>
    # Remove first character
    [-]
    # Add space to space_buffer
    +++++ +++[-<++++>]
    # GOTO start of space_buffer
    <[<]>
    # Print space_buffer
    [.>]
    # Print input_string
    >[.>]
<]

Todavía debería haber algunos bytes para cortar aquí; Hace poco comencé a usar brainfuck, por lo que el movimiento de mi puntero probablemente sea muy ineficiente.

— Aedan Smith
fuente

2

MATL , 9 bytes

tg!*YRPRc

Esto produce espacios finales y líneas nuevas.

Pruébalo en línea!

Explicación

t      % Input string implicitly. Duplicate
g!     % Convert to logical and transpose: gives a column vector of ones
*      % Multiply with broadcast. This gives a square matrix with the string's
       % ASCII codes on each row
YR     % Lower triangular part: make elements above the diagonal 0
P      % Flip vertically
R      % Upper triangular part: make elements below the diagonal 0
c      % Convert to char. Implicitly display, with char 0 shown as space

— Luis Mendo
fuente

2

Lote, 92 bytes

@set/ps=
@set t=
:g
@echo %t%%s%
@set t= %t%
@set s=%s:~1,-1%
@if not "%s%"=="" goto g

Toma entrada en STDIN.

— Neil
fuente

2

C, 73 bytes

f(char*s){char*b=s,*e=s+strlen(s)-1;while(e-b>-1)puts(s),*b++=32,*e--=0;}

Sin golf:

f(char*s) {
  char *b=s,
       *e=s+strlen(s)-1;
  while (e-b>-1)
    puts(s),
    *b++=32,
    *e--=0;
}

Uso:

main(){
  char a[] = "abcde";
  f(a);
}

— Karl Napf
fuente

2

05AB1E , 8 bytes

Código:

ÐvNú,¦¨D

Explicación:

Ð          # Triplicate the input
 v         # Length times do...
  Nú,      # Prepend N spaces and print with a newline
     ¦¨    # Remove the first and the last character
       D   # Duplicate that string

Utiliza la codificación CP-1252 . Pruébalo en línea!

— Adnan
fuente

2

Pyke, 10 bytes

VQlRc
l7tO

Pruébalo aquí!

— Azul
fuente

2

Haskell, 47 43 bytes

f s@(a:b:c)=s:map(' ':)(f.init$b:c)
f s=[s]

Pruébalo en Ideone . La salida es una lista de cadenas que se permitió en los comentarios del desafío. Para imprimir, ejecute con en (putStr.unlines.f)lugar de solo f.

Editar: guardado 4 bytes después de notar que se permite el espacio en blanco al final.

Prelude> (putStr.unlines.f)"codegolf"
codegolf
 odegol
  dego
   eg
               --(trailing whitespace)

— Laikoni
fuente

2

Perl 6 , 42 bytes

for get,{S/\w(.*)./ $0/}.../\s..?$/ {.put}

Expandido:

for

  # generate the sequence
  get,       # get a line from the input

  {          # bare block lambda with implicit parameter ｢$_｣
             # used to produce the rest of the sequence

    S/       # replace
      \w     # a word character ( to be removed )
      (      # set ｢$0｣
        .*   # any number of any characters
      )
      .      # any character ( to be removed )
    / $0/    # append a space

  }

  ...        # repeat that until

  /          # match
    \s       # whitespace
    .        # any character
    .?       # optional any character
    $        # end of string
  /

{
  .put       # print $_ with trailing newline
}

— Brad Gilbert b2gills
fuente

1

GNU sed 24 Bytes

Incluye +2 para -rn

:
p
s/[^ ](.+)./ \1/
t

Imprime, reemplaza el primer carácter no espacial con un espacio y elimina el último carácter hasta que nada cambie.

— Riley
fuente

0

Retina , 17 bytes

;{G:`
\S(.+).
 $1

Pruébalo en línea!

— Martin Ender
fuente

0

C ++ 14, 117 bytes

auto f(auto s){decltype(s)r;auto b=s.begin();auto e=s.rbegin();while(e.base()-b>0)r+=s+"\n",*b++=32,*e++=0;return r;}

Asume que la entrada ses a std::stringy devuelve el texto animado.

Sin golf:

auto f(auto s){
  decltype(s)r;
  auto b=s.begin();
  auto e=s.rbegin();
  while(e.base()-b>0){
    r+=s+"\n";
    *b++=32;
    *e++=0;
  }
  return r;
}

Uso:

main(){
  std::string a{"abcdef"};
  std::cout << f(a);
  std::string b{"abcde"};
  std::cout << f(b);
}

— Karl Napf
fuente

0

Vim - 14 pulsaciones de teclas

qqYp^r $x@qq@q

Explicación:

qq  -- record a macro named 'q'
Y   -- Copy current line
p   -- Paste it
^r  -- Replace the first non-space character on the new line with a space
$x  -- Delete the last character on the line
@q  -- Recursively call the 'q' macro
q   -- Stop recording the 'q' macro
@q  -- Run the 'q' macro

Vim mata automáticamente la macro una vez que nos quedamos sin personajes

— Alondra
fuente

0

¡Chasquido! - 16 bloques

¡Chasquido!

La salida es autocentrante. La "espera" es para los humanos.

— wyldstallyns
fuente

0

PHP, 91 bytes

<?for(;$i<.5*$l=strlen($s=$_GET[s]);$i++)echo str_pad(substr($s,$i,$l-$i*2),$l," ",2)."\n";

Uso: guardar en un archivo y llamar desde el navegador:

http://localhost/codegolf/string-middle.php?s=ABCDEFGHIJKLMNOPQRSTUVWXYZ

Raw output:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
 BCDEFGHIJKLMNOPQRSTUVWXY 
  CDEFGHIJKLMNOPQRSTUVWX  
   DEFGHIJKLMNOPQRSTUVW   
    EFGHIJKLMNOPQRSTUV    
     FGHIJKLMNOPQRSTU     
      GHIJKLMNOPQRST      
       HIJKLMNOPQRS       
        IJKLMNOPQR        
         JKLMNOPQ         
          KLMNOP          
           LMNO           
            MN            


http://localhost/codegolf/string-middle.php?s=1ABCDEFGHIJKLMNOPQRSTUVWXYZ

Raw output:
1ABCDEFGHIJKLMNOPQRSTUVWXYZ
 ABCDEFGHIJKLMNOPQRSTUVWXY 
  BCDEFGHIJKLMNOPQRSTUVWX  
   CDEFGHIJKLMNOPQRSTUVW   
    DEFGHIJKLMNOPQRSTUV    
     EFGHIJKLMNOPQRSTU     
      FGHIJKLMNOPQRST      
       GHIJKLMNOPQRS       
        HIJKLMNOPQR        
         IJKLMNOPQ         
          JKLMNOP          
           KLMNO           
            LMN            
             M

— Mario
fuente

0

Mathematica, 71 bytes

Table[#~StringTake~{i,-i},{i,Ceiling[StringLength@#/2]}]~Column~Center&

— ngenisis
fuente

Animar a encontrar el medio

Casos de prueba

V , 10 bytes

Python, 45 bytes

ES6 (Javascript), 47, 48, 43 bytes

Python 2, 50 bytes

Perl, 31 bytes

Brainfuck , 67 bytes

Código sin golf:

MATL , 9 bytes

Explicación

Lote, 92 bytes

C, 73 bytes

05AB1E , 8 bytes

Pyke, 10 bytes

Haskell, 47 43 bytes

Perl 6 , 42 bytes

Expandido:

GNU sed 24 Bytes

Retina , 17 bytes

C ++ 14, 117 bytes

Vim - 14 pulsaciones de teclas

PHP, 91 bytes