Girdiğiniz sözcüğü alan bir program yapın ve bu sözcüğü eksi ilk harfini ekleyerek arkasına ekler, ardından tüm harfler bitene kadar tekrar eder. Örneğin, catolur catattve helloolur helloellolloloo.

Giriş
İngiliz alfabesinin 26 harfinden herhangi biri. Boşluklarla ayrılmış birden fazla kelime olabilir ve değişiklik her kelimeye uygulanmalıdır.

Çıktı
(lar) Girilen sözcükler, her bir kelime ilk harfi eksikken, sonra ikinci harfi eksikken, sonradan eklenecek başka harf bulunmadığı sürece girilir.

Daha fazla örnek:

ill eel çıktılar illlll eelell

laser bat çıktılar laserasersererr batatt

darth vader çıktılar dartharthrththh vaderaderdererr

Bu kod golf, yani en kısa kod kazanır.

Açıklama:
Giriş veya çıkışları bir liste olarak ele alabilirsiniz. Kelimeleri boşluk yerine newline kullanarak ayırabilirsiniz. Girişe bir boşluk ekleyebilirsiniz.

Japt -m, 6 3 bayt

Giriş ve çıkış kelimelerin dizileridir.

£sY

Dene

açıklama

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

brainfuck , 60 56 bayt

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

Çevrimiçi deneyin!

Sonda bir boşluk gerektirir ve önde gelen bir alan yazdırır. Bunların her ikisi de atlanabilir, ancak bu 112 baytta sona erer .

açıklama

,[  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 bayt

map$concat.scanr(:)""

Çevrimiçi deneyin!

Düzenleme: -15 bayt, çünkü yeni IO formatı (boşlukla ayrılmış kelimeler yerine kelimelerin listesi)

Perl -p, 36 25 23 bayt

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

Çevrimiçi deneyin!

Bu tek bir regsub. İlk olarak, tüm kelime sınırları veya boşluk olmayan karakterlerle eşleşir:

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

Bu eşleşmelerin her birinin, kelimenin geri kalanıyla değiştirilmesi gerektiğini unutmayın:

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

Bunu $', dizgenin parçasını maçtan sonra depolayan özel değişkenle başarabiliriz . Ancak, girilen geri kalan sözcüklerden kurtulmak s/ .*//için ilk boşluğu geçmiş olan her şeyi ortadan kaldıran iç içe geçmiş regsub uygulamasına ihtiyacımız var $'.

@Nwellnhof 2 bayt için teşekkür ederiz .

Python 3 , 49 bayt

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

Çevrimiçi Deneyin!

Bu "".split(), özyinelemede temel durumun kontrolü olarak işlev görmesi için boş bir dizi döndürmesi gerçeğinden faydalanır .

Jöle , 3 bayt

ḊƬ€

Çevrimiçi deneyin!

KArtık diziye giriş / çıkışa izin verildiğinden s'ye ihtiyacınız yok.

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

APL (Dyalog), 19 9 bayt

{⌽∊,\⌽⍵}¨

Beynimi koşu için @ H.PWiz sayesinde

Bu çalışır, çünkü APL'deki tüm dizeler karakter dizileridir.

{⌽∊,\⌽⍵}¨ 
        ¨ - 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 bayt

@ShieruAsakoto ile 1 bayt kaydedildi

G / Ç formatı: sözcük dizisi.

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

Çevrimiçi deneyin!

JavaScript (ES6), 35 bayt

G / Ç formatı: sözcük dizisi.

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

Çevrimiçi deneyin!

R , 82 75 67 bayt

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

Çevrimiçi deneyin!

JayCe sayesinde birkaç bayt kurtarıldı

Çıktıyı yeni satırlarla ayırır.

sapply(...)İfade ile bir matris / sütunu uygun altdizgelerin vektör, dolgu oluşturur ""gerektiği gibi. writedaha sonra matris elemanlarını ysatır başına ayırarak ayırır "".

brainfuck , 94 93 bayt

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

Çevrimiçi deneyin!

• İçin bir byte sayesinde Kaydedilen Nitrodon - golf .[-]>[.>]<[<]>için [.>]<[<]>[-]>.

açıklama

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

Çevrimiçi deneyin!

atfetme

İlk uzay yükü için Esolang'ın brainfuck sabit koleksiyonu kullanıldı.

05AB1E , 5 bayt

€.síJ

Çevrimiçi deneyin!

açıklama

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

Vim , 47 bayt (38 tuş vuruşu)

Girişinize Vim arabelleğindeki tek satır olarak başlayın.

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

açıklama

Bu, her bir kelimeyi kendi satırına yerleştirir, her satırın üzerinde tekrar eder, sonra hepsini birleştirir. Kelimelerin 99 karakterden uzun olması veya girişinizde 99 kelimeden uzun olması durumunda kırılıyor.

1. :s/<Space>/\r/g<CR> yerini (yeni çizgilerle boşluk \r)
2. gg imleci ilk satırın başına getirir
3. qakaydetmeye başlar makro a :
   • yw kelimenin geri kalanını yanks
   • P imlecin arkasına koyar
   • lx İkinci kelimenin ilk harfini kaldırır.
   • qmakro kaydetmeyi durdurur a
4. qbmakro kayıt b başlar :
   • 99@aMakro yürütür a doksan dokuz kez (karakter sınırını tanıtır)
   • j0 imleci bir sonraki satırın başına getirir
   • qMakroyu kaydetmeyi durdurur b
5. 99@bmakro b'yi yürütür doksan dokuz kez çalıştırır (limit kelimesini tanıtır)
6. gg imleci ilk satıra yerleştirir
7. 99J katılır (daha kelime sınırı) Aşağıdaki doksan dokuz boşluklu çizgiler

Başka bir 2 bayt (2 tuş vuruşu) için, kelime sınırını 999'a kadar uzatabilirsiniz. Başka bir 4 bayt, 9999, vb.

Kabuğu , 6 4 bayt

^{Jonathan Allan sayesinde -2 bayt (liste olarak girdi alarak)!}

moΣṫ

Çevrimiçi deneyin!

açıklama

Dizelerin bir listesi olarak girdi alır ve aşağıdaki işlevi eşler:

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

Retina 0.8.2 , 15 bayt

 
¶
.
$&$%'
¶
 

Çevrimiçi deneyin! Not: arka boşluklar. Açıklama:

 
¶

Boşluklarda bölün.

.
$&$%'

Her harfe onun sonunu ekleyin. %Biz sadece kelimenin eki almak anlamına gelir.

¶
 

Boşluklara katılın.

Pepe , 167 153 bayt

REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree

Çevrimiçi deneyin!

16 bit x86 derleme kodu, 24 bayt

     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

Kaynak dizgeye si = pointer ile çağrı yapın, di = output buffer için pointer.
Kaynak dizgenin bitmesi için sıfır bayt gerekir.
Kod, 16 veya 32 veya 64 bitte aynıdır (si / di, esi / edi veya rsi / rdi olur).
32 bit kod, genişletilmiş arama nedeniyle iki bayt daha büyüktür.
64 bitlik kod üç bayt daha büyüktür, çünkü rsi / rdi'nin inc / dec değeri bir önek çeker (ancak 32 bitlik bellek alanı içinde oldukları biliniyorsa, bu cezadan kaçınmak için yeniden esi / edi olabilir) .

MATL , 18 16 bayt

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

Giriş, bir hücre dizisidir. Çevrimiçi deneyin!

açıklama

"         % 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 bayt

Çözüm:

,/'(1_)\'

Çevrimiçi deneyin!

Açıklama:

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

C ++ (clang) , 174 bayt

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

Çevrimiçi deneyin!

Bu benim ilk gönderim ve yazdırmak yerine dize döndürüp döndürmediğimi bilmiyordum :)

Stax , 3 bayt

m|]

Koş ve hata ayıkla

Açıklama:

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

Kömür , 14 bayt

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

Çevrimiçi deneyin! Not: Sondaki boşluk. Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

   Ｓ            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 bayt

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

Çevrimiçi deneyin!

Pip -s , 11 bayt

J_@>,#_Mq^s

Boşluktan ayrılmış kelimelerin listesini stdin'den alır. Çevrimiçi deneyin!

açıklama

             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 bayt

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

Çevrimiçi deneyin!

Python 2,63 bayt

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

Çevrimiçi deneyin!

Tuval , 6 bayt

±［±］⇵］

Burada dene!

Çılgın çıktı formatı ile 5 bayt

C #, 111 90 bayt

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

Çevrimiçi Deneyin!

Girişleri ve çıkışları dizilere değiştirerek birkaç bayt kurtardım:

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

Çevrimiçi Deneyin!

K (oK) , 17 13 bayt

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

Çevrimiçi deneyin!

Önek adsız işlevi; Giriş, sırayla karakter listeleri olan dizelerin bir listesi olarak alınır.

4 bayt için @ @ streetster teşekkürler.

Nasıl:

{,/|:'|,\|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")

Ortak Lisp , 179 bayt

(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)))))

Çevrimiçi deneyin!

Bu benim ilk golf denememdir herhangi bir düzenleme kabul edilir.

Lua , 70 bayt

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

Çevrimiçi deneyin!

açıklama

Lua'daki argümanlar argindeks 1'den başlayan tabloda saklanır. Unary operatörü #tablonun boyutunu s:sub(a,b)döndürür ve fonksiyon stamsayılarla sınırlandırılmış dizgeyi temel alan bir alt dizgeyi döndürür ave bb geçilmezse dizginin geri kalanını döndürür.

Satır kırılmasından kaçınmak io.write()yerine kullanmak zorunda kaldım ve sonunda bunun tersini print()ekledim print().