Animar encontrando o meio

10

Dada uma sequência não vazia, continue removendo o primeiro e o último caracteres até chegar a um ou dois caracteres.

Por exemplo, se a string foi abcde, seu programa deve imprimir:

abcde
 bcd
  c

No entanto, se fosse abcdef, deveria parar com dois caracteres:

abcdef
 bcde
  cd

Novas linhas à direita e espaços à direita no final de cada linha são opcionais. Você pode ter quantos quiser ou nenhum.

Casos de teste

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

Lembre-se de que isso é código-golfe , portanto o código com o menor número de bytes vence.

code-golf string Oliver Ni
fonte
A saída pode ser uma lista de seqüências de caracteres, em vez de imprimi-las?
Greg Martin
@GregMartin Sim.
Oliver Ni
11
Precisamos ter os espaços iniciais em cada linha?
ETHproductions
@ETHproductions Sim.
Oliver Ni
9
@Oliver Essa é uma informação importante, você deve incluí-lo no texto
Luis Mendo

Respostas:

11

V , 10 bytes

ò^llYpr $x

Experimente online!

Explicação:

ò^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
fonte
6

Python, 45 bytes

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

Emite recursivamente a string, além de uma nova linha, além dos espaços iniciais para a próxima linha, mais o resultado recursivo da string encurtada com um espaço extra no prefixo.

Se uma nova linha principal fosse permitida, poderíamos salvar um byte:

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

Compare com um programa (49 bytes em Python 2):

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

ES6 (Javascript), 47, 48., 43 bytes

EDIT: operador ternário substituído por &&, sequência de preenchimento prefixada pela nova linha. Obrigado @ Neil por um excelente conselho!

EDIT: incluiu o nome da função para a chamada recursiva, retirou um byte usando uma nova linha literal

Golfe

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

Teste

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
zepelim
fonte
11
Percebo que @xnor começa com pigual a uma nova linha e um espaço; talvez isso possa ajudá-lo também.
19416 Neil
11
Ah, e você também pode usar em s&&vez de s?...:''.
Neil
4

Python 2, 50 bytes

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

Função recursiva simples que continua encurtando a string até que ela desapareça.

Chamar como f ('string')

Resultado

string
 trin
  ri
ElPedro
fonte
4

Perl, 31 bytes

30 bytes de código + -psinalizador.

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

Para executá-lo: 

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

Explicações : O \Se .$corresponde ao primeiro e último caractere, (.+)ao meio e ( *)aos espaços à direita que são adicionados toda vez que removemos um caractere desde o início. Portanto, o regex remove um caractere do início, um do final e adiciona um espaço inicial de cada vez.

dada
fonte
4

Brainfuck , 67 bytes

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

Isso deve funcionar em todos os sabores do cérebro.

Experimente online!

Código não destruído:

# 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
    >[.>]
<]

Ainda deve haver alguns bytes para cortar aqui; Só recentemente comecei a usar brainfuck, então meu movimento do ponteiro é provavelmente muito ineficiente.

Aedan Smith
fonte
2

MATL , 9 bytes

tg!*YRPRc

Isso produz espaços à direita e novas linhas.

Experimente online!

Explicação

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
fonte
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

Recebe entrada em STDIN.

Neil
fonte
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;}

Ungolfed:

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
fonte
2

05AB1E , 8 bytes

Código:

ÐvNú,¦¨D

Explicação:

Ð          # 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

Usa a codificação CP-1252 . Experimente online!

Adnan
fonte
2

Haskell, 47 43 bytes

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

Experimente em Ideone . Saída é uma lista de cadeias que foi permitida nos comentários do desafio. Para imprimir, execute com em (putStr.unlines.f)vez de apenas f.

Editar: salvou 4 bytes depois de perceber que o espaço em branco à direita é permitido.

Prelude> (putStr.unlines.f)"codegolf"
codegolf
 odegol
  dego
   eg
               --(trailing whitespace)
Laikoni
fonte
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
fonte
1

GNU sed 24 Bytes

Inclui +2 para -rn

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

Imprime, substitui o primeiro caractere não espacial por um espaço e exclui o último caractere até que nada mude.

Riley
fonte
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;}

Assume que a entrada sé a std::stringe retorna o texto animado.

Ungolfed:

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
fonte
0

Vim - 14 pressionamentos de tecla

qqYp^r $x@qq@q


Explicação:

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

O Vim mata automaticamente a macro assim que ficarmos sem caracteres

BlackCap
fonte
0

Snap! - 16 blocos

Snap!

A saída é autocentrante. A 'espera' é para os humanos.

wyldstallyns
fonte
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: salve em um arquivo e ligue no 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
fonte
0

Mathematica, 71 bytes

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

animar-encontrar-o-meio

ngenisis
fonte