Bu alçakgönüllü StackOverflow sorusundan ilham alındı .

Fikir basit; bir Dize ve bir Dizeler dizisi verildiğinde, dizideki herhangi bir kelime örneğini (yoksayma durumu) ilk Dize dışındaki giriş Dizesi'nden, bırakabileceği ek boşluklarla birlikte kaldırın. Kelimeler, kelimelerin bölümleriyle değil, String dizisindeki tüm kelimelerle eşleşmelidir.

örneğin "A cat called matt sat on a mat and wore a hat A cat called matt sat on a mat and wore a hat", ["cat", "mat"]çıktı almalı"A cat called matt sat on a mat and wore a hat A called matt sat on a and wore a hat"

Giriş

• Girdi, bir String ve bir String dizesi veya girdi String'in ilk eleman olduğu bir String dizisi olarak alınabilir. Bu parametreler her iki sırada da olabilir.
• Girdi Dizesi, boşlukla ayrılmış Dizelerin bir listesi olarak alınamaz.
• Girdi Dizesi'nde ön, arka veya ardışık boşluklar bulunmaz.
• Tüm girişler, yalnızca boşluklar da dahil olmak üzere, giriş Dizesi hariç yalnızca [A-Za-z0-9] karakterlerini içerecektir.
• Giriş dizisi boş olabilir veya giriş Dizesinde olmayan sözcükler içerebilir.

Çıktı

• Çıktı, bir işlevden döndürülen değer olabilir veya STDOUT'a yazdırılabilir
• Çıktı, orijinal Dize ile aynı durumda olmalıdır

Test senaryoları

the blue frog lived in a blue house, [blue] -> the blue frog lived in a house
he liked to read but was filled with dread wherever he would tread while he read, [read] -> he liked to read but was filled with dread wherever he would tread while he
this sentence has no matches, [ten, cheese] -> this sentence has no matches
this one will also stay intact, [] -> this one will also stay intact
All the faith he had had had had no effect on the outcome of his life, [had] -> All the faith he had no effect on the outcome of his life
5 times 5 is 25, [5, 6] -> 5 times is 25
Case for different case, [case] -> Case for different
the letters in the array are in a different case, [In] -> the letters in the array are a different case
This is a test Will this be correct Both will be removed, [this,will] -> This is a test Will be correct Both be removed

Bu kod golf olduğundan, en düşük bayt sayısı kazanır!

R , 84 bayt

function(s,w,S=el(strsplit(s," ")),t=tolower)cat(S[!duplicated(x<-t(S))|!x%in%t(w)])

Çevrimiçi deneyin!

Kolmogorov karmaşıklığı da olmayan bir dize meydan okumasında 100 bayttan az mı?

Açıklama:

Dizeyi kelimelere böldükten sonra,

1. kopyalar ve
2. içinde w

veya alternatif olarak, kafasına çevirerek,

1. bir kelimenin ilk oluşumu VEYA
2. değil w.

duplicatedilk oluşum olmayanların mantıksal indekslerini düzgün bir şekilde döndürür, bu yüzden !duplicated()ilk oluşum olanların x%in%wendekslerini döndürür ve xiçinde bulunanların mantıksal indekslerini döndürür w. Temiz.

Java 8, 117110 bayt

a->s->{for(String x:a)for(x="(?i)(.*"+x+".* )"+x+"( |$)(.*)";s.matches(x);s=s.replaceAll(x,"$1$3"));return s;}

Açıklama:

Çevrimiçi deneyin.

a->s->{                // Method with String-array and String parameters and String return
  for(String x:a)      //  Loop over the input-array
    for(x="(?i)(.*"+x+".* )"+x+"( |$)(.*)";
                       //   Regex to match
        s.matches(x);  //   Inner loop as long as the input matches this regex
      s=s.replaceAll(x,"$1$3")); 
                       //    Replace the regex-match with the 1st and 3rd capture groups
  return s;}           //  Return the modified input-String

Normal ifade için ek açıklama:

(?i)(.*"+x+".* )"+x+"( |$)(.*)   // Main regex to match:
(?i)                             //  Enable case insensitivity
    (                            //  Open capture group 1
     .*                          //   Zero or more characters
       "+x+"                     //   The input-String
            .*                   //   Zero or more characters, followed by a space
               )                 //  End of capture group 1
                "+x+"            //  The input-String again
                     (           //  Open capture group 2
                       |$        //   Either a space or the end of the String
                         )       //  End of capture group 2
                          (      //  Open capture group 3
                           .*    //   Zero or more characters
                             )   //  End of capture group 3

$1$3                             // Replace the entire match with:
$1                               //  The match of capture group 1
  $3                             //  concatted with the match of capture group 3

MATL , 19 18 bayt

"Ybtk@kmFyfX<(~)Zc

Girişler şunlardır: dizelerden oluşan bir hücre dizisi, sonra bir dize.

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

Nasıl çalışır

"        % Take 1st input (implicit): cell array of strings. For each
  Yb     %   Take 2nd input (implicit) in the first iteration: string; or
         %   use the string from previous iteration. Split on spaces. Gives
         %   a cell array of strings
  tk     %   Duplicate. Make lowercase
  @k     %   Push current string from the array taken as 1st input. Make
         %   lowercase
  m      %   Membership: gives true-false array containing true for strings
         %   in the first input argument that equal the string in the second
         %   input argument
  F      %   Push false
  y      %   Duplicate from below: pushes the true-false array again
  f      %   Find: integer indices of true entries (may be empty)
  X<     %   Minimum (may be empty)
  (      %   Assignment indexing: write false in the true-false array at that
         %   position. So this replaces the first true (if any) by false
  ~      %   Logical negate: false becomes true, true becomes false
  )      %   Reference indexing: in the array of (sub)strings that was
         %   obtained from the second input, keep only those indicated by the
         %   (negated) true-false array
  Zc     %   Join strings in the resulting array, with a space between them
         % End (implicit). Display (implicit)

Perl 5 , 49 bayt

@B=<>;$_=join$",grep!(/^$_$/xi~~@B&&$v{+lc}++),@F

Çevrimiçi deneyin!

@TonHospel sayesinde 9 (!!) bayt kaydedildi !

Pyth, 27 bayt

jdeMf!}r0eT@mr0dQmr0dPT._cz

Çevrimiçi deneyin

açıklama

jdeMf!}r0eT@mr0dQmr0dPT._cz
                          z  Take the string input.
                       ._c   Get all the prefixes...
    f    eT@                 ... which end with something...
     !}         Q    PT      ... which is not in the input and the prefix...
       r0   mr0d mr0d        ... case insensitive.
jdeM                         Join the ends of each valid prefix.

Büyük / küçük harfe duyarlı olmayan kontrol için 10 bayt azaltılabileceğinden eminim, ancak nasıl olduğunu göremiyorum.

Stax , 21 bayt ^CP437

åìøΓ²¬$M¥øHΘQä~╥ôtΔ♫╟

Paketten çıkarıldığında 25 bayt,

vjcm[]Ii<;e{vm_]IU>*Ciyj@

Sonuç bir dizidir. Stax için uygun çıktı, hat başına bir elementtir.

Çevrimiçi çalıştırın ve hata ayıklayın!

açıklama

vj                           Convert 1st input to lowercase and split at spaces,
  c                          Duplicate at the main stack
   m                         Map array with the rest of the program 
                                 Implicitly output
    []I                      Get the first index of the current array element in the array
       i<                    Test 1: The first index is smaller than the iteration index
                                 i.e. not the first appearance
         ;                   2nd input
          {vm                Lowercase all elements
             _]I             Index of the current element in the 2nd input (-1 if not found)
                U>           Test 2: The index is non-negative
                                 i.e. current element is a member of the 2nd input
                  *C         If test 1 and test 2, drop the current element
                                 and go on mapping the next
                    iyj@     Fetch the corresponding element in the original input and return it as the mapped result
                                 This preserves the original case

Perl 6 , 49 bayt

->$_,+w{~.words.grep:{.lc∉w».lc||!(%){.lc}++}}

Dene

Expanded:

->              # pointy block lambda
  $_,           # first param ｢$_｣ (string)
  +w            # slurpy second param ｢w｣ (words)
{

  ~             # stringify the following (joins with spaces)

  .words        # split into words (implicit method call on ｢$_｣)

  .grep:        # take only the words we want

   {
     .lc        # lowercase the word being tested
     ∉          # is it not an element of
     w».lc      # the list of words, lowercased

     ||         # if it was one of the words we need to do a secondary check

     !          # Boolean invert the following
                # (returns true the first time the word was found)

     (
       %        # anonymous state Hash variable
     ){ .lc }++ # look up with the lowercase of the current word, and increment
   }
}

Perl 5 , 50 48 bayt

içerir +1için-p

STDIN üzerinde ayrı satırlarda hedef dizeyi ve ardından her filtre sözcüğünü verin:

perl -pe '$"="|";s%\b(@{[<>]})\s%$&x!$v{lc$1}++%iegx;chop';echo
This is a test Will this be correct Both will be removed
this
will
^D
^D

chopSadece son söz kaldırılırsa durumunda sonunda boşluk düzeltmek için gerekli olan

Sadece kod:

$"="|";s%\b(@{[<>]})\s%$&x!$v{lc$1}++%iegx;chop

Çevrimiçi deneyin!

JavaScript (ES6), 98 bayt

s=>a=>s.split` `.filter(q=x=>(q[x=x.toLowerCase()]=eval(`/\\b${x}\\b/i`).test(a)<<q[x])<2).join` `

K4 , 41 bayt

Çözüm:

{" "/:x_/y@>y:,/1_'&:'(_y)~/:\:_x:" "\:x}

Örnekler:

q)k){" "/:x_/y@>y:,/1_'&:'(_y)~/:\:_x:" "\:x}["A cat called matt sat on a mat and wore a hat A cat called matt sat on a mat and wore a hat";("cat";"mat")]
"A cat called matt sat on a mat and wore a hat A called matt sat on a and wore a hat"

q)k){" "/:x_/y@>y:,/1_'&:'(_y)~/:\:_x:" "\:x}["Case for different case";enlist "case"]
"Case for different"

q)k){" "/:x_/y@>y:,/1_'&:'(_y)~/:\:_x:" "\:x}["the letters in the array are in a different case";enlist "In"]
"the letters in the array are a different case"

q)k){" "/:x_/y@>y:,/1_'&:'(_y)~/:\:_x:" "\:x}["5 times 5 is 25";(1#"5";1#"6")]
"5 times is 25"

Açıklama:

Boşlukta bölün, her iki girişi de küçük harfle yazın, eşleşmeleri arayın, ilk tekrarlama dışında tümünü kaldırın, dizeyi tekrar birleştirin.

{" "/:x_/y@>y:,/1_'&:'(_y)~/:\:_x:" "\:x} / the solution
{                                       } / lambda with implicit x & y args
                                  " "\:x  / split (\:) on whitespace " "
                                x:        / save result as x
                               _          / lowercase x
                          ~/:\:           / match (~) each right (/:), each left (\:)
                      (_y)                / lowercase y
                   &:'                    / where (&:) each ('), ie indices of matches
                1_'                       / drop first of each result
              ,/                          / flatten
            y:                            / save result as y
         y@>                              / descending indices (>) apply (@) to y
      x_/                                 / drop (_) from x
 " "/:                                    / join (/:) on whitespace " "

JavaScript (Node.js) , 75 bayt

f=(s,a)=>a.map(x=>s=s.replace(eval(`/\\b${x}\\b */ig`),s=>i++?"":s,i=0))&&s

Çevrimiçi deneyin!

JavaScript ES6, 78 Bayt

f=(s,a,t={})=>s.split` `.filter(w=>a.find(e=>w==e)?(t[w]?0:t[w]=1):1).join` `

Nasıl çalışır:

f=(s,a,t={})=> // Function declaration; t is an empty object by default
s.split` ` // Split the string into an array of words
.filter(w=> // Declare a function that, if it returns false, will delete the word
  a.find(e=>w==e) // Returns undeclared (false) if the word isn't in the list
  ?(t[w]?0 // If it is in the list and t[w] exists, return 0 (false)
    :t[w]=1) // Else make t[w] exist and return 1 (true)
  :1) // If the word isn't in the array, return true (keep the word for sure)
.join` ` // Rejoin the string

PowerShell v3 veya üstü, 104 bayt

Param($s,$w)$w|?{$_-and$s-match($r="\b$_(?: |$)")}|%{$h,$t=$s-split$r;$s="$h$($Matches.0)$(-join$t)"};$s

Bir bayt pahasına, PS 2.0'da değiştirerek çalışabilir $Matches.0 olan $Matches[0].

Uzun versiyon:

Param($s, $w)
$w | Where-Object {$_ -and $s -match ($r = "\b$_(?: |$)")} |    # Process each word in the word list, but only if it matches the RegEx (which will be saved in $r).
    ForEach-Object {                                            # \b - word boundary, followed by the word $_, and either a space or the end of the string ($)
        $h, $t = $s -split $r                                   # Split the string on all occurrences of the word; the first substring will end up in $h(ead), the rest in $t(ail) (might be an array)
        $s = "$h$($Matches.0)$(-join $t)"                       # Create a string from the head, the first match (can't use the word, because of the case), and the joined tail array
    }
$s                                                              # Return the result

kullanım
Whatever.ps1 olarak kaydedin ve dize ve sözcüklerle bağımsız değişken olarak çağırın. Birden fazla kelimenin geçirilmesi gerekiyorsa, kelimelerin @ () içine alınması gerekir:

.\Whatever.ps1 -s "A cat called matt sat on a mat and wore a hat A cat called matt sat on a mat and wore a hat" -w @("cat", "mat")

Dosyasız alternatif (doğrudan bir PS konsoluna yapıştırılabilir): Komut dosyasını bir değişkene ScriptBlock (kıvırcık ayraçların içine) olarak kaydedin, ardından Invoke () yöntemini çağırın veya Invoke-Command ile kullanın:

$f={Param($s,$w)$w|?{$_-and$s-match($r="\b$_(?: |$)")}|%{$h,$t=$s-split$r;$s="$h$($Matches.0)$(-join$t)"};$s}
$f.Invoke("A cat called matt sat on a mat and wore a hat A cat called matt sat on a mat and wore a hat", @("cat", "mat"))
Invoke-Command -ScriptBlock $f -ArgumentList "A cat called matt sat on a mat and wore a hat A cat called matt sat on a mat and wore a hat", @("cat", "mat")

Javascript, 150 bayt

s=(x, y)=>{let z=new Array(y.length).fill(0);let w=[];for(f of x)(y.includes(f))?(!z[y.indexOf(f)])&&(z[y.indexOf(f)]=1,w.push(f)):w.push(f);return w}

Temiz , 153 142 138 134 bayt

import StdEnv,StdLib,Text
@ =toUpperCase
$s w#s=split" "s
=join" "[u\\u<-s&j<-[0..]|and[i<>j\\e<-w,i<-drop 1(elemIndices(@e)(map@s))]]

Çevrimiçi deneyin!

Fonksiyonu tanımlar, $ :: String [String] -> Stringkelimenin tam anlamıyla zorluğun açıkladığı şeyi yapar. Her hedef sözcük için, ilkinden sonraki her olayı bulur ve kaldırır.

Retina, 46 37 bayt

+i`(^|,)((.+),.*\3.* )\3( |$)
$2
.*,

@Neil sayesinde -14 bayt ve hata düzeltmesi için +5 bayt.

Biçimdeki giriş word1,word2,word3,sentence , ben (girişler farklı kullanıldığı yerlerde) çok satırlı girişi var nasıl emin değilim çünkü ..

Açıklama:

Çevrimiçi deneyin.

+i`(^|,)((.+),.*\3.* )\3( |$)   Main regex to match:
+i`                              Enable case insensitivity
   (^|,)                          Either the start of the string, or a comma
        (                         Open capture group 2
         (                         Open capture group 3
          .+                        1 or more characters
            )                      Close capture group 3
             ,                     A comma
              .*                   0 or more characters
                \3                 The match of capture group 3
                  .*               0 or more characters, followed by a space
                     )            Close capture group 2
                      \3          The match of capture group 2 again
                        ( |$)     Followed by either a space, or it's the end of the string
$2                              And replace everything with:
                                 The match of capture group 2

.*,                             Then get everything before the last comma (the list)
                                 and remove it (including the comma itself)

Kırmızı , 98 bayt

func[s w][foreach v w[parse s[thru[any" "v ahead" "]any[to remove[" "v ahead[" "| end]]| skip]]]s]

Çevrimiçi deneyin!

f: func [s w][ 
    foreach v w [                   ; for each string in the array
        parse s [                   ; parse the input string as follows:
            thru [                  ; keep everything thru: 
                any " "             ; 0 or more spaces followed by
                v                   ; the current string from the array followed by
                ahead " "           ; look ahead for a space
            ]
            any [ to remove [       ; 0 or more: keep to here; then remove: 
                " "                 ; a space followed by 
                v                   ; the current string from the array
                ahead [" " | end]]  ; look ahead for a space or the end of the string
            | skip                  ; or advance the input by one 
            ]
        ]
    ]
    s                               ; return the processed string 
]

Kabuk , 13 bayt

wüöVËm_Ṗ3+⁰ew

Bu sırayla dizelerin listesini ve tek bir dizeyi bağımsız değişken olarak alır. Listenin çift olmadığını varsayar. Çevrimiçi deneyin!

açıklama

wüöVËm_Ṗ3+⁰ew  Inputs: list of strings L (explicit, accessed with ⁰), string S (implicit).
               For example, L = ["CASE","for"], s = "Case for a different case".
            w  Split S on spaces: ["Case","for","a","different","case"]
 ü             Remove duplicates wrt an equality predicate.
               This means that a function is called on each pair of strings,
               and if it returns a truthy value, the second one is removed.
  öVËm_Ṗ3+⁰e    The predicate. Arguments are two strings, say A = "Case", B = "case".
           e    Put A and B into a list: ["Case","case"]
         +⁰     Concatenate with L: ["CASE","for","Case","case"]
       Ṗ3       All 3-element subsets: [["CASE","for","Case"],["CASE","for","case"],
                                        ["CASE","Case","case"],["for","Case","case"]]
  öV            Does any of them satisfy this:
    Ë            All strings are equal
     m_          after converting each character to lowercase.
                In this case, ["CASE","Case","case"] satisfies the condition.
               Result: ["Case","for","a","different"]
w              Join with spaces, print implicitly.

Min , 125 bayt

=a () =b a 1 get =c a 0 get " " split
(:d (b d in?) ((c d in?) (d b append #b) unless) (d b append #b) if) foreach
b " " join

Giriş, quotbirinci öğe olarak String girişi ve quotikinci öğe olarak yinelenen dizelerden oluşan bir yığının üzerindedir;

("this sentence has no matches" ("ten" "cheese"))

Python 3 , 168 bayt

def f(s,W):
 s=s.split(" ");c={w:0for w in W}
 for w in W: 
  for i,v in enumerate(s):
   if v.lower()==w.lower():
    c[w]+=1
    if c[w]>1:s.pop(i)
 return" ".join(s)

Çevrimiçi deneyin!

AWK , 120 bayt

NR%2{for(;r++<NF;)R[tolower($r)]=1}NR%2==0{for(;i++<NF;$i=$(i+s))while(R[x=tolower($(i+s))])U[x]++?++s:i++;NF-=s}NR%2==0

Çevrimiçi deneyin!

"Boşluğu kaldır" kısmı bunu ilk düşündüğümden biraz daha zorlaştırdı. Alan ayarlama"" kaldırır, ancak fazladan bir ayırıcı bırakır.

TIO bağlantısında birden fazla girişe izin vermek için 28 ekstra bayt vardır.

Giriş 2 satır üzerinden verilir. İlk satır kelime listesidir ve ikinci satır "cümle" dir. "Word" ve "word" ifadelerinin ekli noktalama işaretleri ile aynı kabul edilmediğini unutmayın. Noktalama işaretlerine sahip olmak, bunu daha da eğlenceli bir problem haline getirecektir .

Yakut , 63 61 60 59 bayt

->s,w{w.any?{|i|s.sub! /\b(#{i}\b.*) #{i}\b/i,'\1'}?redo:s}

Çevrimiçi deneyin!

Büyük / küçük harfe duyarlı ve başarısızlık nedeniyle ~ her 10 ¹⁵ seferde bir daha kısa bir sürüm

->s,w{s.uniq{|i|w.member?(i)?i:rand}}

Python 2 , 140 bayt

from re import*
p='\s?%s'
S,A=input()
for a in A:S=sub(p%a,lambda s:s.end()==search(p%a,S,flags=I).end()and s.group()or'',S,flags=I)
print S

Çevrimiçi deneyin!

Açıklama:

re.sub(..)argüman olarak değiştirme dizesi yerine bir işlev alabilir. İşte burada süslü bir lambda var. Desenin her oluşumu için fonksiyon çağrılır ve bu fonksiyona bir nesne aktarılır - matchobject. Bu nesnenin yerleşik oluşum hakkında bilgi vardır. start()Veya tarafından alınabilir bu oluşumun indeksi ile ilgileniyorumend() fonksiyonu . İkincisi daha kısa olduğundan kullanılır.

Kelimenin ilk oluşumunun değiştirilmesini dışlamak için, tam olarak bir tane almak ve daha sonra aynı kullanarak dizinleri karşılaştırmak için başka bir normal ifade arama işlevi kullandım end()

Bayrak re.Ikısa versiyonudurre.IGNORECASES