A meno che tu non abbia uno script utente che modifica il design del sito (o anche in questo caso), dovresti aver notato che abbiamo il nostro design del sito!

_{^{(È novembre ora)}}

Quindi, per festeggiare, facciamo un programma che applica retroattivamente questo design (semplificato, ovviamente)!

Quindi, i cambiamenti più importanti sono:

• il nostro nuovo nome è ora Code Golf e Coding Challenges
• il nostro sito non è più il colore blu predefinito ed è invece un bel verde scuro

Quindi, data una stringa, cambia:

• PPCG per CGCC
• Programming Puzzles {non-whitespace} Code Golfa Code Golf {same-thing} Coding Challenges(per esempio Programming Puzzles + Code Golf, and Code Golfe & Code Golfsarebbero tutti essere sostituito con Code Golf + Coding Challenges, and Coding Challengese & Coding Challenges.
• #abca #acb(blu di swap al verde e viceversa - basta ignorare il fatto che il verde non dovrebbe logicamente diventare blu, ma io non voglio complicare il colore shifting)
• #abcdefa #abefcd(come sopra)

Si noti che per gli scambi di colore, è necessario accettare qualsiasi cifra esadecimale da 0-9a a-f. È possibile scegliere quale caso di cifra esadecimale richiedere, ma deve essere coerente e uguale dall'input all'output.

Le sostituzioni possono fare distinzione tra maiuscole e minuscole e, in caso contrario, specificare come funziona l'output.

Le sostituzioni dovrebbero avvenire solo quando la stringa è circondata da limiti di parole (incluso l'inizio di #). In altre parole, ciascuna delle sostituzioni specificate dovrebbe verificarsi solo se la corrispondenza è sul bordo della stringa o è delimitata da caratteri non alfanumerici (su entrambi i lati).

Si applicano scappatoie standard. Questa è una sfida di code-golf, quindi vince il codice più corto!

Esempi

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

(per l'ultimo caso di test, è importante notare che la stringa tradotta potrebbe essere nuovamente tradotta ma la trasformazione deve essere applicata esattamente una volta)

Aggiornamento importante

(Grazie @tsh)

La Programming Puzzles ... Code Golfregola di sostituzione può includere le altre regole al suo interno ( Programming Puzzles PPCG Code Golfè valida). In questo caso, puoi scegliere se applicare o meno le regole, ma deve essere deterministico. Non sto richiedendo che tu sia coerente tra PPCGe #...perché le risposte sembrano implementare le regole nel mio elenco di ordinamenti che si traducono in incoerenze. Questo è solo un chiarimento; Credo che tutte le risposte attuali rimangano valide.

Rubino -p , 165 164 159 byte

Finì per essere molto simile alla risposta sed, ma abusa dell'interpolazione di stringhe di Ruby per duplicare la corrispondenza del gruppo esadecimale ([\da-f]{1,2})entro la terza regex tre volte invece di dover ripetere di nuovo il tutto.

• -1 byte da @ randomdude999.
• -5 byte sfruttando la soluzione Perl di 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'}

Provalo online!

C ++ (gcc) , 270 285 283 byte

Grazie a Neil per aver segnalato un bug.

-2 byte grazie a 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;};

Provalo online!

Retina 0.8.2 , 153 130 byte

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

Provalo online! Il link include casi di test. Tutte le sostituzioni fanno distinzione tra maiuscole e minuscole. Presuppone che siano accettabili caratteri normali di parole regex in modo che \B#corrispondano solo a #s che non seguono un carattere parola. Modifica: salvato 22 byte grazie a @tsh.

GNU sed -E, 198 caratteri

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

Eseguibile usando ad esempio sed -E 'the above'; le nuove righe possono essere incluse letteralmente o sostituite ;se lo desideri. Entrambi funzionano.

@HyperNeutrino dai che la parola regola del confine è stupida. Guarda cosa dovevo fare nel #caso.

Sì, non ci ho nemmeno provato. : P

+9 di @Value Ink

Stax , 85 byte

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

Esegui ed esegui il debug

05AB1E , 123 109 105 110 114 byte

ž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 byte che risolvono casi di test come Programming Puzzles and no substitution Code Golfe Programming Puzzles and Programming Puzzles and Code Golf.
+4 byte che risolvono casi di test come color-#00f(colori con qualcosa oltre agli spazi / nuove righe che lo circondano). Grazie a @Grimy per avermi portato alla mia attenzione.

Che tiene conto del maiuscolo o minuscolo. I valori esadecimali sono in minuscolo abcdef; Programming Puzzles ... Code Golfè in titlecase; PPCGè in maiuscolo.

Provalo online.

Sicuramente non è la lingua giusta per il lavoro. Imitare i confini delle parole e sostituirli Programming Puzzles \S+ Code Golf, ma non Code Golf \S+ Programming Puzzleso Programming Puzzles \S+ \S+ Code Golfsenza regex è piuttosto difficile (per farla breve) ..>.>

Spiegazione:

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

Vedere questo 05AB1E punta del mio (sezione Come utilizzare il dizionario? ) Per capire perché ”–±ÇÀ”è "Programming Puzzles"; ”ƒËŠˆ”è "Code Golf"; ed ”Âïªï”è "Coding Challenges".

Python 2 , 240 byte

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

Provalo online!

JavaScript (Node.js) , 174 byte

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

Provalo online!

Pyth , 177 173 162 142 byte

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

Ecco una versione senza i meccanismi di compressione delle stringhe di Pyth (ovvero è sicuro copiare e incollare):

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

Provalo online!

Questo alla fine è stato molto lungo perché ho cercato di essere il più pedante possibile con le regex. Ho provato a comprimere tutte le stringhe possibili, ma la maggior parte di esse non si è ridotta o non è stata incollata correttamente in TIO.

Spiegazione:

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 grazie a una regex migliore dalla risposta Ruby di Value Ink
• -20 grazie all'utilizzo di un loop per entrambi i sostituti esadecimali, ispirato alle risposte Ruby e Perl

Perl 5 -p , 152 145 byte

@ValueInk salva 7 byte

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}

Provalo online!

Java 8, 192 byte

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

Port of @Neil 's Retina answer , quindi assicurati di votarlo!

Provalo online.