Défi :

Étant donné une chaîne divisée à des positions spécifiques et en majuscule le premier caractère du mot donné. Mettre en majuscule le premier caractère du premier mot si et seulement s'il était déjà en majuscule

Contribution :

Une chaîne set un caractère c.

Sortie:

La chaîne à chaque occurrence de cremplacée par le premier caractère en majuscule

Exemples :

STRING(s)             CHARACTER(c)  RESULT
Hello_world           _             HelloWorld
me,no,like            ,             meNoLike
you-got-it            -             youGotIt
Am^I^clear            ^             AmIClear
go!full!caps          !             goFullCaps
weird&but&tRue        &             weirdButTRue
ProbleM1fixed1no      1             ProbleMFixedNo
!prob!!lem!s!Olved!!  !             ProbLemSOlved

Remarque :

• L'entrée donnée sera toujours valide. ie: La première sera toujours une chaîne avec au moins une instance du caractère à remplacer à. Le second sera toujours un seul caractère.
• La longueur de la chaîne d'entrée sera supérieure 4.

• Il y aura au moins une occurrence du personnage à diviser.

• L'entrée est garantie pour ne contenir que des lettres et le séparateur (Merci @Arnauld)

• Le séparateur est tout ce qui n'est pas un alphabet (az / AZ) (suggéré par @Dennis)

Critères gagnants:

C'est le code-golf donc le code le plus court en octets pour chaque langue gagne.

1. Merci à @JonathanAllan d'avoir signalé deux erreurs.

Python 3 , 63 octets

lambda s,c:''.join(map(min,s,s[0]+s.title()[1:])).replace(c,'')

Essayez-le en ligne!

C (gcc) , 61 53 55 octets

-8 octets grâce à Dennis!

f(s,c)char*s;{for(;*s;putchar(*s++))if(*s==c)*++s&=95;}

Essayez-le en ligne!

JavaScript (ES6), 58 56 octets

2 octets enregistrés grâce à @ l4m2 / @Downgoat

Prend des entrées dans la syntaxe de curry (s)(c).

s=>c=>s.replace(u=/./g,x=>u=x==c?'':u?x:x.toUpperCase())

Essayez-le en ligne!

Commenté

s => c =>                  // given s and c
  s.replace(u = /./g, x => // initialize u to a RegExp; replace each character x in s with,
    u =                    // and update u to:
      x == c ?             //   if x is the separator:
        ''                 //     an empty string
      :                    //   else:
        u ?                //     if u is not an empty string:
          x                //       x unchanged
        :                  //     else:
          x.toUpperCase()  //       x capitalized
  )                        // end of replace()

Perl 6 -p , 19 octets

s:g[<:!L>(.)]=$0.uc

Essayez-le en ligne!

sed 4.2.2 (-r), 21

s/[^a-z]+(.)?/\u\1/gi

J'ai essayé à la \Wplace de [^a-z], mais malheureusement cela ne correspond pas _.

Essayez-le en ligne!

Gelée , 8 octets

Œt⁸1¦«⁸ḟ

Essayez-le en ligne!

Comment ça fonctionne

Œt⁸1¦«⁸ḟ  Main link. Left argument: s (string). Right argument: c (character).

Œt        Title case; capitalize the first character of each word.
  ⁸1¦     Replace the first character of the result with the first character of s.
     «⁸   Take the character-wise minimum of the result and s.
          Note that uppercase letters have lower code points than lowercase ones.
       ḟ  Filterfalse; remove all occurrences of c.

Octave , 83 , 66 , 64 octets

Enregistré 2 octets grâce à Luis Mendo. upperau lieu de toupper.

@(s,c,k=upper(s(i=find(s==c)+1)))[strsplit({s(i)=k,s}{2},c){:}];

Essayez-le en ligne!

Wow, c'est probablement le morceau d'Octave-code le plus salissant que j'aie jamais écrit! Cela utilise deux des astuces publiées dans cette question de conseils, à savoir la liste d'arguments et les tableaux de cellules.

Explication:

Entrée de liste d'arguments:

@(s,c,k        % An anonymous function that may take three input variables, s, c, k
               % where the third argument has the default value:
 k=upper(s(i=find(s==c)+1))

kest ici le premier caractère saprès chaque séparateur c, converti en majuscules. L'index de chaque caractère en majuscule est stocké dans i.

Corps du réseau cellulaire:

Nous créons un tableau de cellules avec deux éléments, l'un étant que nous disons que tous les ièmes caractères devraient être remplacés par son homologue dans k, et l'autre avec s, qui est maintenant déjà mis à jour. Nous indexons cela à l'aide de {2}sorte que nous ne récupérons que la chaîne entière modifiée. Ce dernier est alimenté strsplit, ce qui le divise en cellules au niveau du séparateur. Nous le convertissons en une liste séparée par des virgules en utilisant {:}et le concaténons en une chaîne en utilisant des crochets [].

Toutes mes excuses si cela n'a aucun sens pour vous ... Cela n'a guère de sens pour moi: P

Retina 0.8.2 , 20 octets

T`lLp`LL_`[\W\d_]+.?

Essayez-le en ligne! Prend la chaîne uniquement, séparateur en option. Tous les caractères non alphabétiques sont supprimés mais tout caractère alphabétique suivant est en majuscule. La version précédente de 34 octets acceptait les entrées arbitraires:

T`l`L`(?=.*(.)$)\1+.
(?=.*(.)$)\1

Essayez-le en ligne! Le lien inclut une suite de tests. Suppose que l'entrée se compose de la chaîne et du caractère concaténés ensemble. Explication: La première étape translitère tous les caractères immédiatement après les occurrences du caractère de fin de minuscules en majuscules et la deuxième étape supprime ensuite toutes les occurrences du caractère de fin.

Pour les deux solutions, l'utilisation d'une correspondance de droite à gauche au lieu d'un +fonctionne également.

APL (Dyalog Classic) , 22 octets

{⍵~⍨1(819⌶@(⍵=¯1⌽⊢))⍺}

Essayez-le en ligne!

Röda , 57 54 octets

-3 octets grâce au charlatan des vaches

{(_/`\Q$_`)|{pull;[upperCase(_[:1]),_1[1:]]if[#_1>0]}}

Essayez-le en ligne!

Explication:

{
  (_/`\Q$_`)| /* Pull two strings and split the first with the second */
  {
    pull;                /* Pull one string and print it */
                         /* For each string _1 in the stream: */
                         /*   If _1 is not empty: */
    [                    /*     Print: */
      upperCase(_[:1]),  /*       The first character capitalized */
      _1[1:]             /*       The rest of characters */
    ]if[#_1>0]           /*   End if */
  }
}

V , 6 7 octets

1 octet enregistré en n'utilisant pas d'argument

ÓÁˆ/õ±

Essayez-le en ligne!

Le programme prend le texte en entrée et le caractère en argument.

Hexdump:

00000000: d3c1 882f f5b1                           .../..

Il s'agit d'une simple substitution. Non compressé, il ressemble à ce qui suit

:s/\A(.)/\u\1/g

Effectuer une substitution globale dans laquelle \A, un caractère non alphabétique, suivi d'un caractère (.)est remplacé par le \upremier groupe de capture en majuscules\1

Scala, 83 octets

def f(s:String)={val w=s.split("[^a-zA-Z]");w(0)+w.tail.map(_.capitalize).mkString}

Essayez-le en ligne!

Explication:

def f(s: String) = {                        // takes a String "s" as input
  val w = s.split("[^a-zA-Z]");             // split on non-alpha chars
  w(0) + w.tail.map(_.capitalize).mkString  // upper case first letter of all words except first one and join array into a String
}                                           //

rouge , 87 octets

func[s c][b: split s c prin b/1 foreach w next b[if w <>""[w/1: uppercase w/1 prin w]]]

Essayez-le en ligne!

05AB1E , 9 octets

¡ćsvyćusJ

Essayez-le en ligne!

Explication

¡           # split the string on the char
 ć          # extract the head of the resulting list
  s         # swap the head to the bottom of the stack
   vy       # for each string y in the rest of the list
     ću     # extract the head and capitalize it
       s    # swap it below the rest of the string
        J   # join everything to one string

PHP, 91 83 octets

$a=explode($argv[2],$argv[1]);echo array_shift($a);foreach($a as$i)echo ucfirst($i);

Courir avec -r . Était de 2 octets plus court en utilisant split au lieu d'exploser, mais ^ test échoue en raison de l'expression régulière.

-8 grâce à Med

Groovy, 43 octets, 45 octets

s.replaceAll(/\$c(.)/){it[1].toUpperCase()}

Essayez-le en ligne . Suite de tests incluse excluant le dernier élément car il manque le caractère séparateur c.

Aller, 138 92 87 octets

A chuté de 46 octets grâce à @Dennis idée de cas de titre .

func f(s,d string){p:=Split(s,d);Print(p[0]+Replace(Title(Join(p[1:]," "))," ","",-1))}

Essayez-le en ligne!

Husk , 10 octets

ΣΓ·:mΓo:ax

Essayez-le en ligne!

Explication

ΣΓ·:mΓ(:a)x  -- example inputs: 'x' "abxbcxcdxdex"
          x  -- split on character: ["ab","bc","cd","de"]
 Γ           -- pattern match (x = head) (xs = tail) and do..
  ·:         -- | construct list (x:xs) but with the second argument do..
    m        -- | | map (eg. "bc")
     Γ(  )   -- | | | pattern match on first character
      ( a)   -- | | | | upper-case it
      (: )   -- | | | | and join again
             -- | | | : "Bc"
             -- | | : ["Bc","Cd","De"]
             -- : ["ab","Bc","Cd","De"]
Σ            -- concatenate: "abBcCdDe"

F # (Mono) , 122 octets

let f(s:string)c=s|>Seq.mapi(fun i x->if i>0&&s.[i-1]=c then Char.ToUpper(x)else x)|>Seq.where((<>)c)|>Seq.toArray|>String

Essayez-le en ligne!

Java 10, 141 octets

s->c->{var r=s.split("\\"+c);var r=a[0],t;for(int i=0;++i<a.length;r+=t.isEmpty()?"":(char)(t.charAt(0)&~32)+t.substring(1))t=a[i];return r;}

Essayez-le en ligne.

Explication:

s->c->{                    // Method with String and character parameters and String return-type
  var r=s.split("\\"+c);   //  Split String by character (with potential regex char)
  var r=a[0],              //  Result-String, starting at the first item
      t;                   //  Temp-String to reduce bytes
  for(int i=0;++i<a.length;//  Loop in the range [1, length_of_array)
      r+=                  //    After every iteration: append the result-String with:
         t.isEmpty()?      //     If the current item empty:
          ""               //      Append nothing
         :                 //     Else:
          (char)(t.charAt(0)&~32)
                           //      Capitalize the first character
          +t.substring(1)) //     And append the other characters as is
    t=a[i];                //   Set `t` to the current String-item of the array
  return r;}               //  Return the result-String

R , 87 octets

g<-function(s,x,z=strsplit(s,x,T)[[1]])cat(z[1],capwords(z[-1]),sep="")
example(chartr)

Essayez-le en ligne!

Utilise cette astuce ne peut pas être correctement exécutée dans TIO donc je l'ai simulée.

Nous avons besoin de l' Tun sinon les cas de test échouent.

Stax , 11 octets

óKo{cplòüö\

Exécuter et déboguer

Explication

/BsF1:/s^s|dl                 # Full Program, unpacked, Implicit Input
/                             # Split on substrings (Split input with symbol to split on)
 B                            # Remove first element from array. Push the tail of the array, then the removed element.
  s                           # Swap first two elements of stack
   F                          # Start for loop
    1:/                       # Split array at index; push both parts.
       s^s                    # Swap first two elements of stack, capitalize character, swap first two elements 
         |dl                  # Get length of stack, listify that amount (entire stack), implicit output of array

Il y a quelques parties que j'aimerais vraiment corriger d'une manière ou d'une autre. Je peux le réduire à environ 8 octets, mais il échoue sur le dernier cas de test>. <

Rubis -pl , 36 octets

$_.gsub!(/[^a-z]+(.|$)/i){$1.upcase}

Essayez-le en ligne!

Prend uniquement la chaîne sans deuxième argument. Utilise la version de bloc de la gsub!méthode car avec une gsub! x,ysyntaxe commune, il $1n'est pas facile de remplir les données de correspondance. |$en regex est nécessaire pour le cas de test avec séparateur à la fin.

Python 3 , 77 octets

o=[]
for x in s.split(c): o.append(chr(ord(x[0])-32)+x[1:])
print(''.join(o))

Essayez-le en ligne!

Cela suppose que la chaîne est codée ASCII et suppose que set csont des variables préchargées contenant l'entrée.

for x in s.split(x)       #loop through items in the string s split by x
    o.append(             #add the following to c
        chr(              #turn the following number into a character
            ord(          #turn the following character into a number
                x[0]      #the first character in string x
            )-32          #subtract 32 from this number
        +x[1:]            #add everything past and including the second character in string x

Cette solution fonctionne sur le fait que dans le codage ASCII, les lettres minuscules sont positionnées 32 entrées après les lettres majuscules

Edit: je viens de réaliser que cela met également en majuscule le premier caractère de la chaîne, ce qui ne devrait pas être le cas. mais je suis assez fier de mes bêtises, donc je vais laisser ça si c'est permis