Étant donné une chaîne, mettez-la en majuscule. Par capitalisation, j'entends les conTeNT-lENgthmodifications apportées à Content-Length. Dans l'exemple, j'ai montré la chaîne avec 2 mots avec -comme limite de mot. Cependant, je m'attends à ce que vous écriviez le code de la chaîne contenant un nombre quelconque de mots séparés par un seul caractère comme limite. Cette limite peut changer à travers la chaîne.

Conditions

1. l'utilisation regular expressionsn'est pas autorisée .
2. il peut y avoir n'importe quel nombre de mots dans une phrase (chaîne).
3. chaque mot sera composé de Englishlettres [a-zA-Z]de n'importe quel cas.
4. les différents mots de la phrase seront séparés par un seul caractère. Ce personnage ne sera l'une des -, ., <space-character>, /, &, #. Vous pouvez sans risque supposer que la phrase ne contiendra aucun autre caractère que ceux mentionnés.
5. les limites des mots doivent être conservées dans la sortie.
6. le code le plus court gagne.

Par exemple, votre programme devrait sortir Begin/With.Type&Contentpour BeGin/wITH.tyPE&conTeNt.

Some test cases:
 "aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe" 
 "type&AgeNt/CC/COnteNt lEnGth#acCePT/AgeNt.RAnGe-Cc/contEnt/cODe" 
 "cc/rEspoNCe.lEngtH#tYpE-witH&UsEr/bEgIN&uSer.AGEnT&begIn/aCCEPt/Cc" 
 "lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT" 
 "contENT/ACcEpT" 
 "BeGin/wITH.tyPE&conTeNt"
 "Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with" 
 "RaNgE&COnTeNT WITh CoNTENT-TypE tyPe"
 "BEgin COdE#uSeR#aGeNt.USeR"
 "TypE LENGth"

GolfScript, 36 27 19 caractères

0\{95&+.47>32*\}%\;

Une approche GolfScript assez basique qui fonctionne pour toutes les entrées selon les spécifications. Les exemples peuvent être testés en ligne .

Python 3,22

print(input().title())

Ce code prendra une chaîne en entrée de stdin et donnera une sortie en majuscule à stdout.

par exemple:

contribution:

BEGIN/wITH.tyPe&cOnTENt

sortie:

Begin/With.Type&Content

Le code suivant est pour les entrées multilignes (si nécessaire)

Python 3, 46

import sys
for i in sys.stdin:print(i.title())

Mathematica 62

Les données

tests={"aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe","type&AgeNt/CC/COnteNt lEnGth#acCePT/AgeNt.RAnGe-Cc/contEnt/cODe","cc/rEspoNCe.lEngtH#tYpEwitH&UsEr/bEgIN&uSer.AGEnT&begIn/aCCEPt/Cc","lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT","contENT/ACcEpT","BeGin/wITH.tyPE&conTeNt","Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with","RaNgE&COnTeNT WITh CoNTENT-TypE tyPe","BEgin COdE#uSeR#aGeNt.USeR","TypE LENGth"}

Code

StringReplace[ToLowerCase@#,WordBoundary~~x_:>ToUpperCase@x]&

Usage

f["aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe"]

"Plage d’acceptation de l’agent / Type d’utilisateur. Type"

f /@ tests

{"Agent Accept / Longueur-Type User Range.Type",
"Type & Agent / Cc / Content Length # Accept / Agent.Range-Cc / Content / Code", "Cc / Responce.Length # Type-With & User / Begin & User.Agent & Begin / Accept / Cc "," Length # User.Type / Begin & Length Type / Accept # Range / Code & And-Accept / Content "," Content / Accept ",
" Begin / With.Type & Content ",
" Code.Cc # User.Length-User -Et & Type Type & Length.Type User.User & With ",
" Range & Content With Content-Type Type ",
" Begin Code # User # Agent.User ",
" Type Length "}

JavaScript (94)

prompt().split(l='').map(function(a){return l='A'>l?a.toUpperCase():a.toLowerCase()}).join('')

PHP: 78 73 65 64 caractères

$b=ucfirst;foreach(str_split($s)as$c)echo$b($c),!$b[0]=$c<A?u:l;

L'entrée est transmise $s. Il opère sur la chaîne comme un tableau de caractères.

Il s'agit d'une simple machine à 2 états. Il repose sur l'ordre lexical des chaînes et que l'analyseur suppose automatiquement que vous vouliez taper une chaîne dans certains cas.

L'état est stocké dans $bet est représenté comme le nom de la fonction qui doit être appelée sur le caractère suivant. ucfirstet lcfirstsont plus courts à taper et ont un comportement identique à strtolower/ strtouppersur les chaînes de caractères uniques. De plus, comme ils ne diffèrent que par une seule lettre, nous pouvons les utiliser efficacement pour stocker l'état. La version d'origine devait stocker l'état explicitement dans un booléen.

Comme l'écho n'imprime rien pour les booléens faux, j'ai utilisé une virgule et le ! opérateur pour "masquer" l'affectation (qui dans ce cas est véridique) dans l'instruction echo. Cela m'a permis de sauvegarder un personnage en supprimant le {}.

C, 83

n;main(c){c=getchar();putchar(c>96?n?c:(n=c-32):c&64?n?c+32:(n=c):(n=0,c));main();}

Prend des lignes stdin, les traduit en stdout. (Préfère SIGINTà EOF.)

Powershell: 37 - 43

Selon la façon dont vous souhaitez prendre l'entrée ...

Inviter l'utilisateur à entrer: 43

(Culture).TextInfo.ToTitleCase((read-host))

Prendre la contribution du pipeline: 38

(Culture).TextInfo.ToTitleCase($input)

Fournissez une entrée comme argument lors de l'exécution du script: 37

(Culture).TextInfo.ToTitleCase($args)

REMARQUE: Les scripts ci-dessus ignoreront les mots en majuscules, les laissant tels quels. Si cela doit être pris en compte, l'entrée doit être forcée en minuscules avant la conversion de casse de titre. Cela ajoute 10 caractères à la première méthode et 12 aux deux autres.

(Culture).TextInfo.ToTitleCase((read-host).ToLower())
(Culture).TextInfo.ToTitleCase("$input".ToLower())
(Culture).TextInfo.ToTitleCase("$args".ToLower())

Java - 209 caractères

class C{
public static void main(String[]a){
for(String b:a){
char[]k=b.toLowerCase().toCharArray();
for(int i=-1;i<k.length;i++){if(i<0||"-. /&#".indexOf(k[i])>=0)k[++i]=(char)(k[i]-32);}
System.out.println(k);}}}

J'ai ajouté des nouvelles lignes uniquement pour la lisibilité.

R, 143 116

Une solution un peu longue peut-être mais c'est parti:

f=function(x){a=sapply(1:nchar(x),function(y)substr(tolower(x),y,y));d=c(1,which(!a%in%letters)+1);a[d]=toupper(a[d]);cat(a,sep="")}

Légèrement non golfé et expliqué:

f <- function(x){
    #Split the string in characters and "lower-case" everything
    a <- sapply(1:nchar(x),function(y)substr(tolower(x),y,y))
    #Select the first character and each character following a 
    #character that doesn't belong to lower case alphabet
    d <- c(1,which(!a%in%letters)+1)
    #Make those ones uppercase.
    a[d] <- toupper(a[d])
    #Output (stdout) while pasting them back together.
    cat(a,sep="")
    }

Éditer : 116 caractères

Le principal défi ici est de vectoriser substr. Voici une autre façon moins verbeuse.

f=function(x){n=1:nchar(x);a=mapply(substr,tolower(x),n,n);d=c(T,!a%in%letters);a[d]=toupper(a[d]);cat(a[n],sep="")}

Dentelé:

f <- function(x){
    n <- 1:nchar(x)
    a <- mapply(substr,tolower(x),n,n)
    d <- c(T,!a%in%letters) #This has been simplified as well
    a[d] <- toupper(a[d])
    cat(a[n],sep="") #Because a is now 1 char longer than x, need to subset a
    }

Usage:

> f("aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe")
Agent Accept/Length-Type User Range.Type

Befunge 98 - 24 45

~\j:'``!3*j' -;:'``b*j:'/`!3*j' +#;:,'/`!jc#@

Écrire cela m'a fait mal au cerveau.

Cela prend l'entrée ~et si le caractère précédent était l'un des séparateurs (ou s'il n'y avait pas de caractère précédent), il s'exécute

:'``!3*j' -;

Cet extrait prend le caractère et si sa valeur ascii est supérieure ou égale à a, il en soustrait 32, le modifiant ainsi en majuscules. S'il est inférieur à a,3*j ignore le réglage. Ensuite, il saute la partie suivante. Cette partie gère le passage des majuscules aux minuscules (je suis sûr qu'elle peut être fusionnée avec la partie suivante; je ne sais pas comment):

:'``b*j:'/`!3*j' +#;

Le caractère est imprimé ( ,), puis cela vérifie si le caractère est l'une des limites:

'/`!

Il compare fondamentalement le caractère à la valeur ascii de /. Si le caractère n'est pas une frontière, le code pousse 12pour qu'il saute l'ajustement de capitalisation la prochaine fois. #saute le programme de fin:, @et si la fin de l'entrée est atteinte, ~renvoie l'exécution du code à la @fin du programme.

Rubis: 60 51 50 47 caractères

$_.downcase.chars{|c|$><<$/=$/<?0?c.upcase: c}

Exemple d'exécution:

bash-4.1$ for line in "${test[@]}"; do printf '%-75s | %s\n' "$line" "$( ruby -ne '$_.downcase.chars{|c|$><<$/=$/<?0?c.upcase: c}' <<< "$line" )"; done
aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe                                    | Agent Accept/Length-Type User Range.Type
type&AgeNt/CC/COnteNt lEnGth#acCePT/AgeNt.RAnGe-Cc/contEnt/cODe             | Type&Agent/Cc/Content Length#Accept/Agent.Range-Cc/Content/Code
cc/rEspoNCe.lEngtH#tYpE-witH&UsEr/bEgIN&uSer.AGEnT&begIn/aCCEPt/Cc          | Cc/Responce.Length#Type-With&User/Begin&User.Agent&Begin/Accept/Cc
lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT     | Length#User.Type/Begin&Length Type/Accept#Range/Code&And-Accept/Content
contENT/ACcEpT                                                              | Content/Accept
BeGin/wITH.tyPE&conTeNt                                                     | Begin/With.Type&Content
Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with           | Code.Cc#User.Length-User-And&Type Type&Length.Type User.User&With
RaNgE&COnTeNT WITh CoNTENT-TypE tyPe                                        | Range&Content With Content-Type Type
BEgin COdE#uSeR#aGeNt.USeR                                                  | Begin Code#User#Agent.User
TypE LENGth                                                                 | Type Length

C # - 110

Un traitement simple basé sur une machine à états finis:

x.Aggregate(new{b=1>0,r=""},(s,c)=>new{b="-. /&#".Contains(c),r=s.r+(s.b?Char.ToUpper(c):Char.ToLower(c))}).r

(où xest le stringpour capitaliser)

et bien sûr, si vous voulez être ennuyeux (après la mise à jour des spécifications), vous pouvez utiliser

new CultureInfo(9).TextInfo.ToTitleCase(x)

ou, avec tout le passe-partout ennuyeux:

class C{static void Main(string[]a){System.Console.WriteLine(new System.Globalization.CultureInfo(9).TextInfo.ToTitleCase(a[0]));}}

Javascript 102

prompt().split(o=q='').map(function(c){o+=(q)?c.toLowerCase():c.toUpperCase(),q=('A'>c)?0:1})
alert(o)

Forth, 135

: s swap ;
: c 1 begin key dup 96 > if s if 32 - then 0 s 
else dup 64 > if s 0= if 32 + then 0 s then else 1 s then then emit again ; c

La sortie traduite est écrite au stdoutfur et à mesure de sa lecture stdin.

Befunge-98 (29), C (65)

Puisque la méthode / l'algorithme est à peu près le même, j'inclus les deux versions dans le même article. Les deux s'appuient sur le suivi du fait que le dernier caractère était un symbole ou une lettre, afin de savoir s'il faut minuscule ou non une lettre.

#@~:'0` #v_,0>
',++@'% '<   ^

c,d;main(){for(;~(c=getchar());d=c>48)putchar(c<48?c:c&95|32*d);}

05AB1E , 1 octet

Code:

™

Explication:

™   # Implicit input which is converted to title case.

Essayez-le en ligne!

Caractères Excel VBA-11

Dans la fenêtre Exécution

?[Proper()]

VBscript

Set xlapp = CreateObject("excel.application")
wscript.echo xlapp.Evaluate("Proper(""BeGin/wITH.tyPE&conTeNt"")"

AWK, 113 103 octets

{for(;++i<=split($0,a,"");){s=a[i]
O=O (L?tolower(s):toupper(s))
L=1
if(index("-. /&#",s))L=0}print O}

Cela fonctionne très bien pour le contenu sur une seule ligne, mais pour une entrée multiligne, quelques bits doivent être ajoutés

{O=""
for(L=0;++i<=split($0,a,"");){s=a[i]
O=O (L?tolower(s):toupper(s))
L=1
if(index("-. /&#",s))L=0}print O}

Ce serait bien si nous pouvions profiter de la division automatique d'un enregistrement en champs et de la modification de ces champs, mais nous perdrions alors nos séparateurs de champs. :(

Je sais que ce n'est pas la réponse la plus golfique et c'est une question plutôt ancienne, mais je pense que AWK est sous-représenté dans l'espace de réponse de CG :)

(Merci @manatwork pour avoir testé le code, cela devrait fonctionner maintenant :) A également changé le flux mais gardé le nombre d'octets le même, en remplaçant certains ;par des sauts de ligne.)

PHP (> v5.4.32) - 25 caractères

<?=ucwords($a,'-. /&#')?>

Explication:

• ucwords () est une fonction PHP intégrée

• Le premier paramètre $aest l'entrée

• Le deuxième paramètre est le délimètre (caractères non alphabétiques trouvés dans les cas de test)

• Le retour / l'écho / l'impression est supposé en raison de l'utilisation de <?= ?>

Liens:

• Code Playground

• Fonction PHP ucwords ()

T-SQL, 179

DECLARE @T VARCHAR(MAX)='foo',@X VARCHAR(2),@ INT=0WHILE @<LEN(@T)SELECT @X=SUBSTRING(@T,@,2),@+=1,@T=STUFF(@T,@,1,IIF(@X LIKE'[a-Z]_',LOWER(RIGHT(@X,1)),UPPER(RIGHT(@X,1))))PRINT @T

Essayez la version SELECT dans SQL Server 2012 ici .

Remplacez "foo" par la chaîne d'entrée. Le nombre de caractères correspond à une chaîne de longueur nulle. Ce code traverse la chaîne à l'aide d'un index, en mettant en majuscule ou en minuscule le caractère à cette position en fonction du caractère précédent.

JavaScript (Node.js) , 70 octets

c=>a=>c.split``.map(b=>a="A">a?b.toUpperCase():b.toLowerCase()).join``

Essayez-le en ligne!

Je suis sûr que cela peut être joué plus loin.

Remarque :

Prend entrée via f(string)(), les derniers sont requis mais n'effectuent rien.

Powershell, 77 75 octets

Cette solution répond pleinement aux règles de la tâche (même exemple ambigu foo:bar).

-join($args|% t*y|%{"$_"|%('ToU*r','ToL*r')[+$l];$l=!('# -./&'|% Co*s $_)})

Voir également la solution Powershell avec fonction intégrée ToTitleCase de @Iszi.

Script de test expliqué:

$f = {

-join(
$args|% t*y|%{                   # for each char from input string
    "$_"|%('ToU*r','ToL*r')[+$l] # evaluate ToUpper or ToLower method depend on $l (lower) value
                                 # Note the variable $l is not defined for a first char
                                 # so it evaluates toUpper for the first char 
    $l=!('# -./&'|% Co*s $_)     # golfed form for $l=!'# -./&'.Contains($_) expression
                                 # =0 if the current char is specified separator (toUpper for next char)
}                                # =1 otherwise (toLower for next char)
)                                # finally, join all chars to a result string

}

@(
    ,('foo:bar'                                                                 ,'Foo:bar')
    ,('aGeNT ACcEpT/LEngTh-tYPe USeR raNgE.TyPe'                                ,'Agent Accept/Length-Type User Range.Type')
    ,('type&AgeNt/CC/COnteNt lEnGth#acCePT/AgeNt.RAnGe-Cc/contEnt/cODe'         ,'Type&Agent/Cc/Content Length#Accept/Agent.Range-Cc/Content/Code')
    ,('cc/rEspoNCe.lEngtH#tYpE-witH&UsEr/bEgIN&uSer.AGEnT&begIn/aCCEPt/Cc'      ,'Cc/Responce.Length#Type-With&User/Begin&User.Agent&Begin/Accept/Cc')
    ,('lENgTH#USeR.tYpE/BeGiN&LENGth tYpe/ACCEpt#rANge/codE&AnD-ACCepT/ConTenT' ,'Length#User.Type/Begin&Length Type/Accept#Range/Code&And-Accept/Content')
    ,('contENT/ACcEpT'                                                          ,'Content/Accept')
    ,('BeGin/wITH.tyPE&conTeNt'                                                 ,'Begin/With.Type&Content')
    ,('Code.cc#User.lenGTh-USer-AND&tyPE TypE&leNgtH.tYPe usER.UseR&with'       ,'Code.Cc#User.Length-User-And&Type Type&Length.Type User.User&With')
    ,('RaNgE&COnTeNT WITh CoNTENT-TypE tyPe'                                    ,'Range&Content With Content-Type Type')
    ,('BEgin COdE#uSeR#aGeNt.USeR'                                              ,'Begin Code#User#Agent.User')
    ,('TypE LENGth'                                                             ,'Type Length')
) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-ceq$e): $r"
}

Production:

True: Foo:bar
True: Agent Accept/Length-Type User Range.Type
True: Type&Agent/Cc/Content Length#Accept/Agent.Range-Cc/Content/Code
True: Cc/Responce.Length#Type-With&User/Begin&User.Agent&Begin/Accept/Cc
True: Length#User.Type/Begin&Length Type/Accept#Range/Code&And-Accept/Content
True: Content/Accept
True: Begin/With.Type&Content
True: Code.Cc#User.Length-User-And&Type Type&Length.Type User.User&With
True: Range&Content With Content-Type Type
True: Begin Code#User#Agent.User
True: Type Length

QBasic, 74 octets

1c$=LCASE$(INPUT$(1))
IF f=0THEN c$=UCASE$(c$)
f=c$>"@
?c$;
IF""<c$GOTO 1

Les octets sont comptés dans CP-437 ;est un octet unique (code de caractère 20).

La méthode de saisie ici est un peu étrange: les caractères sont tapés un à la fois et leur capitalisation est convertie avant d'être affichée. Ainsi, lorsque vous tapez aGeNT, il apparaît à l'écran sous la forme Agent. Frapper Entermet fin au programme.

Python 3 , 122 octets

lambda s:''.join(chr(ord(c)+[[0,0],[0,32],[-32,0]][('@'<c<'[')-('`'<c<'{')]['@'<p<'['or'`'<p<'{'])for c,p in zip(s,'-'+s))

Essayez-le en ligne!

Pas un bon score, mais je voulais l'essayer sans opérations de chaîne intégrées pour changer la casse.

PHP - 23 caractères

mb_convert_case ($ w, 2);

Il a besoin de php_mbstring pour fonctionner