Tantangan ogl-edocf

22

Memasukkan

String acak non-kosong yang terdiri dari karakter ASCII dalam kisaran .[32..126]

Keluaran

Output diperoleh dengan menerapkan rotasi berturut-turut ke string input.

Untuk setiap huruf ( [a-zA-Z]) dalam string input, dari kiri ke kanan:

  • jika huruf dalam huruf besar, putar semua karakter sebelum itu dengan satu posisi ke kiri
  • jika huruf dalam huruf kecil, putar semua karakter sebelum itu dengan satu posisi ke kanan

Contoh

Input: "Iklan Cb"

  • Huruf pertama adalah " C ". Kita harus melakukan rotasi ke kiri, tetapi tidak ada karakter sebelum " C " ini. Jadi, tidak ada yang berputar.
  • Huruf berikutnya adalah " b ". Kami memutar " C " ke kanan. Karena itu karakter tunggal, tidak berubah.
  • Karakter " - " tidak memicu rotasi apa pun, karena ini bukan huruf.
  • Huruf berikutnya adalah " A ". Kami memutar " Cb- " ke kiri, yang memberi " bC Ad"
  • Huruf keempat dan terakhir adalah " d ". Kami memutar " b-CA " ke kanan, yang menghasilkan " Ab-C d"

Oleh karena itu, output yang diharapkan adalah " Ab-Cd ".

Aturan

  • Anda dapat mengambil input sebagai string atau sebagai array karakter - yang mungkin atau mungkin tidak sama, tergantung pada bahasa Anda.
  • Anda juga dapat menampilkan array karakter alih-alih string.
  • Ini adalah

Uji kasus

"cbad" -> "abcd"
"ACBD" -> "ABCD"
"Cb-Ad" -> "Ab-Cd"
"caeBDF" -> "aBcDeF"
"aEcbDF" -> "abcDEF"
"ogl-edocf" -> "code-golf"
"W o,ollelrHd!" -> "Hello, World!"
"ti HIs SSta ET!" -> "tHis IS a tEST!"
Arnauld
sumber

Jawaban:

5

Pyth, 21 20 byte

VQ=k+.>k-}NG}Nr1GN)k

Coba di sini

Penjelasan

VQ=k+.>k-}NG}Nr1GN)k
VQ                )      For each N in the input...
     .>k                 ... rotate k (initially '')...
        -}NG}Nr1G        ... by (N is lowercase) - (N is uppercase)...
    +            N       ... then append N...
  =k                     ... and update k.
                   k     Output the result.

sumber
Anda dapat menggunakan .Uuntuk mengurangi input dari nilai 2. Ini memungkinkan Anda melepaskan =kdari awal, dan )kdari akhir karena input dan pencetakan tersirat. Program lengkap: .U+.>b-}ZG}Zr1GZ- tautan
Sok
4

Python 2 , 100 98 95 byte

f=lambda s,p='':s and f(s[1:],[p[x:]+p[:x]+s[0]for x in[s[0].isupper()-s[0].islower()]][0])or p

Cobalah online!

TFeld
sumber
3

Jelly , 14 byte

ØẠŒHċ€ḅ-N⁸ṙ;ð/

Tautan monadik yang menerima daftar karakter yang menghasilkan daftar karakter.

Cobalah online! Atau lihat test-suite .

Bagaimana?

ØẠŒHċ€ḅ-N⁸ṙ;ð/ - Link - list of characters
             / - reduce by:
            ð  -   a dyadic chain:  1st call is f(L=1stCharacter, R=2ndCharacter)
               -                    ...then calls are f(L=previousResult, R=nextCharacter)
ØẠ             -     alphabet characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
  ŒH           -     split in half = ["ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz"]
     €         -     for each:
    ċ          -       count occurrences (of R)
               -                          e.g.: 'W' -> [1,0]; 'c' -> [0,1]; '@' -> [0,0]
      ḅ-       -     convert from base -1             -1             1             0
        N      -     negate                            1            -1             0
         ⁸     -     chain's left argument (i.e. L)
          ṙ    -     rotate left by (the negate result)
           ;   -     concatenate R
Jonathan Allan
sumber
Saya tidak terlalu mengenal Jelly, tetapi tidak harus Imelakukan hal yang sama seperti ḅ-dalam kasus ini? Tampaknya berfungsi di sini , tetapi tidak dalam kode Anda. Saya agak bingung kenapa. Juga, apakah ada perintah untuk mendorong seluruh daftar sebagai item yang terpisah ke tumpukan di Jelly (tunggu, Jelly bukan bahasa berbasis tumpukan, kan ..)? Dalam hal itu pengurangan sederhana dapat digunakan dan Anda juga tidak perlu meniadakan jika saya tidak salah (sama seperti edit terakhir dalam jawaban 05AB1E saya).
Kevin Cruijssen
1
Imenghasilkan daftar - tambahkan ŒṘ untuk melihat representasi lengkap . Begitu ØẠŒHċ€IṪN⁸ṙ;ð/juga bekerja.
Jonathan Allan
Ah ok, itu masuk akal. Terima kasih untuk penjelasannya. Jawaban bagus btw, sudah tervotasikan kemarin. :)
Kevin Cruijssen
3

05AB1E , 18 17 16 14 byte

õsvy.uy.l-._y«

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

õ            # Start with an empty string
 sv          # Loop over the characters `y` of the input
   y.u       #  Check if `y` is an uppercase letter (1 if truthy; 0 if falsey)
   y.l       #  Check if `y` is a lowercase letter (1 if truthy; 0 if falsey)
      -      #  Subtract them from each other
       ._    #  Rotate the string that many times (-1, 0, or 1) toward the left
   y«        #  Append the current character `y` to the string
             # (And implicitly output the string after the loop)
Kevin Cruijssen
sumber
3

K4 , 43 33 byte

Larutan:

""{.q.rotate[-/y in'.Q`A`a;x],y}/

Contoh:

q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"Cb-Ad"
"Ab-Cd"
q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"ogl-edocf"
"code-golf"
q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"ti HIs SSta ET!"
"tHis IS a tEST!"

Penjelasan:

Iterasi di atas string input, putar output sebelumnya sebesar 1, -1 atau 0 tergantung pada posisinya di daftar "a-zA-Z".

""{.q.rotate[-/y in'.Q`A`a;x],y}/ / the solution
""{                            }/ / iterate (/) over, starting x as ""
                             ,y   / append y to
   .q.rotate[             ;x]     / rotate x by ...
                    .Q`A`a        / the lists "a..z" and "A..Z"
               y in'              / y in each (') alphabet?
             -/                   / subtract (-) over (/)

Catatan:

  • -10 byte dengan inspirasi dari solusi 05AB1E
streetster
sumber
3

> <> , 45 43 byte

ii:2+7$.::&"`{"@)@(*?}"@["&::&@)@(*?{&!
ror

Cobalah online!

Fakta bahwa> <> memiliki rotasi stack membantu, tetapi harus memeriksa huruf tidak.

Penjelasan:

i    Get first inputted character
 i   Get second. This is to prevent errors from rotating an empty stack
  :2+7$.      Jump to the second line if that was EOF
        ::&   Create copies of the input and store one in the register
           "`{"@)@(*     Check if the char is lower case
                    ?}   If so rotate the stack
                      "@["&::&@)@(*?{   Rotate the other way if uppercase
                                     &  Push the new char
                                      ! Skip the first i instruction
Skip to the second line on EOF
ro      Reverse the stack and output
r r     Cancel out the first reverse
 o      Output the rest of the stack
Jo King
sumber
2

Haskell , 101 91 byte

-10 byte terinspirasi oleh jawaban Curtis Bechtel (gunakan '@'<c,c<'['lebih elem c['A'..'Z']dan kisaran yang sesuai untuk huruf-huruf kecil).

g(x:y)=foldl((<>pure).(!))[x]y
x@(a:b)!c|'`'<c,c<'{'=last x:init x|'@'<c,c<'['=b++[a]|0<1=x

Cobalah online!

Penjelasan / Tidak Diundang

Operator (!)mengambil string yang tidak kosong xdi mana kita dapat mencocokkan pola dan karakter:

x@(a:b) ! c
  | '`' < c, c < '{' = last x : init x  -- rotate x to the right by one
  | '@' < c, c < '[' = b ++ [a]         -- rotate x to the left by one
  | otherwise = x                       -- keep x as is

Sekarang kita dapat mengurangi ekor input dari kiri ke kanan, dimulai dengan karakter pertama dari input menggunakan:

\b a -> b!a ++ [a]
ბიმო
sumber
2

Haskell , 122 92 byte

Terima kasih kepada BWO untuk sarannya! Saya juga menghemat banyak dengan mengambil pendekatan yang sedikit berbeda dari jawaban asli saya.

l@(a:b)!c|'`'<c,c<'{'=last l:init l++[c]|'@'<c,c<'['=b++[a,c]|0<1=l++[c]
f(c:s)=foldl(!)[c]s

Cobalah online!

Curtis Bechtel
sumber
Anda dapat menukar pola-kecocokan (#), penggunaan ,lebih &&, penggunaan [l!!0,c]lebih head l:[c], 1>0alih-alih True, Anda tidak perlu menghitung f=dan Anda dapat mengasumsikan input tidak kosong yang menyelamatkan l==[]penjaga - menghemat Anda 13 byte: Cobalah secara online!
ბიმო
Btw. Saya menggunakan isLowerdan isUppergolf dalam kiriman saya , saya harap Anda baik-baik saja dengan itu kalau tidak saya akan membalikkan edit saya.
ბიმო
@ BWO Terima kasih atas sarannya, dan terus maju!
Curtis Bechtel
2

JavaScript (Node.js) , 116 102 byte

f=(s,i=1)=>s[i]?f(s.replace(RegExp(`^(.)(.{${i}})(?=[A-Z])|^(.{${i}})(.)(?=[a-z])`),"$4$3$2$1"),i+1):s

Cobalah online!

Asli ( 116 111 106B)

s=>Buffer(s).map((x,i)=>s=(t=s[S="slice"](i),i<2)?s:x>64&x<91?s[S](1,i)+s[0]+t:x>96&x<123?s[i-1]+s[S](0,i-1)+t:s)&&s

s=>Buffer(s).map((x,i)=>i<2|--x%32>25|x<64?s:s=[s[S="slice"](1,i)+s[0],s[i-1]+s[S](0,i-1)][+(x>95)]+s[S](i))&&s

s=>Buffer(s).map((x,i)=>!i|--x%32>25|x<64?s:s=(w=x>95,t=s.slice(1-w,i-w),w?s[i-1]+t:t+s[0])+s.slice(i))&&s

Shieru Asakoto
sumber
Mungkin lebih pendek untuk dilakukan eval(`regex`)daripada menggunakan konstruktor
Downgoat
@Downgoat Saya khawatir bukan itu masalahnya karena garis miring diperlukan dalam kasus eval(`regex`), jadi -2 + 2 = 0 dan karenanya tidak membantu mengurangi jumlah byte.
Shieru Asakoto
@Downgoat Layak digunakan eval()ketika setidaknya satu flag digunakan: eval('/./g')lebih pendek 3 byte dari RegExp('.','g').
Arnauld
@Arnauld Itu benar, tapi saya tidak menggunakan bendera di sini.
Shieru Asakoto
@ShieruAsakoto (Tentu. Komentar saya terutama ditujukan kepada Downgoat untuk menjelaskan mengapa tidak layak melakukannya di sini.)
Arnauld
2

Ruby , 51 byte

->s{w=[];s.map{|x|w.rotate!(x=~/\W/||?_<=>x)<<x};w}

Cobalah online!

Input dan output adalah array karakter

Trik-nya:

Kode ini cukup mudah, kecuali mungkin bagian rotasi:

(x=~/\W/||?_<=>x)

x adalah karakter tunggal, yang bisa berupa huruf, ekspresi pertama x=~/\W/kembali niljika itu huruf, dan 0 sebaliknya. Jika 0, kita selesai, jika tidak, logika ormemeriksa ekspresi kedua: ?_<=>xmengembalikan -1 untuk huruf besar dan 1 untuk huruf kecil. Jadi rotasi adalah:

  • -1 (1 ke kiri) untuk huruf besar
  • +1 (1 ke kanan) untuk huruf kecil
  • 0 (tidak ada rotasi) jika bukan huruf
GB
sumber
2

Merah , 110 byte

func[s][p: s forall s[if all[(a: first s)>#"@"a < #"["][move p back s]if all[a >#"`"a <#"{"][move back s p]]p]

Cobalah online!

Penjelasan:

f: func [ s ] [
    p: s                                ; store the starting position of the string in p
    forall s [                          ; iterate through the entire string
        a: first s                      ; store the current character in a
        if all [ a > #"@" a < #"[" ] [  ; if `a` is a uppercase letter
            move p back s               ; move the starting char to the position before current
        ]
        if all [ a > #"`" a < #"{" ] [  ; if `a` is a lowercase letter
            move back s p               ; move the character before the current one to the start
        ]
    ]
    p                                   ; return the string 
]
Galen Ivanov
sumber
2

Perl 6 , 47 byte

*.reduce:{|@$^a.rotate($^b~~/\w/&&'_'leg$b),$b}

Cobalah online!

Bekerja pada berbagai karakter.

nwellnhof
sumber
Ah, saya akan menggunakan cmp dan uc / lc, tetapi itu mencapai 49 byte
Jo King
1
Sial, 48 byte Hampir berhasil
Jo King
2

Japt, 17 16 14 byte

Mengambil input sebagai array karakter, menghasilkan string

;rÏiXéCøY -BøY

Cobalah


Penjelasan

 rÏ                :Reduce by passing the current result (X) & the current element (Y) through a function
   i               :  Prepend to Y
    Xé             :  X rotated right by
;     B            :    Uppercase alphabet
       øY          :    Contains Y?
          -        :    Subtract
;          C       :    Lowercase alphabet
            øY     :    Contains Y?
Shaggy
sumber
1

Jelly , 19 byte

W€ḷṙ01ŒlƑ?-ŒuƑ?};ʋ/

Cobalah online!

Erik the Outgolfer
sumber
1

Java 10, 149 119 byte

s->{for(int i=1;i<s.length();)s=s.replaceAll("^(.)(.{"+i+"})(?=[A-Z])|^(.{"+i+++"})(.)(?=[a-z])","$4$3$2$1");return s;}

Port dari jawaban JavaScript @ShieruAsakoto , jadi pastikan untuk menghapusnya.

Cobalah online.

Penjelasan:

s->{                          // Method with String as both parameter and return-type
  for(int i=1;i<s.length();)  //  Loop `i` in the range [1, length)
    s=s.replaceAll("^(.)(.{"+i+"})(?=[A-Z])|^(.{"+i+++"})(.)(?=[a-z])","$4$3$2$1");
                              //   Rotate the substring of [0, i] either left or right
  return s;}                  //  Return the modified input-String as result
Kevin Cruijssen
sumber
1

Stax , 32 byte

éG7[Æ┐äZ▬Θε♫∙~╞ÉH╔u╬←J╛ü╢(┼▒uX)Ü

Jalankan dan debug itu

B]s{c97 123:bsaa|)sc65 91:bsaa|(s+c}fd  #Full program, unpacked, implicit input
B]s                                     #Unons-left, singleton, swap top 2 of stack
   {c                                   #Copy iterative letter
     97 123                             #Put 97 and 123 on stack(lower case)
           :bsaa                        #Check if iterative letter is between range, swap orientation back to proper order
                |)                      #Rotate if the letter is within range
                  sc                    #Swap top 2 and copy top
                    65 91               #Put 65 and 91 on stack (Capitals)
                         :bsaa          #Check if iterative letter is between range, swap orientation back to proper order
                              |(        #Rotate if the letter is within range
                                s+c     #swap, concat and copy
                                   }fd  #remove duplicate of original answer after loop and implicitly print

Banyak stack swapping yang mungkin tidak perlu. Saya benar-benar ingin mendapatkan ini lebih banyak, tetapi saya berjuang dengan pemesanan tumpukan. Mungkin seseorang bisa mengetahuinya jika mereka bosan. Akan terus mengerjakannya.

Multi
sumber
1

Attache , 69 byte

~Fold[{s'r.=_'sp;Rotate[s,&`-!Has&r[0]=>ALPHA'alpha]+r}@SplitAt]#Iota

Cobalah online!

Penjelasan

Bentuk umum

Fungsi umumnya terlihat seperti ini:

~Fold[{...}]#Iota

Yang melipat {...}setiap anggota dalam kisaran dari 0ke #input - 1(Iota ), dimulai dengan input sebagai seed.

Fungsi dalam

Fungsi berikut disebut sebagai f[building, index]dan dipanggil dengan setiap indeks dari 0ke #inputeksklusif. @SplitAtpanggilan SplitAtpada argumen ini, membelah string input aktif index.

{s'r.=_'sp;Rotate[s,&`-!Has&r[0]=>ALPHA'alpha]+r}
{                                               }    anonymous function taking the split string
                                                     e.g.: ["cd-", "Adf!"]
      _'sp                                           concat the input with a space
                                                     e.g.: ["cd-", "Adf!", " "]
                                                     (this is to handle index = 0)
 s'r.=                                               `s` is the first member, and `r` is the second
           Rotate[s,                         ]       rotate `s` by:
                                  ALPHA'alpha          over uppercase and lowercase alphabets:
                        Has&r[0]=>                       test if r[0] is in each alphabet
                                                       e.g.: [true, false]
                    &`-!                               subtract the second from the first
                                                       e.g.: (true - false) = 1 - 0 = 1
                                                     s is rotated according to the following map:
                                                       uppercase =>  1
                                                       symbol    =>  0
                                                       lowercase => -1
                                              +r     append the right portion of the string

Pada dasarnya, fungsi ini memutar bagian kiri dari string sesuai dengan karakter pertama dari bagian kanan.

Conor O'Brien
sumber
1

Arang , 20 byte

FS≔⁺⭆ω§ω⁻⁺λ№αι№βιιωω

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

FS

Ulangi karakter input.

≔⁺⭆ω§ω⁻⁺λ№αι№βιιω

Peta atas string karakter yang dikumpulkan sejauh ini, pengindeksan secara siklis ke karakter yang dikumpulkan sejauh ini dengan indeks bertambah atau berkurang jika karakter saat ini masing-masing huruf besar atau kecil. Ini melengkapi rotasi. Karakter selanjutnya kemudian digabungkan, dan hasilnya ditugaskan kembali ke string.

ω

Cetak hasilnya.

Neil
sumber
1

R , 107 102 100 byte

Masif karena manipulasi string R adalah besar. Adakah yang bisa mendapatkannya di bawah 100?

-5 byte menggunakan trik "set variabel loop ke F untuk menghindari inisialisasi".

-2 byte dengan mengasumsikan semua karakter dapat dicetak dan digunakan 2*!k%%97>25daripada 2*k%in%97:122untuk menguji huruf kecil, menggunakan prioritas operator.

function(x){for(k in u<-utf8ToInt(x))u[1:F-1]=u[(1:(F=F+1)+k%in%65:90-2*!k%%97>25)%%F];intToUtf8(u)}

Cobalah online!

J.Apakah
sumber
1
Ayo bergabung dengan kami (ini hanya saya sekarang ...) di chatroom R golf untuk memunculkan beberapa ide di sekitar! Dugaan saya adalah bahwa permutasi adalah sependek mungkin dengan pendekatan ini tetapi tidak mencobanya sendiri, saya tidak bisa mengatakan dengan pasti.
Giuseppe
1

Japt , 25 23 byte

Aku menyerah, tidak bisa membuatnya lebih pendek

-2 byte dari @ETHproductions

£=¯Y éXè\a -Xè\A)+UsYÃU

£=¯Y éXè\a -Xè\A)+UsYÃU     Full program. Implicit input U
£                           map each char
 =                          set U equal to:
  ¯Y                        U sliced to current mapped value
    éXè\a -Xè\A)            and rotated left or right 1 char
                +UsY        append the non-sliced U value
                      ÃU    Output U    

Cobalah online!

Luis felipe De jesus Munoz
sumber
Sayangnya, saya tidak dapat menemukan cara yang lebih pendek untuk melakukan éXè\a -Xè\Asalah satu :-( Anda dapat menyimpan dua byte dengan mengubah spasi ganda menjadi ), dan menghapus ©(koma implisit berarti yang Umasih di
output
Simpan 2 byte lagi dengan menjatuhkan ÃUdan menggunakan -hflag.
Shaggy
1

Retina , 67 64 58 byte

^
¶
+`(.*)(.)¶([a-z])|(.)(.*)¶([A-Z])|¶(.)
$2$1$3$5$4$6$7¶

-9 byte terima kasih kepada @Neil menghapus tiga yang tidak perlu ?telah saya tambahkan, serta yang tidak perlu (.*)dalam kasus-lain.

Cobalah secara online atau verifikasi semua kasus uji . (CATATAN: Output dengan baris tambahan. Header dalam rangkaian uji adalah untuk menguji setiap jalur input sebagai tempat uji terpisah, dan catatan kaki adalah untuk menghapus baris tambahan tersebut untuk output yang lebih kompak.)

Penjelasan:

Tambahkan baris baru sebelum input:

^
¶

Lanjutkan mengganti selama kami dapat menemukan kecocokan:

+`

Yang lainnya adalah tiga cek berbeda yang digabung menjadi satu:

Jika karakter tepat setelah baris baru adalah huruf kecil: putar semuanya sebelum baris baru ke kanan, lalu tambahkan karakter dan baris baru:

(.*)(.)¶([a-z])
$2$1$3¶

Jika karakter tepat setelah baris baru adalah huruf besar: putar semuanya sebelum baris baru ke kiri, dan kemudian tambahkan karakter itu dan baris baru:

(.)(.*)¶([A-Z])
$2$1$3¶

Lain-lain (bukan huruf kecil atau huruf besar): cukup geser baris baru ke kanan untuk 'iterasi' berikutnya:

¶(.)
$1¶

Tiga cek di atas digabung dengan regex ATAU pernyataan ( |) dan penggantian grup yang lebih besar untuk membuatnya bertindak seperti if(lowercase) ... elseif(uppercase) ... else ...:

Kevin Cruijssen
sumber
Saya tidak berpikir Anda membutuhkan ?huruf s - jika belum ada yang berputar, tidak masalah apakah ada surat.
Neil
1
Juga, mengganti (.*)¶(.)dengan $1$2¶dapat disederhanakan untuk menggantikan ¶(.)dengan $1¶sebagai capture lainnya tidak mempengaruhi hasil.
Neil
@Neil Ah, tentu saja terima kasih. -9 byte di sana! :)
Kevin Cruijssen
1

MATL , 20 byte

ttYo-ZS"X@q:&)w@YSwh

Cobalah online!

-4 byte terima kasih kepada Luis Mendo.

Ubah huruf besar / kecil / non-huruf ke [-1,0,1] (paruh pertama program). Berlaku pengalihan secara berturut-turut (babak kedua). Saya merusak otak saya jika ada cara yang lebih baik untuk memetakan huruf besar / huruf kecil ke [-1,0,1] (lihat versi kedua), dan mungkin cara untuk membalikkan string segera untuk menyingkirkan keduanya wDibutuhkan untuk &).

Sanchises
sumber
1

C (dentang) , 168 159 153 119 byte

g,i,j;f(char*a){for(i=0;a[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j),*a=g:isupper(a[i])?g=*a,bcopy(a+1,a,j),a[j]=g:0);}

-26 terima kasih kepada @ceilingcat

Cobalah online!

Logern
sumber
Sarankan g=a[j=i++];islower(a[i])?bcopy(a,a+1,j)alih-aliha[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j)
ceilingcat
0

Pyth, 16 byte

em=+.>k-F}RGrBd2

Coba di sini!

Penjelasan:

em=+.>k-F}RGrBd2dQ    Autofill variables
 m               Q    for each d in Q (the input):
            rBd2       Take [d, swapcase(d)]
         }RG           Figure out which are in the lowercase alphabet (returns [1,0] for lowercase, [0,1] for uppercase, [0,0] for non-letters)
       -F              Fold on subtraction (1 for lowercase, -1 for uppercase, 0 for non-letter)
    .>k                Cycle the processed part (k) of the input right by ^ steps
   +            d      Add in the new character at the end
  =   k                Store new process step back into k (k starts as an empty string)
e                     Get the (e)nd step's output.
Steven H.
sumber