Давши рядок, використовуйте великі літери. Під капіталізацією я маю на увазі conTeNT-lENgthзміни до Content-Length. У прикладі я показав рядок із 2-х слів у -якості межі слова. Однак я очікую, що ви напишете код для рядка, що містить будь-яку кількість слів, розділених одним символом як границю. Ця межа може змінюватися через рядок.

Умови

1. використовуючи regular expressionsце не допускається .
2. в реченні (рядок) може бути будь-яка кількість слів.
3. кожне слово буде складатися з Englishбукв [a-zA-Z]будь-якої справи.
4. різні слова в реченні будуть відокремлені одним символом. Цей символ буде тільки бути одним з -, ., <space-character>, /, &, #. Можна сміливо припускати, що речення не буде містити жодного іншого символу, крім згаданих.
5. Межі слів повинні зберігатися у висновку.
6. виграє найкоротший код.

Наприклад, ваша програма повинна вивести Begin/With.Type&Contentдля 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 символів

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

Цілком базовий підхід GolfScript, який працює на всі дані відповідно до специфікації. Приклади можна перевірити в Інтернеті .

Пітон 3,22

print(input().title())

Цей код буде приймати рядок як вхід від stdin і надає велике виведення в stdout.

наприклад:

вхід:

BEGIN/wITH.tyPe&cOnTENt

вихід:

Begin/With.Type&Content

Наступний код призначений для багаторядкових входів (за потреби)

Пітон 3, 46

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

Mathematica 62

Дані

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

Код

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

Використання

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

"Агент Accept / Length-Type User Range.Type"

f /@ tests

{"Агент 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 / Type & 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 ",
" Діапазон і вміст із типом типу вмісту ",
" Код початку # Користувач # Агент.Користувач ",
" Довжина типу "}

JavaScript (94)

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

PHP: 78 73 65 64 символів

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

Вхід передається $s . Він діє на рядок як масив символів.

Це проста 2 державна машина. Він спирається на лексичне впорядкування рядків і те, що парсер автоматично припускає, що ви мали намір ввести рядок у деяких випадках.

Стан зберігається в $bі подається як назва функції, яку потрібно викликати наступним символом. ucfirstі lcfirstвони коротші за типом і мають однакову поведінку до strtolower/ strtoupperна окремих символьних рядках. Крім того, оскільки вони відрізняються лише однією буквою, ми можемо їх ефективно використовувати для зберігання держави. Оригінальна версія, необхідна для явного зберігання стану в булевій формі.

Оскільки echo нічого не друкує для булевого false, я використав кому та !оператор, щоб "приховати" завдання (що в даному випадку є truthy) в операторі echo. Це дозволило мені зберегти персонаж, видаливши {}.

С, 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();}

Займає рядки stdin, переводить їх на stdout. (Віддає перевагу SIGINTдо EOF.)

Потужність: 37 - 43

Залежно від того, як ви хочете взяти дані ...

Запропонуйте користувачеві ввести: 43

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

Візьміть вхід з трубопроводу: 38

(Culture).TextInfo.ToTitleCase($input)

Надайте введення як аргумент під час запуску сценарію: 37

(Culture).TextInfo.ToTitleCase($args)

ПРИМІТКА . Вищезазначені сценарії ігнорують слова з великої літери, залишаючи їх такими, які є. Якщо це потрібно врахувати, вхід повинен бути змушений мати малі регістри перед перетворенням титульного випадку. Це додає 10 символів до першого методу та 12 до двох інших.

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

Java - 209 символів

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

Я додав нові рядки лише для читабельності.

R, 143 116

Можливо, рішення трохи довше, але ось ми:

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

Трохи невольф і пояснив:

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

Редагування : 116 символів

Основна проблема тут - векторизація substr. Ось ще один менш дослівний спосіб.

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

Відступ:

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
    }

Використання:

> 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#@

Написання цього зачепило мій мозок.

Це вимагає введення даних, ~і якщо попередній символ був одним з роздільників (або якщо попереднього символу не було), він виконується

:'``!3*j' -;

Цей фрагмент приймає символ, і якщо його значення ascii більше або дорівнює a, він віднімає з нього 32, змінюючи, таким чином, верхній регістр. Якщо вона менше a, 3*jпропускає регулювання. Потім пропускає наступну частину. Ця частина обробляє зміну від верхнього регістру до нижнього регістру (я впевнений, що його можна об'єднати з наступною частиною; я просто не впевнений, як):

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

Символ друкується ( ,), тоді це перевіряє, чи є символ одним із меж:

'/`!

Він в основному порівнює персонаж із значенням ascii /. Якщо символ не є межею, код натискає 12так, що наступного разу він пропустить коригування великої літери. #пропускає над кінцевою програмою: @і, якщо кінець вводу досягнуто, ~відправляє виконання коду назад до програми @, закінчуючи програму.

Ruby: 60 51 50 47 символів

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

Проба зразка:

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

Проста обробка на основі кінцевих станів:

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

(де xвикористовується stringвелика капіталізація)

і звичайно, якщо ви хочете бути нудними (після оновлення специфікації), ви можете використовувати

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

або, з усією нудною котельною плитою:

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)

По-четверте, 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

Перекладений вихід записується так, stdoutяк він читається stdin.

Befunge-98 (29), C (65)

Оскільки метод / алгоритм майже однаковий, я включаю обидві версії в один і той же пост. Обидва покладаються на те, щоб відслідковувати, чи був останній символ символом чи буквою, щоб знати, чи слід писати малі літери чи ні.

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

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

05AB1E , 1 байт

Код:

™

Пояснення:

™   # Implicit input which is converted to title case.

Спробуйте в Інтернеті!

Excel VBA-11 символів

У негайному вікні

?[Proper()]

VBscript

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

AWK, 113 103 байти

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

Це добре працює для вмісту однорядкових, але для багаторядкового введення потрібно додати пару ініт

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

Було б непогано, якби ми могли скористатися автоматичним розділенням запису на поля та модифікацією зазначених полів, але тоді ми втратили роздільники поля. :(

Я знаю, що це не найголовніший варіант відповідей, і це досить старе питання, але я вважаю, що AWK недостатньо представлений у просторі відповідей CG :)

(Дякуємо @manatwork за тестування коду, він повинен працювати зараз :) Також змінився потік, але кількість байтів збереглася однаково, замінивши деякі ;новими рядками.)

PHP (> v5.4.32) - 25 символів

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

Пояснення:

• ucwords () - це вбудована функція PHP

• Перший параметр $a- це вхід

• Другий параметр - це деліметри (нефайлові символи, знайдені в тестових випадках)

• Повернення / відлуння / друк передбачається завдяки використанню <?= ?>

Посилання:

• Ігровий майданчик коду

• Функція 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

Спробуйте версію SELECT в SQL Server 2012 тут .

Замініть "foo" на рядок введення. Кількість знаків для рядків нульової довжини. Цей код проходить рядок, використовуючи індекс, верхній або нижній регістр символу в цій позиції на основі попереднього символу.

JavaScript (Node.js) , 70 байт

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

Спробуйте в Інтернеті!

Я впевнений, що це можна додатково гольфувати.

Примітка :

Здійснюйте вхід через f(string)(), останні потрібні, але нічого не виконують.

Powershell, 77 75 байт

Це рішення повністю відповідає правилам завдання (навіть неоднозначний приклад foo:bar).

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

Дивіться також рішення Powershell із вбудованою функцією ToTitleCase від @Iszi.

Пояснений тестовий сценарій:

$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"
}

Вихід:

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 байти

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

Байти підраховуються в CP-437 ;є єдиним байтом (код символу 20).

Метод введення тут трохи дивний: символи вводяться по одному, а їх величина перетворюється перед тим, як вони відображатимуться. Отже, коли ви вводите текст aGeNT, він відображається на екрані як Agent. Натискання Enterзавершує програму.

Python 3 , 122 байти

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

Спробуйте в Інтернеті!

Не чудова оцінка, але я хотів спробувати це без вбудованих рядкових операцій для зміни випадку.

PHP - 23 символи

mb_convert_case ($ w, 2);

Для роботи йому потрібен php_mbstring