Animate tìm giữa

10

Đưa ra một chuỗi không trống, tiếp tục xóa các ký tự đầu tiên và cuối cùng cho đến khi bạn nhận được một hoặc hai ký tự.

Ví dụ: nếu chuỗi là abcde, chương trình của bạn sẽ in:

abcde
 bcd
  c

Tuy nhiên, nếu có abcdef, nó nên dừng ở hai ký tự:

abcdef
 bcde
  cd

Trailing newlines và trailing space ở cuối mỗi dòng là tùy chọn. Bạn có thể có nhiều như bạn muốn hoặc không có.

Các trường hợp thử nghiệm

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

Hãy nhớ rằng đây là mã golf , vì vậy mã có số byte nhỏ nhất sẽ thắng.

code-golf  string 
— Oliver Ni
nguồn
Đầu ra có thể là một danh sách các chuỗi, thay vì in các chuỗi?
— Greg Martin
@GregMartin Có.
— Oliver Ni
1
Chúng ta có cần phải có không gian hàng đầu trên mỗi dòng không?
— Sản xuất ETH
@ETHproductions Có.
— Oliver Ni
9
@Oliver Đó là thông tin quan trọng, bạn nên đưa nó vào văn bản
— Luis Mendo

Câu trả lời:

11

V , 10 byte

ò^llYpr $x

Hãy thử trực tuyến!

Giải trình:

ò^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
nguồn
6

Python, 45 byte

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

Đệ quy đầu ra chuỗi, cộng với một dòng mới, cộng với các khoảng trắng hàng đầu cho dòng tiếp theo, cộng với kết quả đệ quy cho chuỗi rút ngắn có thêm khoảng trắng trong tiền tố.

Nếu một dòng mới hàng đầu được cho phép, chúng ta có thể lưu một byte:

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

So sánh với một chương trình (49 byte trong Python 2):

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

ES6 (Javascript), 47, 48, 43 byte

EDIT: Toán tử ternary thay thế bằng &&, chuỗi đệm có tiền tố với dòng mới. Cảm ơn @Neil vì một lời khuyên tuyệt vời!

EDIT: bao gồm tên hàm cho lệnh gọi đệ quy, loại bỏ một byte bằng cách sử dụng một dòng mới bằng chữ

Chơi gôn

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

Kiểm tra

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
nguồn
1
Tôi nhận thấy rằng @xnor bắt đầu pbằng với một dòng mới và khoảng trắng ; có lẽ điều đó cũng có thể giúp bạn
— Neil
1
Oh, và bạn cũng có thể sử dụng s&&thay vì s?...:''.
— Neil
4

Python 2, 50 byte

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

Hàm đệ quy đơn giản giúp tiếp tục rút ngắn chuỗi cho đến khi nó biến mất.

Gọi dưới dạng f ('chuỗi')

Đầu ra

string
 trin
  ri
— ElPedro
nguồn
4

Perl, 31 byte

30 byte mã + -pcờ.

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

Để chạy nó: 

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

Giải thích : Các \Svà .$tương ứng với ký tự đầu tiên và cuối cùng, (.+)giữa và ( *)các khoảng trắng ở cuối được thêm vào mỗi khi chúng ta xóa một ký tự từ đầu. Vì vậy, regex loại bỏ một ký tự từ đầu, một ký tự từ cuối và thêm một khoảng trắng hàng đầu mỗi lần.

— Dada
nguồn
4

Brainfuck , 67 byte

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

Điều này sẽ làm việc trên tất cả các hương vị brainfuck.

Hãy thử trực tuyến!

Mã bị đánh cắp:

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

Vẫn nên có một số byte để cắt ở đây; Gần đây tôi mới bắt đầu sử dụng brainfuck, vì vậy chuyển động con trỏ của tôi có lẽ rất kém hiệu quả.

— Aedan Smith
nguồn
2

MATL , 9 byte

tg!*YRPRc

Điều này tạo ra không gian dấu và dòng mới.

Hãy thử trực tuyến!

Giải trình

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
nguồn
2

Mẻ, 92 byte

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

Đưa đầu vào vào STDIN.

— Neil
nguồn
2

C, 73 byte

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

Ung dung:

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

Sử dụng:

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

05AB1E , 8 byte

Mã số:

ÐvNú,¦¨D

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

— Nam bộ
nguồn
2

Haskell, 47 43 byte

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

Hãy thử nó trên Ideone . Đầu ra là một danh sách các chuỗi được cho phép trong các nhận xét về thử thách. Để in, chạy với (putStr.unlines.f)thay vì chỉ f.

Chỉnh sửa: Đã lưu 4 byte sau khi nhận thấy khoảng trắng theo dõi được cho phép.

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

Perl 6 , 42 byte

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

Mở rộng:

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
nguồn
1

GNU sed 24 byte

Bao gồm +2 cho -rn

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

In, thay thế ký tự không phải không gian đầu tiên bằng dấu cách và xóa ký tự cuối cùng cho đến khi không có gì thay đổi.

— Riley
nguồn
0

C ++ 14, 117 byte

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

Giả sử đầu vào slà một std::stringvà trả về văn bản hoạt hình.

Ung dung:

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

Sử dụng:

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

Vim - 14 tổ hợp phím

qqYp^r $x@qq@q


Giải trình:

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 tự động giết macro khi chúng ta hết ký tự

— Chim bông lau
nguồn
0

Chộp lấy! - 16 khối

Chộp lấy!

Đầu ra là tự định tâm. 'Chờ đợi' là dành cho con người.

— wyldstallyns
nguồn
0

PHP, 91 byte

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

Cách sử dụng: lưu trong tệp và gọi từ trình duyệt:

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
nguồn
0

Toán học, 71 byte

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

animate-find-the-middle

— ngenisis
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.