A menos que você tenha um script de usuário que modifique o design do site (ou mesmo se houver), você deve ter notado que temos o design do site!

_{^{(Agora é novembro)}}

Então, para comemorar, vamos criar um programa que aplique retroativamente esse design (simplificado demais, é claro)!

Portanto, as mudanças mais importantes são:

• nosso novo nome agora é Code Golf and Coding Challenges
• nosso site não é mais a cor azul padrão e é um bom verde escuro

Então, dada uma string, mude:

• PPCG para CGCC
• Programming Puzzles {non-whitespace} Code Golfpara Code Golf {same-thing} Coding Challenges(por exemplo, Programming Puzzles + Code Golf, and Code Golfe & Code Golftudo seria alterado para Code Golf + Coding Challenges, and Coding Challenges, e & Coding Challenges.
• #abcpara #acb(alternar azul para verde e vice-versa - apenas ignore o fato de que o verde não deve logicamente se tornar azul, mas não quero complicar a mudança de cor)
• #abcdefpara #abefcd(o mesmo que acima)

Observe que, para as trocas de cores, você deve aceitar qualquer dígito hexadecimal de 0-9a a-f. Você pode escolher qual caso de dígito hexadecimal exigir, mas deve ser consistente e o mesmo da entrada à saída.

Suas substituições podem fazer distinção entre maiúsculas e minúsculas e, caso contrário, especifique como a saída funciona.

As substituições só devem acontecer quando a string estiver cercada por limites de palavras (incluindo o início da #). Em outras palavras, cada uma das substituições especificadas deve ocorrer apenas se a correspondência estiver na borda da sequência ou for delimitada por caracteres não alfanuméricos (nos dois lados).

Aplicam-se brechas padrão. Este é um desafio do código-golfe, portanto o código mais curto vence!

Exemplos

PPCG -> CGCC
Programming Puzzles or Code Golf -> Code Golf or Coding Challenges
PPCG stands for Programming Puzzles and Code Golf and its site color is #abf -> CGCC stands for Code Golf and Coding Challenges and its site color is #afb
The color #00f is much more intense than #5568ed -> The color #0f0 is much more intense than #55ed68
Programming Puzzles and No Substitution -> Programming Puzzles and No Substitution
No Substitution and Code Golf -> No Substitution and Code Golf
Programming Puzzles and no substitution Code Golf -> Programming Puzzles and no substitution Code Golf
Code Golf and Programming Puzzles -> Code Golf and Programming Puzzles
Programming Puzzles and Programming Puzzles and Code Golf -> Programming Puzzles and Code Golf and Coding Challenges

(para o último caso de teste, é importante observar que a sequência traduzida pode ser convertida novamente, mas a transformação deve ser aplicada exatamente uma vez)

Atualização importante

(Obrigado @tsh)

A Programming Puzzles ... Code Golfregra de substituição pode incluir as outras regras dentro dela ( Programming Puzzles PPCG Code Golfé válida). Nesse caso, você pode escolher se as regras são ou não aplicadas, mas devem ser determinísticas. Não estou exigindo que você seja consistente entre PPCGe #...porque as respostas parecem implementar as regras em minha ordem de lista, o que resulta em inconsistências. Isso é apenas um esclarecimento; Eu acredito que todas as respostas atuais permanecem válidas.

Ruby -p , 165 164 159 bytes

Acabou sendo muito semelhante à resposta sed, mas abusa da interpolação de strings de Ruby para duplicar a correspondência de grupo hexadecimal ([\da-f]{1,2})no terceiro regex três vezes, em vez de precisar repetir a coisa toda novamente.

• -1 byte de @ randomdude999.
• -5 bytes de alavancar a solução Perl da Xcali

gsub /\bPPCG\b/,"CGCC"
gsub /\bProgramming Puzzles( \S+ )(Code Golf)\b/,'\2\1Coding Challenges'
[1,2].map{|i|gsub /(^|\s)#\K#{'([\da-f]{%d})'%i*3}\b/,'\2\4\3'}

Experimente online!

C ++ (GCC) , 270 285 283 bytes

Agradecemos a Neil por apontar um bug.

-2 bytes graças ao ceilingcat.

#import<regex>
#import<string>
auto f=[](auto s){typeof(s)R[][2]{"bPPCG","CGCC","bProgramming Puzzles( \\S+ )(Code Golf)","$2$1Coding Challenges","B#(?=([\\da-f]{3}){1,2}\\b)(.+?)(..??)(..??)","#$2$4$3"};for(auto r:R)s=std::regex_replace(s,std::regex('\\'+*r+"\\b"),r[1]);return s;};

Experimente online!

Retina 0.8.2 , 153 130 bytes

\bPPCG\b
CGCC
\bProgramming Puzzles( \S+ )(Code Golf)\b
$2$1Coding Challenges
\B(#(?=([\da-f]{3}){1,2}\b).+?)(..??)(..??)\b
$1$4$3

Experimente online! O link inclui casos de teste. Todas as substituições diferenciam maiúsculas de minúsculas. Supõe que os caracteres normais da palavra regex sejam aceitáveis, de modo que \B#corresponda apenas aos #s que não seguem um caractere de palavra. Editar: salvou 22 bytes graças a @tsh.

GNU sed -E, 198 caracteres

s/\bPPCG\b/CGCC/g
s/\bProgramming Puzzles( \S* Cod)e Golf\b/Code Golf\1ing Challenges/g
s/((^|\W)#[0-9a-f])([0-9a-f])([0-9a-f])\b/\1\4\3/g
s/((^|\W)#[0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})\b/\1\4\3/g

Executável usando, por exemplo sed -E 'the above'; as novas linhas podem ser incluídas literalmente ou substituídas por, ;se você desejar. Ambos funcionam.

@HyperNeutrino, essa regra de limite de palavras é estúpida. Olha o que eu tinha que fazer no #caso.

Sim, eu nem tentei. : P

+9 por @Value Ink

Stax , 85 bytes

ì▀¼FΣ¼≤C╛╓ÄydîNû►┘Δ▲Bd♫|α╒oñFτ▒t!↑▌╩┘♦pMc6Hèé▄·│╝∙↔¥^4b5╠·9█&╨^╨♂═î£ε■屫\┴J₧å♠Å≡z╜û♀

Execute e depure

05AB1E , 123 109 105 110 114 bytes

žKISå_Å¡JεÐć'#QsžhA6£«sSåP*i3äćsRJ«ë"PPCG"Qi"CGCC"]J”–±ÇÀ”DU¡ćsε”ƒËŠˆ”©¡DVćDÁ2ôεðå}ćs_P*YyÊP*i”Âïªï”«s®ý«®ìëyXì]J«

+5 bytes corrigindo casos de teste como Programming Puzzles and no substitution Code Golfe Programming Puzzles and Programming Puzzles and Code Golf.
+4 bytes corrigindo casos de teste como color-#00f(cores com algo além de espaços / novas linhas ao redor). Obrigado a @Grimy por trazer isso à minha atenção.

Maiúsculas e Minúsculas. Valores hexadecimais estão em minúsculas abcdef; Programming Puzzles ... Code Golfestá em titlecase; PPCGestá em maiúsculas.

Experimente online.

Definitivamente, não é o idioma certo para o trabalho. Imitar limites de palavras e substituí-los Programming Puzzles \S+ Code Golf, mas não Code Golf \S+ Programming Puzzlesou Programming Puzzles \S+ \S+ Code Golfsem nenhuma expressão regular, é bastante difícil (para resumir) ..>.>

Explicação:

žK                # Push "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                  # (NOTE: if '_' also count as word boundary, use `žj` instead)
  IS              # Push the input as a list of characters
    å_            # Check for each character if they are NOT in the string
      Å¡          # Split the (implicit) input on truthy values
        J         # Join each inner character list to a string again
ε                 # Map each word to:
 Ð                #    Triplicate the word
  ć               #    Extract head; push remainder and head separately to the stack
   '#Q           '#    Check if the head equals "#"
    žh            #    Push string "0123456789"
      A6£«        #    Append the first 6 letters of the alphabet: "0123456789abcdef"
   s      sSåP    #    Check if the characters of the remainder are all in this string
   *i             #    If both are truthy:
     3ä           #     Split the 'word' into three parts
                  #      i.e. "#ab12cd" → ["#ab","12","cd"]
       ćs         #     Extract head, and swap
         R        #     Reverse the remainder list
          J«      #     Join them together, and merge them to the head again
    ë"PPCG"Qi     #    Else-if the word is "PPCG":
     "CGCC"       #     Push "CGCC"
                  #    (Implicit else:
                  #      Use the word that's still there from the initial triplicate)
]                 # Close all if statements and the nested map
 J                # Join the mapped words together again
”–±ÇÀ”            # Push dictionary string "Programming Puzzles"
      DU          # Save a copy in variable `X`
        ¡         # Split the string by this
         ćs       # Extract head & swap; pushing head and remainder to the stack
ε                 # Map each substring `y` in the remainder to:
 ”ƒËŠˆ”           #  Push dictionary string "Code Golf"
       ©          #  Save it in variable `®` (without popping)
        ¡         #  Split the current substring we're mapping by it
         DV       #  Save a copy of this list in variable `Y`
           ćD     #  Extract the head and duplicate
                  #  (so the stack is: remainder, head, head)
 Á                #  Rotate the characters in the head-string once towards the right
  2ô              #  Split it into parts of size 2
    εðå}          #  Check in each part if it contains a space
        ćs        #  Extract head and swap again
          _       #  Check if all values are 0
           P      #  And check if this is truthy for all
          *       #  And check if this is truthy, as well as the head
                  #  (this means the current string has a leading and trailing space,
                  #   and no other spaces)
 YyÊP             #   Check that none of the susbtrings in variable `Y`
                  #   are equal to the current substring `y`
 *i               #   If both checks above are truthy:
   ”Âïªï”«        #    Prepend "Coding Challenges" to the duplicated head
          s®ý     #    Join the remainder by variable `®` ("Code Golf")
             «    #    Append it
              ®ì  #    And prepend an additional variable `®` ("Code Golf")
  ë               #   Else:
   y              #    Simply keep the substring `y` as is
    Xì            #    And prepend variable `X` ("Programming Puzzles") 
                  #    since we've split by it
]                 # Close all if-else statements and the map
 J                # Join the mapped substrings together to a single string
  «               # And append it to the initially extracted head
                  # (then output the resulting string implicitly as result)

Veja esta dica 05AB1E (seção Como usar o dicionário? ) Para entender por que ”–±ÇÀ”é "Programming Puzzles"; ”ƒËŠˆ”é "Code Golf"; e ”Âïªï”é "Coding Challenges".

Python 2 , 240 bytes

import re
lambda x,s=re.sub,b='(?<!\w)',e='(?!\w)',h='([\da-f]',t=r'#\1\3\2':s(b+'#%s{2})'%h+h+'{2})%s{2})'%h+e,t,s(b+'#%s)'%h+h+')%s)'%h+e,t,s(b+'Programming Puzzles( \S+ Cod)e Golf'+e,r'Code Golf\1ing Challenges',s(b+'PPCG'+e,'CGCC',x))))

Experimente online!

JavaScript (Node.js) , 174 bytes

s=>s[R='replace'](/\bPPCG\b/g,'CGCC')[R](/\bProgramming Puzzles( \S+ )(Code Golf)\b/g,'$2$1Coding Challenges')[R](/\B#(?=([\da-f]{3}){1,2}\b)(.+?)(..??)(..??)\b/ig,'#$2$4$3')

Experimente online!

Pyth , 177 173 162 142 bytes

J::jb.z"\\bPPCG\\b""CGCC"." z¶NZI°Pÿúd(MÜ_BöIkxnqä'u)"." s6#~ÍN³=<nñu/GÎg"VS2~:J%"(^|\W)#%s\\b"*3%"([\da-f]{%d})"N$r"\1#\2\4\3"$)J

Aqui está uma versão sem os mecanismos de compactação de string do Pyth (também conhecido como copiar e colar):

J::jb.z"\\bPPCG\\b""CGCC""\\bProgramming Puzzles( \S+ )(Code Golf)\\b""\\2\\1Coding Challenges"VS2~:J%"(^|\W)#%s\\b"*3%"([\da-f]{%d})"N$r"\1#\2\4\3"$)J

Experimente online!

Isso acabou sendo muito longo, porque eu tentei ser o mais pedante possível com as expressões regulares. Tentei comprimir todas as seqüências possíveis, mas a maioria delas não ficou menor ou não pôde ser colada no TIO corretamente.

Explicação:

J::                      # definition of J to the following 2 regex replacements
   jb.z                  # input to first regex replacement: all input lines joined together
   "\\bPPCG\\b"          # first regex
   "CGCC"                # first replacement
   ."<compressed>"       # second regex: "\\bProgramming Puzzles( \S+ )(Code Golf)\\b"
   ."<compressed>"       # second replacement: "\\2\\1Coding Challenges"
VS2                      # loop twice, N = 1 or 2
  ~:J                    # some weird assignment: J = regex replace in J (would be J := (regex, replacement) if : was python's regex replace operator)
    %                    # third regex: string format
     "(^|\W)#%s\\b"      # format string
     *3                  # repeat 3 times:
       %"([\da-f]{%d})"N # string format, replace %d with N (the loop counter)
    $r"\1#\2\4\3"$       # third replacement: uses python raw literals because it's shorter than escaping the backslashes
    )                    # end for loop
J                        # print J

• -11 graças a uma melhor expressão regular da resposta Ruby da Value Ink
• -20 graças ao uso de um loop para as duas substituições hexadecimais, inspiradas nas respostas Ruby e Perl

Perl 5 -p , 152 145 bytes

@ValueInk salva 7 bytes

s/\bPPCG\b/CGCC/g;s/\bProgramming Puzzles( \S+ )(Code Golf)\b/$2$1Coding Challenges/g;for$a(1,2){$p="([a-f0-9]{$a})"x3;s/(^|\s)#\K$p\b/$2$4$3/gi}

Experimente online!

Java 8, 192 bytes

s->s.replaceAll("\\bPPCG\\b","CGCC").replaceAll("\\bProgramming Puzzles( \\S+ )(Code Golf)\\b","$2$1Coding Challenges").replaceAll("\\B(#(?=([0-9a-f]{3}){1,2}\\b).+?)(..??)(..??)\\b","$1$4$3")

Porto de @Neil resposta Retina 's , por isso, certifique-se de upvote-lo!

Experimente online.