Tạo một chương trình lấy từ bạn nhập và thêm từ đó vào mặt sau trừ đi chữ cái đầu tiên, sau đó lặp lại cho đến khi hết chữ cái. Ví dụ, catsẽ trở thành catatt, và hellosẽ trở thành helloellolloloo.

Nhập
bất kỳ trong số 26 chữ cái của bảng chữ cái tiếng Anh. Có thể có nhiều từ được phân tách bằng dấu cách và thay đổi sẽ được áp dụng cho mỗi từ.

Đầu ra
(các) từ được nhập, với mỗi từ được đặt sau chữ cái đầu tiên bị thiếu, và sau đó chữ cái thứ hai bị mất, và cứ như vậy cho đến khi không còn chữ cái nào để thêm.

Ví dụ khác:

ill eel đầu ra illlll eelell

laser bat đầu ra laserasersererr batatt

darth vader đầu ra dartharthrththh vaderaderdererr

Đây là mã golf, vì vậy mã ngắn nhất sẽ thắng.

Làm rõ:
Bạn có thể coi đầu vào hoặc đầu ra là một danh sách. Bạn có thể tách các từ bằng cách sử dụng dòng mới thay vì khoảng trắng. Bạn có thể thêm một không gian dấu vào đầu vào.

Japt -m, 6 3 byte

Đầu vào và đầu ra là mảng các từ.

£sY

Thử nó

Giải trình

        :For each word in the input array
£       :Map each letter at index Y
 sY     :  Slice the current word from index Y

Brainfuck , 60 56 byte

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

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

Yêu cầu một không gian dấu và in một không gian hàng đầu. Cả hai đều có thể bị phá vỡ, nhưng kết thúc ở mức 112 byte .

Giải trình

,[  Loop over each byte of input
  Tape: 32 w o r-32 d'
  >++++++++[-<----<++++>>]   Subtract 32 from the character and add 32 to the previous char
  Tape: 32 w o r d-32 0'
  <[>>]<   If the last character was a space
  Tape: 32 w o r d-32 0'
  or
  Tape: 32 w o r d' space-32
  [
    [<]>.   Move to the end of the word and print out the space
    [   Loop over each letter
      [-]    Remove the first letter (initially space)
      >[.>]  Print the rest of the word
      <[<]>  Move back to the first letter
    ]
    Tape: clear
  ]
,]  Get the next byte of input

Haskell, 36 21 byte

map$concat.scanr(:)""

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

Chỉnh sửa: -15 byte, vì định dạng IO mới (danh sách các từ thay vì các từ được phân tách bằng dấu cách)

Perl -p, 36 25 23 byte

s!\b|\S!$'=~s/ .*//r!eg

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

Đây là một regsub duy nhất. Đầu tiên, nó phù hợp với tất cả các ranh giới từ hoặc ký tự không phải không gian:

[][H][e][l][l][o] [][W][o][r][l][d]

Lưu ý rằng mỗi trận đấu này nên được thay thế bằng phần còn lại của từ:

[→Hello][H→ello][e→llo][l→lo][l→o][o→] (...)

Chúng ta có thể thực hiện điều này với biến đặc biệt $', lưu trữ một phần của chuỗi sau trận đấu. Tuy nhiên, chúng ta cần áp dụng regsub lồng nhau s/ .*//cho nó, loại bỏ mọi thứ vượt qua khoảng trắng đầu tiên $', để loại bỏ các từ còn lại trong đầu vào.

Cảm ơn @nwellnhof cho 2 byte.

Python 3 , 49 byte

d=lambda s:' '.join(n+d(n[1:])for n in s.split())

Dùng thử trực tuyến!

Điều này lợi dụng thực tế là "".split()trả về một mảng trống để đóng vai trò kiểm tra cho trường hợp cơ sở trong đệ quy.

Thạch , 3 byte

ḊƬ€

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

Không cần Ks nữa vì đầu vào / đầu ra mảng hiện đã được cho phép.

ḊƬ€
  €   For each word:
Ḋ       Remove the first letter
 Ƭ      until there are none left.

APL (Dyalog), 19 9 byte

{⌽∊,\⌽⍵}¨

cảm ơn @ H.PWiz đã chạy bộ não của tôi

Điều này hoạt động vì tất cả các chuỗi trong APL là mảng ký tự.

{⌽∊,\⌽⍵}¨ 
        ¨ - for each string
      ⍵} - string argument - ex. "hello"
     ⌽ - reverse - "olleh"
   ,\ - scan magic - "o" "ol" "oll" "olle" "olleh"
  ∊ - enlist(join together) "oolollolleolleh"
{⌽ - reverse - "helloellolloloo"

TIO

JavaScript (ES6), 33 byte

Đã lưu 1 byte nhờ @ShieruAsakoto

Định dạng I / O: mảng các từ.

a=>a.map(g=w=>w&&w+g(w.slice(1)))

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

JavaScript (ES6), 35 byte

Định dạng I / O: mảng các từ.

a=>a.map(w=>w.replace(/./g,"$&$'"))

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

R , 82 75 67 byte

write(sapply(x<-scan(,""),substring,1:(y=max(nchar(x))),y),1,y,,"")

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

Một số byte được lưu nhờ JayCe

Tách đầu ra với dòng mới.

Các sapply(...)biểu hiện tạo ra một vector ma trận / cột của chuỗi con phù hợp, đệm với ""khi cần thiết. writesau đó in các phần tử của ma trận, ytrên mỗi dòng, phân tách chúng bằng "".

Brainfuck , 94 93 byte

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

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

• Lưu một byte nhờ Nitrodon - chơi golf .[-]>[.>]<[<]>để [.>]<[<]>[-]>.

Giải trình

[[[ (dynamic) tape layout: ... NUL STR ... STR CHR FLG BUF SPC NUL ... ]]]

load a 32 into SPC
-[-[-<]>>+<]>-

while FLG
<<+[

 read a word
 [
  clear FLG; read CHR
  [-]<,
  copy CHR to BUF (using FLG as a temporary)
  [->+>+<<]>[-<+>]
  subtract SPC from BUF and save SPC
  >>[-<->>+<]
  move tape layout one to the right
  <
 ]

 strip trailing space; set FLG to true
 << [>>+<<[-]]
 to STR's first character
 <[<]>
 print word in all reduced forms
 [
  [.>]<[<]>[-]>
 ]

 print SPC; move to FLG
 >>>>.<<
]

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

Ghi công

Bộ sưu tập hằng số brainfuck của Esolang đã được sử dụng cho tải không gian ban đầu.

05AB1E , 5 byte

€.síJ

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

Giải trình

€.s        # push suffixes of each
   í       # reverse each
    J      # join suffixes

Vim , 47 byte (38 nét chính)

Bắt đầu với đầu vào của bạn là dòng duy nhất trong bộ đệm Vim.

:s/<Space>/\r/g<CR>ggqaywPlxqqb99@aj0q99@bgg99J

Giải trình

Điều này đặt mỗi từ trên dòng riêng của nó, lặp đi lặp lại trên mỗi dòng, sau đó nối lại tất cả chúng. Phá vỡ nếu các từ dài hơn 99 ký tự hoặc nếu đầu vào của bạn có nhiều hơn 99 từ.

1. :s/<Space>/\r/g<CR> thay thế khoảng trắng bằng dòng mới ( \r)
2. gg định vị con trỏ ở đầu dòng đầu tiên
3. qabắt đầu ghi macro a :
   • yw kéo dài phần còn lại của từ
   • P đặt nó phía sau con trỏ
   • lx xóa chữ cái đầu tiên của từ sau
   • qdừng ghi macro a
4. qbbắt đầu ghi macro b :
   • 99@athực thi macro một chín mươi chín lần (giới thiệu giới hạn ký tự)
   • j0 định vị con trỏ ở đầu dòng tiếp theo
   • qdừng ghi macro b
5. 99@bthực thi macro b chín mươi chín lần (giới thiệu từ giới hạn)
6. gg định vị con trỏ ở dòng đầu tiên
7. 99J nối chín mươi chín dòng sau với khoảng trắng (giới hạn từ một lần nữa)

Đối với 2 byte khác (2 nét chính), bạn có thể mở rộng giới hạn từ thành 999. Thêm 4 byte, 9999, v.v.

Husk , 6 4 byte

^{-2 byte nhờ Jonathan Allan (lấy đầu vào làm danh sách)!}

moΣṫ

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

Giải trình

Lấy đầu vào dưới dạng danh sách các chuỗi và ánh xạ chức năng sau:

Σṫ  -- example argument: "abc"
 ṫ  -- tails: ["abc","bc","c"]
Σ   -- concat: "abcbcc"

Võng mạc 0.8.2 , 15 byte

 
¶
.
$&$%'
¶
 

Hãy thử trực tuyến! Lưu ý: dấu cách. Giải trình:

 
¶

Chia trên không gian.

.
$&$%'

Nối hậu tố của nó vào mỗi chữ cái. Có %nghĩa là chúng ta chỉ có hậu tố của từ.

¶
 

Tham gia với không gian.

Pepe , 167 153 byte

REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree

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

Mã lắp ráp x86 16 bit, 24 byte

     47             inc    di
     B020           mov    al,20h
l1:  3806           cmp    [si],al
     7212           jb     l5 ;less means end of string
     7401           je     l2  ;equal means space was seen
     4F             dec    di ;overwrite extra space
l2:  E80300         call   l3
     46             inc    si ;move to next character in word
     75F1           jne    l1
l3:  56             push   si
l4:  3806           cmp    [si],al
     A4             movsb      ;copy character
     77FB           ja     l4  ;until either zero or space is seen
     5E             pop    si
l5:  C3             ret

Gọi với si = con trỏ đến chuỗi nguồn, di = con trỏ đến bộ đệm đầu ra.
Chuỗi nguồn yêu cầu một byte bằng 0 để kết thúc nó.
Mã này giống nhau ở 16- hoặc 32- hoặc 64 bit (si / di trở thành esi / edi hoặc rsi / rdi).
Mã 32 bit lớn hơn hai byte do cuộc gọi được mở rộng.
Mã 64 bit vẫn lớn hơn ba byte vì inc / dec của rsi / rdi thu hút tiền tố (nhưng nếu biết rằng chúng nằm trong không gian bộ nhớ 32 bit, thì chúng có thể lại là esi / edi để tránh hình phạt đó) .

MATL , 18 16 byte

"@gXH"HX@Jh)]0&h

Đầu vào là một mảng ô của các từ. Hãy thử trực tuyến!

Giải trình

"         % Implicit input: cell array of strings. For each cell
  @g      %   Push content of current cell, that is, a word
  XH      %   Copy into clipboard H
  "       %   For each letter
    H     %     Push word
    X@    %     Push iteration index
    Jh)   %     Index from that until the end into current word
  ]       %   End
  0       %   Push 0. Will be cast to char. Char(0) is displayed as space
  &h      %   Concatenate horizontally all elements so far. Implicit display

K4 / K (oK) , 9 byte

Giải pháp:

,/'(1_)\'

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

Giải trình:

,/'(1_)\' / the solution
        ' / apply to each
       \  / scan
   (  )   / do this together
    1_    / drop first
,/'       / flatten (,/) each (')

C ++ (tiếng kêu) , 174 byte

#include<map>
#include<string.h>
std::string r(std::string w){while(auto x=strchr(w.c_str(),32))return r(w.substr(0,x-w.c_str()))+" "+r(x+1);return w!=""?w+r(w.substr(1)):w;}

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

Đây là lần gửi đầu tiên của tôi và tôi không biết nếu trả về chuỗi thay vì in thì có ổn không :)

Stax , 3 byte

m|]

Chạy và gỡ lỗi nó

Giải trình:

m   Map over the lines
 |] Get all suffixes (suffices?)
    Implicit flatten and output

Than , 14 byte

⪫Ｅ⪪Ｓ ⭆ι✂ιμＬι¹ 

Hãy thử trực tuyến! Lưu ý: Không gian lưu trữ. Liên kết là phiên bản dài dòng của mã. Giải trình:

   Ｓ            Input string
  ⪪             Split on spaces
 Ｅ              Map over each word
      ι         Current word
     ⭆          Map over each character and join
        ι       Current word
         μ      Current index
           ι    Current word
          Ｌ     Length
            ¹   Literal 1
       ✂        Slice
⪫               Join with spaces
                Implicitly print

C (gcc) , 79 byte

f(s,t)char*s,*t;{for(;*s;printf("%.*s",*s^32?t?t-s:~0:1,s),s++)t=strchr(s,32);}

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

Pip -s , 11 byte

J_@>,#_Mq^s

Lấy danh sách các từ được phân tách bằng dấu cách từ stdin. Hãy thử trực tuyến!

Giải trình

             s is space (implicit)
        q    Read a line of stdin
         ^s  Split it on spaces
       M     Map this lambda function to each word:
 _            The word...
  @>          sliced starting at index...
    ,#_       range(len(word))
              This creates len(word) slices ["word" "ord" "rd" "d"]
J             Join those into a single string
             The resulting list of modified words is printed; the -s flag uses space
             as the separator

Ruby , 42 byte

->s{s.map{|a|(w=a.b).chars{a[0]='';w<<a}}}

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

Python 2 , 63 byte

lambda s:' '.join(map(g,s.split()))
g=lambda s:s and s+g(s[1:])

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

Canvas , 6 byte

±［±］⇵］

Hãy thử nó ở đây!

5 byte với định dạng đầu ra điên rồ

C #, 111 90 byte

b=>string.Join(" ",(b.Split(' ').Select(x=>string.Concat(x.Select((y, i)=>x.Substring(i))))))

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

Bằng cách thay đổi đầu vào và đầu ra thành mảng, tôi đã lưu một vài byte:

b=>b.Select(x=>string.Concat(x.Select((y,i)=>x.Substring(i)))).ToArray()

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

K (oK) , 17 13 byte

{,/|:'|,\|x}'

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

Tiền tố chức năng ẩn danh; Đầu vào được lấy dưới dạng danh sách các chuỗi, lần lượt là danh sách các ký tự.

Cảm ơn @streetster cho 4 byte.

Làm sao:

{,/|:'|,\|x}' //Main function, argument x → ("ill";"eel")
            ' // For each element of the argument
         |x}  // Flip it. x → ("lli";"lee")
       ,\     // Concatenate each element, keeping intermediates. x → (("l";"ll";"lli");("l";"le";"lee")
      |       // Flip it again. x → (("lli";"ll";"l");("lee";"le";"l"))
   |:'        // Now flip each element. x → (("ill";"ll";"l");("eel";"el";"l"))
{,/           // Concatenation scan. x → ("illlll";"eelell")

Lisp thông thường , 179 byte

(defun r(s)(cond((endp s)nil)((eql(first s)#\Space)(princ " ")(r(rest s)))(t(q s)(r(rest s)))))(defun q (l)(cond((eql(first l)#\Space)t)((endp l)t)(t(princ(first l))(q(rest l)))))

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

Đây là lần thử đầu tiên của tôi khi chơi gôn, mọi chỉnh sửa đều được chào đón

Lua , 70 byte

for i=1,#arg do x=arg[i]for i=1,#x do io.write(x:sub(i))end print()end

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

Giải trình

Các đối số trong Lua được lưu trữ trong bảng argbắt đầu từ chỉ mục 1. Toán tử đơn nguyên #trả về kích thước của bảng và hàm s:sub(a,b)trả về một chuỗi con dựa trên chuỗi sđược phân định bởi các số nguyên avà b, nếu b không được thông qua, nó sẽ trả về phần còn lại của chuỗi.

Tôi đã phải sử dụng io.write()thay vì print()để tránh ngắt dòng, và thêm print()vào cuối vì lý do ngược lại.