Herausforderung :

Geben Sie eine Zeichenfolge an, die an bestimmten Positionen aufgeteilt ist, und schreiben Sie das erste Zeichen des angegebenen Wortes in Großbuchstaben. Aktivieren Sie das erste Zeichen des ersten Wortes genau dann, wenn es bereits aktiviert wurde

Eingabe:

Eine Zeichenfolge sund ein Zeichen c.

Ausgang:

Die Zeichenfolge bei jedem Auftreten von c durch das erste aktivierte Zeichen ersetzt

Beispiele:

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

Hinweis :

• Die angegebene Eingabe ist immer gültig. Das heißt: Die erste Zeichenfolge ist immer eine Zeichenfolge mit mindestens einer Instanz des zu ersetzenden Zeichens. Der zweite wird immer ein einzelnes Zeichen sein.
• Die Länge der Eingabezeichenfolge ist größer. 4.

• Es gibt mindestens ein Vorkommen des Zeichens, bei dem geteilt werden soll.

• Die Eingabe enthält garantiert nur Buchstaben und das Trennzeichen (Danke @Arnauld)

• Separator ist alles, was kein Alphabet ist (az / AZ) (vorgeschlagen von @Dennis)

Gewinnkriterien:

Dies ist Code-Golf, so dass der kürzeste Code in Bytes für jede Sprache gewinnt.

1. Vielen Dank an @ JonathanAllan für den Hinweis auf zwei Fehler.

Python 3 , 63 Bytes

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

Probieren Sie es online!

C (gcc) , 61 53 55 Bytes

-8 Bytes dank Dennis!

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

Probieren Sie es online!

JavaScript (ES6), 58 56 Byte

2 Bytes gespart dank @ l4m2 / @Downgoat

Übernimmt Eingaben in der Currying-Syntax (s)(c).

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

Probieren Sie es online!

Kommentiert

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 Bytes

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

Probieren Sie es online!

sed 4.2.2 (-r), 21

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

Ich habe es \Wstattdessen versucht [^a-z], aber leider passt das nicht zusammen_ .

Probieren Sie es online!

Gelee , 8 Bytes

Œt⁸1¦«⁸ḟ

Probieren Sie es online!

Wie es funktioniert

Œ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 Bytes

2 Bytes dank Luis Mendo gespeichert. upperstatt toupper.

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

Probieren Sie es online!

Wow, das ist wahrscheinlich das schmutzigste Stück Octave-Code, das ich je geschrieben habe! Diese nutzt zwei der Tricks im Thema dieser Tippfrage aufgeführten , nämlich Argumentliste und Zellenarrays.

Erläuterung:

Argumentlisten-Eingabe:

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

kHier wird das erste Zeichen snach jedem Trennzeichen cin Großbuchstaben umgewandelt. Der Index jedes großgeschriebenen Zeichens wird in gespeichert i.

Zellenarraykörper:

Wir erstellen ein Zellenarray mit zwei Elementen, von denen eines besagt, dass alle i-ten Zeichen durch das Gegenstück in kund das andere durch sdas bereits aktualisierte ersetzt werden sollen. Wir indizieren dies mit, {2}damit wir nur den gesamten, modifizierten String zurückbekommen. Diesem wird zugeführt strsplit, was es beim Trennzeichen in Zellen aufteilt. Wir konvertieren es mit in eine durch Kommas getrennte Liste {:}und verketten es mit eckigen Klammern wieder zu einer Zeichenfolge [].

Entschuldigung, wenn das für dich keinen Sinn ergeben hat ... Es ergibt für mich kaum Sinn: P

Retina 0.8.2 , 20 Bytes

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

Probieren Sie es online! Nimmt nur die Zeichenfolge, Trennzeichen optional. Alle nicht-alphabetischen Zeichen werden gelöscht, nachfolgende alphabetische Zeichen werden jedoch in Großbuchstaben geschrieben. Vorherige 34-Byte-Version akzeptiert beliebige Eingabe:

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

Probieren Sie es online! Link enthält Testsuite. Angenommen, die Eingabe besteht aus der Zeichenfolge und dem Zeichen, die zusammen verkettet sind. Erläuterung: In der ersten Stufe werden alle Zeichen, die unmittelbar auf das Auftreten des Endzeichens folgen, von Klein- nach Großbuchstaben umgeschrieben, und in der zweiten Stufe werden alle Vorkommen des Endzeichens gelöscht.

Für beide Lösungen +funktioniert auch die Verwendung einer Übereinstimmung von rechts nach links anstelle von a .

APL (Dyalog Classic) , 22 Byte

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

Probieren Sie es online!

Röda , 57 54 Bytes

-3 Bytes dank Kühe quaken

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

Probieren Sie es online!

Erläuterung:

{
  (_/`\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 Bytes

1 Byte gespart, wenn kein Argument verwendet wird

ÓÁˆ/õ±

Probieren Sie es online!

Das Programm nimmt den Text als Eingabe und das Zeichen als Argument auf.

Hexdump:

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

Dies ist eine einfache Ersetzung. Unkomprimiert sieht es folgendermaßen aus

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

Führen Sie eine globale Ersetzung durch, bei der \Aein nicht alphabetisches Zeichen, gefolgt von einem Zeichen, durch eine erste Erfassungsgruppe (.)mit Großbuchstaben ersetzt wird\u\1

Scala, 83 Bytes

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

Probieren Sie es online!

Erläuterung:

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
}                                           //

Rot , 87 Bytes

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

Probieren Sie es online!

05AB1E , 9 Bytes

¡ćsvyćusJ

Probieren Sie es online!

Erläuterung

¡           # 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 Bytes

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

Laufen Sie mit -r. War mit split 2 Byte kürzer als explodiert, aber ^ test schlägt aufgrund von Regex fehl.

-8 danke an med

Groovy, 43 Bytes, 45 Bytes

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

Probieren Sie es online aus . Die Testsuite ist ohne das letzte Element enthalten, da das Trennzeichen fehlt c.

Gehen, 138 92 87 Bytes

Fiel 46 Bytes dank @Dennis 'Titel Fall Idee.

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

Probieren Sie es online!

Schale , 10 Bytes

ΣΓ·:mΓo:ax

Probieren Sie es online!

Erläuterung

ΣΓ·: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 Bytes

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

Probieren Sie es online!

Java 10, 141 Bytes

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;}

Probieren Sie es online aus.

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Verwendet diesen Trick kann nicht richtig in TIO ausgeführt werden, so habe ich es simuliert.

Wir brauchen das Tsonst einer der Testfälle ausfällt.

Stax , 11 Bytes

óKo{cplòüö\

Führen Sie es aus und debuggen Sie es

Erläuterung

/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

Es gibt ein paar Teile, die ich gerne irgendwie reparieren würde. Ich kann es auf ungefähr 8 Bytes reduzieren, aber es schlägt im letzten Testfall>. <Fehl

Ruby -pl , 36 Bytes

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

Probieren Sie es online!

Nimmt nur den String ohne zweites Argument. Verwendet die Blockversion der gsub!Methode, da sie mit gängiger gsub! x,ySyntax $1nicht ohne weiteres mit Übereinstimmungsdaten gefüllt wird. |$in Regex ist für den Testfall mit Trennzeichen am Ende erforderlich.

Python 3 , 77 Bytes

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

Probieren Sie es online!

Dies setzt voraus , dass die Zeichenfolge ASCII codiert ist , und geht davon aus, daß sund csind Variablen, die das Eingangs vorbelastet.

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

Diese Lösung basiert auf der Tatsache, dass bei der ASCII-Codierung Kleinbuchstaben 32 Einträge nach Großbuchstaben stehen

Bearbeiten: Ich habe gerade festgestellt, dass dies auch das erste Zeichen in der Zeichenfolge großschreibt, was es nicht sollte. aber ich bin ziemlich stolz auf meinen Unsinn, also lasse ich das, wenn das erlaubt ist