Meydan okuma

Her yerde kelime, bir giriş dizesi verilecektir "Lemon"bunun dönüştürülmesi gerekir bulunursa "Lemonade" ancaka , dve ecümlede başka yerden ödünç alınmalıdır.

Örnek

Örnek Giriş:

Çocukken bir limon buldum

Örnek çıktı:

Çocukken bir limonata kurdum

Limonata orijinalden aşağıdaki üst simge harfleri çalarak yaratıldı

Ben igili kurucuları ^d limonata wh ^e n ben ^bir çocuk

Bu sadece bir olası çıktı örneğidir, "e", "d" ve "a" her yerden alınabilirdi ( elbette kelimesi hariçlemon )

Yorumlar

• yeterli değilse e, aya dsize s gerekir -mümkün verilen harflerle ne çıktı. Örneğin girdi bdblemonçıktıbblemond

• lemonMetin her zaman bağımsız olmayabilir (her iki taraftaki boşluk). Örneğin lemons, girişte herhangi bir yerde kelimeye sahip olabilirsiniz ve çıktılemonades

• Giriş, herhangi bir sayıda lemons, hatta 0 lemonsn içerebilir (bu durumda çıkış girişle aynı olacaktır)

• Sen örnek için, büyük ve küçük harfler ile limonata yapabilirsiniz leMonhaline gelebilir leMonadeve adeher halükarda olabilir ödünç (o da olabilirdi bu yüzden leMonADe).
Ödünç aldığınız mektubun durumu, ödünç alırken olduğu gibi kalmalıdır.
(Örnek giriş -> çıkış, he hAD lemOn-> h h lemOnADe)

• Tam bir program olmak zorunda değildir, tek başına bir işlev iyidir.

• Girişin yalnızca CP437 Karakter Seti olacağını varsayabilirsiniz

Code Golf

Bu kod-golf , bu yüzden en düşük bayt sayısı kazanır!

Sözde testcases

* Not: Herhangi bir giriş için birden fazla olası çıkış olabilir, bu nedenle programınız tam olarak bu test durumlarında olduğu gibi çıkmayabilir, bu daha doğrusu insanlar mantığını anlayabilmeleri içindir:

Giriş: EpaD leMons
Çıktı: p LeMonaDEs

Giriş: merhaba dünya
Çıktı: merhaba dünya

Girdi: limon limon
Çıkışı: limon limon
* ( , , harfler başka bir "Lemon" dan alınması asla)ead

Giriş: HE HAD limonata
Çıkış: HH lemonADEade

Giriş: Limonları sever misiniz? Beni limonun altında tuttun
Çıktı: o lemonades sever misiniz? Limonata hmt!

Giriş: AE limon
Çıkışı: lemonAE

Giriş: 55bad limon
Çıkış: 55b lemonad

JavaScript (ES6), 159 157 155 162 bayt

Düzenleme: +7 bayt bir hata atmak yerine "verilen harflerle yapabilecekleri çıktı"

Değiştirilen dizgeyi döndüren özyinelemeli bir işlev.

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``

Nasıl çalışır

İfade s.split(/(lemon)/i)giriş dizesini böler lemonancak sonuçtaki yakalama gruplarını korur.

Örneğin "foo lemon bar LEMON baz".split(/(lemon)/i), diziyi üretecektir [ 'foo ', 'lemon', ' bar ', 'LEMON', ' baz' ].

Biz yinelemeli yinelerler bu dizi, karakterler ayıklanması a, dve eya onların büyük harf daha pozisyonunda bulunan girişlerinden meslektaşları ve garip bir konumda bulunan girişlere onları ekleme.

Yorumlananlar

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

gösteri

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 bayt

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

Bu netlik için iki satıra bölünmüştür; Newline sayılmaz.

pseudocode:

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

Retina , 303 bayt

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

Çevrimiçi deneyin!

Elbette burada yanlış bir şey yapıyorum.