Animer trouver le milieu

10

Étant donné une chaîne non vide, continuez de supprimer les premier et dernier caractères jusqu'à ce que vous obteniez un ou deux caractères.

Par exemple, si la chaîne était abcde, votre programme devrait afficher:

abcde
 bcd
  c

Si tel était le cas abcdef, il devrait s'arrêter à deux caractères:

abcdef
 bcde
  cd

Les sauts de ligne et les espaces de fin à la fin de chaque ligne sont facultatifs. Vous pouvez en avoir autant que vous le souhaitez ou pas du tout.

Cas de test

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

N'oubliez pas qu'il s'agit de code-golf , donc le code avec le plus petit nombre d'octets l'emporte.

code-golf  string 
— Oliver Ni
source
La sortie peut-elle être une liste de chaînes, au lieu d'imprimer les chaînes?
— Greg Martin
@GregMartin Oui.
— Oliver Ni
1
Avons-nous besoin d'avoir les espaces de tête sur chaque ligne?
— ETHproductions
@ETHproductions Oui.
— Oliver Ni
9
@Oliver Ce sont des informations importantes, vous devez les inclure dans le texte
— Luis Mendo

Réponses:

11

V , 10 octets

ò^llYpr $x

Essayez-le en ligne!

Explication:

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

Python, 45 octets

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

Génère récursivement la chaîne, plus une nouvelle ligne, plus les espaces de tête pour la ligne suivante, plus le résultat récursif de la chaîne raccourcie avec un espace supplémentaire dans le préfixe.

Si une nouvelle ligne de tête était autorisée, nous pourrions enregistrer un octet:

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

Comparer avec un programme (49 octets en Python 2):

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

ES6 (Javascript), 47, 48, 43 octets

EDIT: Opérateur ternaire remplacé par &&, chaîne de remplissage préfixée par la nouvelle ligne. Merci @Neil pour un excellent conseil!

EDIT: inclus le nom de la fonction pour l'invocation récursive, supprimé un octet en utilisant une nouvelle ligne littérale

Golfé

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

Tester

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
— Zeppelin
source
1
Je remarque que @xnor commence par pégal à une nouvelle ligne et un espace; peut-être que cela pourrait aussi vous aider.
— Neil
1
Oh, et vous pouvez également utiliser s&&au lieu de s?...:''.
— Neil
4

Python 2, 50 octets

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

Fonction récursive simple qui continue de raccourcir la chaîne jusqu'à ce qu'elle disparaisse.

Appeler comme f ('chaîne')

Production

string
 trin
  ri
— ElPedro
source
4

Perl, 31 octets

30 octets de code + -pindicateur.

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

Pour l'exécuter: 

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

Explications : le \Set .$correspond au premier et au dernier caractère, (.+)au milieu et ( *)aux espaces de fin qui sont ajoutés chaque fois que nous supprimons un caractère du début. Ainsi, l'expression régulière supprime un caractère du début, un de la fin et ajoute un espace de tête à chaque fois.

— Dada
source
4

Brainfuck , 67 octets

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

Cela devrait fonctionner sur toutes les saveurs de cerveau.

Essayez-le en ligne!

Code non 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
    >[.>]
<]

Il devrait encore y avoir quelques octets à couper ici; Je n'ai commencé à utiliser brainfuck que récemment, donc mon mouvement de pointeur est probablement très inefficace.

— Aedan Smith
source
2

MATL , 9 octets

tg!*YRPRc

Cela produit des espaces de fin et des nouvelles lignes.

Essayez-le en ligne!

Explication

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

Lot, 92 octets

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

Prend entrée sur STDIN.

— Neil
source
2

C, 73 octets

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

Non golfé:

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

Usage:

main(){
  char a[] = "abcde";
  f(a);
}
— Karl Napf
source
2

05AB1E , 8 octets

Code:

ÐvNú,¦¨D

Explication:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne!

— Adnan
source
2

Haskell, 47 43 octets

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

Essayez-le sur Ideone . La sortie est une liste de chaînes autorisée dans les commentaires du défi. Pour imprimer, exécutez avec (putStr.unlines.f)au lieu de juste f.

Modifier: enregistré 4 octets après avoir remarqué que les espaces de fin sont autorisés.

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

Perl 6 , 42 octets

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

Étendu:

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
source
1

GNU sed 24 octets

Comprend +2 pour -rn

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

Imprime, remplace le premier caractère non espace par un espace et supprime le dernier caractère jusqu'à ce que rien ne change.

— Riley
source
0

C ++ 14, 117 octets

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

Suppose que l'entrée sest un std::stringet renvoie le texte animé.

Non 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;
}

Usage:

main(){
  std::string a{"abcdef"};
  std::cout << f(a);
  std::string b{"abcde"};
  std::cout << f(b);
}
— Karl Napf
source
0

Vim - 14 frappes

qqYp^r $x@qq@q


Explication:

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 tue automatiquement la macro une fois que nous n'avons plus de caractères

— BlackCap
source
0

Casser! - 16 blocs

Casser!

La sortie est auto-centrée. L'attente est pour les humains.

— wyldstallyns
source
0

PHP, 91 octets

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

Utilisation: enregistrez dans un fichier et appelez depuis le navigateur:

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

Mathematica, 71 octets

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

animer-trouver-le-milieu

— ngenisis
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.