Bir dize verildiğinde büyük harfle yazın. Büyük harf ile demek conTeNT-lENgthdeğişiklikler Content-Length. Örnekte dizeyi 2 kelimeyle gösterdim- kelime sınırı olarak . Ancak ben sınır olarak tek bir karakterle ayrılmış herhangi bir sayıda kelime içeren dize için kod yazmak için bekliyoruz . Bu sınır dizede değişebilir.

Koşullar

1. kullanarak regular expressionsIS izin verilmez .
2. bir cümlede (dize) herhangi bir sayıda kelime olabilir.
3. her kelime Englishharflerden oluşacaktır[a-zA-Z] herhangi bir vakanın .
4. cümledeki farklı kelimeler tek bir karakterle ayrılacaktır. Bu karakter olacak ancak herhangi biri -, ., <space-character>, /,& , #. Güvenle bu cümle varsayabiliriz değil belirtilen dışında başka herhangi bir karakter içermelidir.
5. Çıktıda kelime sınırları korunmalıdır.
6. en kısa kod kazanır.

Örneğin, programınız Begin/With.Type&Contentiçin çıktı almalısınız 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 karakter

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

Spesifikasyona göre tüm girdiler için çalışan oldukça basit bir GolfScript yaklaşımı. Örnekler çevrimiçi olarak test edilebilir .

Python 3,22

print(input().title())

Bu kod bir dizeyi stdin'den girdi olarak alır ve stdout'a büyük harfle çıktı verir.

Örneğin:

giriş:

BEGIN/wITH.tyPe&cOnTENt

çıkışına:

Begin/With.Type&Content

Aşağıdaki kod çok satırlı girişler içindir (gerekirse)

Python 3, 46

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

Mathematica 62

Veri

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

kod

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

kullanım

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

"Temsilci Kabul / Uzunluk Tipi Kullanıcı Aralığı.Tip"

f /@ tests

{"Aracı Kabul / Uzunluk Tipi Kullanıcı Aralığı.Tip",
"Tür ve Aracı / Bilgi / İçerik Uzunluğu # Kabul / Aracı.Range-Bilgi / İçerik / Kod", "Bilgi / Yanıt. Uzunluk # Tür ve Kullanıcı / Başlangıç ​​ve Kullanıcı. Kabul / Bilgi "," Uzunluk # Kullanıcı.Tip / Başlangıç ​​ve Uzunluk Türü / Kabul Et # Aralık / Kod & Kabul Et / İçerik "," İçerik / Kabul Et ",
" Başlangıç ​​/ İçerikle / Tür ",
" Code.Cc # Kullanıcı.Length-Kullanıcı -Ve & Type Type & Length.Type User.User & With ",
" İçerik Tipi Türüyle Aralık ve İçerik ",
" 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 karakter

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

Giriş iletilir $s. Dizede bir karakter dizisi olarak çalışır.

Basit 2 durumlu bir makinedir. Dizelerin sözcüksel sıralamasına dayanır ve ayrıştırıcı otomatik olarak bazı durumlarda bir dize yazmak istediğinizi varsayar.

Durum depolanır $bve bir sonraki karakterde çağrılması gereken işlevin adı olarak temsil edilir. ucfirstve karakterleri yazmak lcfirstiçin daha kısadır ve tek karakter dizelerinde strtolower/ strtoupperüzerinde aynı davranışı vardır . Ayrıca, sadece bir harf ile farklılık gösterdiğinden, bunları devleti depolamak için verimli bir şekilde kullanabiliriz. Orijinal sürüm, durumu açıkça bir boole'de depolamak için gerekiyordu.

Echo boolean false için hiçbir şey !basmadığından, echo deyiminde ödevi "gizlemek" için virgül ve operatör kullandım. Bu, bir karakteri{} .

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

Hatları alır stdin, çevirir stdout. (Bunu tercih SIGINTeder EOF.)

Powershell: 37-43

Girişi nasıl almak istediğinize bağlı olarak ...

Kullanıcıdan giriş iste: 43

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

Boru hattından girdi al: 38

(Culture).TextInfo.ToTitleCase($input)

Komut dosyasını çalıştırırken bağımsız değişken olarak girdi sağlama: 37

(Culture).TextInfo.ToTitleCase($args)

NOT: Yukarıdaki komut dosyaları, tüm harfleri büyük olan kelimeleri yok sayar ve olduğu gibi bırakır. Bunun hesaba katılması gerekiyorsa, girişin Başlık Büyük / Küçük Harf dönüşümünden önce küçük harfe zorlanması gerekir. Bu, ilk yönteme 10, diğer ikisine de 12 karakter ekler.

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

Java - 209 karakter

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

Yalnızca okunabilirlik için yeni satırlar ekledim.

R, 143 116

Belki biraz uzun bir çözüm ama işte başlıyoruz:

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

Hafifçe soluksuz ve açıkladı:

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

Düzenleme : 116 karakter

Buradaki asıl zorluk vektörleştirmektir substr. İşte daha az ayrıntılı bir yol.

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

Girintili'ye:

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
    }

Kullanımı:

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

Bunu yazmak beynime zarar verdi.

Bu, girdiyi alır ~ve önceki karakter ayırıcılardan biriyse (veya önceki karakter yoksa),

:'``!3*j' -;

Bu snippet karakteri alır ve eğer ascii değeri büyük veya ona eşitse a, 32 değerini çıkartır, böylece büyük harfe değiştirir. O daha az ise a, 3*jayar atlar. Daha sonra bir sonraki bölümü atlar. Bu bölüm, büyük harften küçük harfe geçiyor (bir sonraki bölümle birleştirilebileceğinden eminim; nasıl olduğundan emin değilim):

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

Karakter yazdırılır ( ,), bu da karakterin sınırlardan biri olup olmadığını kontrol eder:

'/`!

Temelde karakteri ascii değeriyle karşılaştırır /. Karakter bir sınır değilse, kod bir 12sonraki seferde büyük / küçük harf ayarlamalarını atlayacak şekilde iter . #son programın üzerine atlar: @ve girişin sonuna ulaşılırsa, ~kod yürütme @işlemini programın sonlandırıldığı durumuna geri gönderir .

Yakut: 60 51 50 47 karakter

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

Örnek çalışma:

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

Basit bir sonlu-durum-makine tabanlı işleme:

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

(nerede x olduğu stringyararlanmak için)

ve tabii ki, sıkıcı olmak istiyorsanız (şartname güncellendikten sonra),

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

veya tüm sıkıcı kazan plakası ile:

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)

Dördüncü, 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

Çevrilmiş çıktı stdoutokunduğu gibi yazılır stdin.

Befunge-98 (29), C (65)

Yöntem / algoritma hemen hemen aynı olduğundan, her iki sürümü de aynı gönderiye dahil ediyorum. Her ikisi de, bir harfin küçük harf olup olmadığını bilmek için son karakterin bir sembol veya harf olup olmadığını takip etmeye güvenir.

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

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

05AB1E , 1 bayt

Kod:

™

Açıklama:

™   # Implicit input which is converted to title case.

Çevrimiçi deneyin!

Excel VBA-11 karakterleri

Anında penceresinde

?[Proper()]

VBscript

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

AWK, 113 103 bayt

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

Bu, tek satırlık içerik için iyi çalışır, ancak çok satırlı giriş için birkaç inits eklenmesi gerekir

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

Bir kaydın otomatik olarak alanlara bölünmesinden ve bahsedilen alanların değiştirilmesinden faydalanmak güzel olurdu, ancak daha sonra alan ayırıcılarımızı kaybederdik. :(

Bunun cevapların en golfçüsü olmadığını biliyorum ve bu oldukça eski bir soru, ama AWK'nın CG'nin cevap alanında yeterince temsil edilmediğini hissediyorum :)

(Kodu test ettiğiniz için teşekkürler @manatwork, şimdi çalışmalı :) Ayrıca akışı değiştirdi, ancak bayt sayısını aynı tuttu, bazılarını ;yeni satırlarla değiştirerek .)

PHP (> v5.4.32) - 25 karakter

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

Açıklama:

• ucwords () yerleşik bir PHP fonksiyonudur

• İlk parametre $agiriştir

• İkinci parametre sınırlayıcılardır (test durumlarında alfabetik olmayan kodlayıcılar bulundu)

• Iade / eko / baskı kullanımı nedeniyle varsayılır <?= ?>

Bağlantılar:

• Kod Bahçesi

• PHP ucwords () işlevi

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

Burada SQL Server 2012'deki SELECT sürümünü deneyin .

"Foo" ifadesini giriş dizesiyle değiştirin. Karakter sayısı sıfır uzunluklu bir dize içindir. Bu kod, dizeyi önceki karaktere göre o konumdaki karakteri büyük harflerle veya küçük harflerle kullanarak geçirir.

JavaScript (Node.js) , 70 bayt

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

Çevrimiçi deneyin!

Bu daha da golf olabilir eminim.

Not :

Üzerinden giriş alır f(string)(), son gereklidir ama hiçbir şey yapmaz.

Powershell, 77 75 bayt

Bu çözüm, görev kurallarına tam olarak uygundur (hatta belirsiz örnek foo:bar).

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

@Iszi'nin ToTitleCase yerleşik işlevli Powershell çözümüne de bakın .

Açıklanan test komut dosyası:

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

Çıktı:

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 bayt

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

Baytlar CP-437'de sayılır ; tek bir bayttır (karakter kodu 20).

Buradaki giriş yöntemi biraz garip: karakterler birer birer yazılır ve büyük harfleri gösterilmeden önce dönüştürülür. Yani yazdığınızda aGeNT, ekranda olarak görünür Agent. Vuruş Enterprogramı sonlandırır.

Python 3 , 122 bayt

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

Çevrimiçi deneyin!

Büyük bir puan değil, ama ben vaka değiştirmek için yerleşik dize işlemleri olmadan denemek istedim.

PHP - 23 karakter

mb_convert_case ($ w, 2);

Çalışmak için php_mbstring gerekiyor