Thử thách

Bạn sẽ nhận được một chuỗi đầu vào, bất cứ nơi nào từ "Lemon"được tìm thấy nó nên được chuyển đổi sang "Lemonade" nhưng sự a, dvà ephải được mượn từ một nơi khác trong câu.

Thí dụ

Ví dụ đầu vào:

Tôi đã tìm thấy một quả chanh khi tôi còn là một đứa trẻ

Kết quả ví dụ:

Tôi thích một nước chanh khi tôi còn bé

Các Lemonade được tạo ra bằng cách ăn cắp các chữ số trên sau từ bản gốc

Tôi sáng lập ^d một nước chanh wh ^e n tôi là ^một đứa trẻ

Đây chỉ là một ví dụ đầu ra khả thi, "e", "d" và "a", có thể được lấy từ bất cứ đâu ( ngoại trừ từ từ lemontất nhiên )

Bình luận

• Nếu không đủ e, ahoặc dbạn phải xuất những gì có thể với các chữ cái đã cho. Ví dụ: đầu vào bdblemonsẽ xuấtbblemond

• Văn lemonbản có thể không phải luôn luôn độc lập (không gian ở mỗi bên). Ví dụ: bạn có thể có từ lemonsở đâu đó trong đầu vào và đầu ra phải làlemonades

• Đầu vào có thể chứa bất kỳ số lemons, thậm chí 0 lemons (trong trường hợp đó, đầu ra sẽ giống hệt với đầu vào)

• Bạn có thể làm cho nước chanh của bạn bằng chữ in hoa và chữ thường, ví dụ leMoncó thể trở thành leMonade, và người ademượn có thể là bất kỳ trường hợp nào (vì vậy nó cũng có thể trở thành leMonADe).
Trường hợp của bức thư bạn mượn phải giữ nguyên như khi bạn mượn nó.
(Ví dụ đầu vào -> đầu ra, he hAD lemOn-> h h lemOnADe)

• Không phải là một chương trình đầy đủ, một chức năng là tốt.

• Bạn có thể cho rằng đầu vào sẽ chỉ là Bộ ký tự CP437

Mã Golf

Đây là môn đánh gôn , vì vậy số byte thấp nhất sẽ thắng!

Pseudo-TestCase

* Lưu ý: Đối với bất kỳ đầu vào cụ thể nào, có thể có nhiều đầu ra có thể để chương trình của bạn có thể không xuất ra chính xác như các trường hợp thử nghiệm này, điều này chỉ đơn giản hơn để mọi người có thể hiểu logic:

Đầu vào: EpaD leMons
Đầu ra: p LeMonaDEs

Đầu vào: hello world
Kết quả: hello world

Input: chanh chanh
Output: chanh chanh
* ( Các e, a, dchữ nên không bao giờ được thực hiện từ một "Lemon")

Đầu vào: Nước chanh HE HAD
Đầu ra: HH LemonADEade

Đầu vào: Bạn có thích chanh không? Bạn hAd tôi tại chanh!
Đầu ra: o bạn thích LemonADes? Bạn hmt nước chanh!

Đầu vào: AE chanh
Đầu ra: LemonAE

Đầu vào: 55bad chanh
Đầu ra: 55b chanh

JavaScript (ES6), 159 157 155 162 byte

Chỉnh sửa: +7 byte thành "xuất ra những gì có thể thực hiện được với các chữ cái đã cho" thay vì đưa ra lỗi

Hàm đệ quy trả về chuỗi đã sửa đổi.

f=(s,a=s.split(/(lemon)/i),n=(a.length-1)*1.5)=>n?f(n,a.map((s,i)=>i&1|!n||(a[i]=s.replace([/a/i,/e/i,/d/i][n%3],c=>(a[--n/3<<1|1]+=c,''))))&&a,n-(n==s)):a.join``

Làm thế nào nó hoạt động

Biểu thức s.split(/(lemon)/i)phân tách chuỗi đầu vào trên lemonnhưng bảo toàn các nhóm chụp trong kết quả.

Ví dụ, "foo lemon bar LEMON baz".split(/(lemon)/i) sẽ tạo ra các mảng [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ].

Chúng tôi lặp lại đệ quy trên mảng này, trích xuất các ký tự a , dvà ehoặc các đối tác của họ hoa từ các mục tọa lạc tại một vị trí thậm chí, và phụ thêm chúng vào mục tọa lạc tại một vị trí kỳ lạ.

Đã bình luận

f = (                                   // given:
  s,                                    //   s = input string or previous value of 'n'
  a = s.split(/(lemon)/i),              //   a = split array, as described above
  n = (a.length - 1) * 1.5              //   n = total number of characters to be found
) =>                                    //
  n ?                                   // if there's still at least one character to find:
    f(                                  //   do a recursive call with:
      n,                                //     1) the current value of 'n'
      a.map((s, i) =>                   //     2) an updated version of 'a', where
        i & 1 | !n || (                 //       for even positions:
          a[i] = s.replace(             //         we look for the next character
            [/a/i, /e/i, /d/i][n % 3],  //           'a', 'e' or 'd' (case insensitive)
            c => (                      //           append it to
              a[--n / 3 << 1 | 1] += c, //           one of the entries at an odd position
              ''                        //           and remove it from the original entry
            )                           //           end of replace() callback
          )                             //         end of replace()
        )                               //       end of position condition
      ) && a,                           //     end of map() -> yield the updated 'a'
      n -                               //     3) the updated value of 'n', skipping the
      (n == s)                          //        current character if not found at all
    )                                   //   end of recursive call
  :                                     // else:
    a.join``                            //   success: join 'a' and return it

Bản giới thiệu

f=(s,a=s.split(/(lemon)/i),n=(a.length-1)*1.5)=>n?f(n,a.map((s,i)=>i&1|!n||(a[i]=s.replace([/a/i,/e/i,/d/i][n%3],c=>(a[--n/3<<1|1]+=c,''))))&&a,n-(n==s)):a.join``

console.log(f("I found a lemon when I was a kid"))
console.log(f("I found a lemon when I was a kid. I found another lemon when I was older."))
console.log(f("bdblemon"))
console.log(f("he hAD lemOn"))

CJam, 130 byte

LqY5m*{"lemon"_eu}%3/:z{~?}f%{_@\/_:,[{1$+}*]);@f{[\]}@+\1a*}/\{1
=}$0f=\1$,{"ade"{__C#)\Ceu#)|(\0+We\)@_N=@+N\t\}fC}fN0a/L*1a/\.{}

Điều này được chia thành hai dòng cho rõ ràng; dòng mới không được tính.

Mã giả:

FLAG_1 = object()
FLAG_2 = object()
lemon_instances = [] # CJam: L
input_chars = list(all_input()) # CJam: q
lemons = [
    "LEMON", "LEMOn", "LEMoN", "LEMon", "LEmON", "LEmOn", "LEmoN", "LEmon",
    "LeMON", "LeMOn", "LeMoN", "LeMon", "LemON", "LemOn", "LemoN", "Lemon",
    "lEMON", "lEMOn", "lEMoN", "lEMon", "lEmON", "lEmOn", "lEmoN", "lEmon",
    "leMON", "leMOn", "leMoN", "leMon", "lemON", "lemOn", "lemoN", "lemon"
] # CJam: Y5m*{"lemon"_eu}%3/:z{~?}f%
for i in lemons: # CJam: { ... }/
    temp = input_chars.split(i) # CJam: _@\/
    lengths = temp.map(len) # CJam: _:,
    # Here, accum turns an array like [1,2,3] into [1,3,6].
    indices = accum(lengths) # CJam: [{1$+}*]
    indices.pop() # CJam: );
    temp2 = zip(temp, indices) # CJam: @f{[\]}
    lemon_instances = temp2 + lemon_instances # CJam: @+
    input_chars = join_array(temp, FLAG_1) # CJam: 1a*
lemon_instances.sort(key=lambda x: x[1]) # CJam: {1=}$
lemon_instances = [i[0] for i in lemon_instances] # CJam: 0f=
for i in range(len(lemon_instances)): # CJam: \1$,{...}fN
    for c in "ade": # CJam: "ade"{...}fC
        # list_index returns -1 if not found
        lower = list_index(input_chars, c)+1 # CJam: __C#)
        upper = list_index(input_chars, upper(c))+1 # CJam: \Ceu#)
        char_index = (lower or upper) - 1 # CJam: |(
        input_chars.append(FLAG_2) # CJam: \0+
        # -1 refers to the last element in the list
        swap_list_elements(input_chars, char_index, -1) # CJam: e\
        extracted = input_chars.pop() # CJam: )
        lemon_instances[i] += extracted # CJam: @_N=@+N\t\
remove_all(input_chars, FLAG_2) # CJam: 0a/L*
temp1 = input_chars.split(FLAG_1) # CJam: 1a/
# interleave([1, 2, 3], ["a", "b"]) gives [1, "a", 2, "b", 3]
temp2 = interleave(temp1, lemon_instances) # CJam: \.{}
print("".join(temp2))

Võng mạc , 303 byte

i+`(?<!lemon)(a)(.*)(lemon)(?!a)
$2$3$1
i+`(lemon)(?!a)(.*)(?<!lemon)(a)
$1$3$2
i+(?<!lemona?)(d)(.*)(lemona?)(?![ad])
$2$3$1
i+`(lemona?)(?![ad])(.*)(?<!lemona?)(d)
$1$3$2
i+(?<!lemona?d?)(e)(?!(?<=le)mon)(.*)(lemona?d?)(?![ade])
$2$3$1
i+`(lemona?d?)(?![ade])(.*)(?<!lemona?d?)(e)(?!(?<=le)mon)
$1$3$2

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

Chắc chắn tôi đang làm gì đó sai ở đây.