Questo è relativamente veloce, ma sono sicuro che ti piacerà.

Codegolf è un programma che prenderà input sotto forma di frase e quindi fornirà all'output la prima lettera maiuscola in ogni parola.

Regole:

1. Le presentazioni potrebbero non essere sotto forma di una funzione. Quindi no:

   function x(y){z=some_kind_of_magic(y);return z;} come risposta finale ... Il tuo codice deve mostrare che accetta input e fornisce output.

2. Il codice deve conservare qualsiasi altra lettera maiuscola contenuta nell'input. Così

   eCommerce and eBusiness are cool, don't you agree, Richard III?
   

   sarà reso come

   ECommerce And EBusiness Are Cool, Don't You Agree, Richard III?
   

3. Alcuni di voi potrebbero pensare: "Facile, userò solo regex!" e quindi l'uso della regex nativa nella lingua da golf prescelta comporterà una penalità di 30 caratteri che verrà applicata al conteggio del codice finale. Risata malefica

4. Una "parola" in questo caso è qualsiasi cosa separata da uno spazio. Pertanto palate cleansersono due parole, mentre pigeon-toedè considerata una parola. if_you_love_her_then_you_should_put_a_ring_on_itè considerata una parola. Se una parola inizia con un carattere non alfabetico, la parola viene preservata, quindi _thisdopo il rendering rimane come _this. (Complimenti a Martin Buttner per aver segnalato questo caso di test).

   • 4b. Non vi è alcuna garanzia che le parole nella frase di input siano separate da un singolo spazio.

5. Test Case, (si prega di utilizzare per testare il codice):

   Ingresso:

   eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye
   

   Produzione:

   ECommerce Rocks. CrazyCamelCase Stuff. _those  Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye
   

6. Questo è il codice golf, il codice più corto vince ...

In bocca al lupo...

CJam, 15 13 byte

Lq{_eu?_S-}/;

Provalo online nell'interprete CJam .

pseudocodice

L             e# B := ""
 q            e# Q := input()
  {       }/  e# for C in Q:
   _eu?       e#     C := B ? C : uppercase(C)
       _S-    e#     B := string(C).strip(" ")
            ; e# discard(B)

Tutti i caratteri modificati C vengono lasciati in pila e, quindi, stampati all'uscita.

CSS 2.1, 49

:after{content:attr(t);text-transform:capitalize}

Spiegazione :

• La attrfunzione accetta l'input da un tattributo HTML (di testo).
• L'input viene capitalizzato impostando text-transformsu capitalize.
• L'output viene fornito come contenuto generato, utilizzando la contentproprietà su uno pseudo-elemento .::after

Snippet eseguibile :

:after {
    content: attr(t);
    text-transform: capitalize;
}

<div t="eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye"></div>

Nota : CSS 2.1 ha specificato il comportamento desiderato: ha messo in capitalizemaiuscolo il primo carattere di ogni parola. Tuttavia, CSS3 mette in maiuscolo la prima unità tipografica di ogni parola. Quindi lo snippet sopra non funzionerà correttamente né sul vecchio IE, che non seguiva CSS 2.1; né sui nuovi browser conformi che seguono CSS3.

Javascript ( ES6 ), 77 byte

alert(prompt().split(' ').map(x=>x&&x[0].toUpperCase()+x.slice(1)).join(' '))

Commentate

alert( // output
    prompt(). // take input
    split(' '). // split by spaces
    map(x=> // map function to array
        x && // if x, empty string "" is falsey and returns itself
        x[0].toUpperCase() + x.slice(1) // capaitalize 1st char and concatenate the rest
    ).
    join(' ') // join array with spaces
)

Perl, 13 byte

perl -040pe '$_="\u$_"'

9 byte più 4 byte per 040p(supponendo che io abbia interpretato correttamente le regole sulle invocazioni speciali ).

-040imposta il separatore del record di input $/su un singolo spazio, in modo da preservare gli spazi; la \usequenza di escape converte il carattere successivo in maiuscolo / minuscolo.

CJam, 17 15 byte

lS/{S+(eu\+}/W<

Provalo qui.

Implementazione abbastanza semplice della specifica. Utilizzare il nuovo {}&per evitare errori per spazi consecutivi.

Due byte salvati da Dennis.

C, 64 63 byte

a;main(c){while(~(c=getchar()))putchar(a?c:toupper(c)),a=c-32;}

Correzione: ad alcuni compilatori (come Clang) non piace un parametro int al posto di argv, quindi l'ho spostato in una variabile globale. Il conteggio dei byte rimane lo stesso. Grazie all'ossifrage schizzinoso per aver notato. Fino a 63 byte, grazie Dennis.

Ungolfed:

int a;

int main(int c) {
    while(~(c = getchar()))
        putchar(a ? c : toupper(c)),
        a = c - ' ';
}

Abbastanza semplice: se a è falso, il personaggio viene convertito in maiuscolo. Viene impostato dopo aver letto uno spazio: c - '' è falso solo se c == ''. toupper () ignora tutto ciò che non è una lettera minuscola, quindi i simboli e gli spazi multipli vanno bene. -1 ha tutti i bit impostati, quindi quando getchar () restituisce -1 l'operatore NOT lo rende zero e il ciclo si arresta. a viene dichiarato come variabile globale, quindi è inizializzato su zero (falso). Questo assicura che la prima parola sia maiuscola.

Python 3, 59 56 byte

f=1
for c in input():print(end=f*c.upper()or c);f=c==" "

Grazie a @Reticality per 3 byte.

Versione Perl <5.18, 30 27 26 25

say map"\u$_",split$,=$"

24personaggi +1per -n.

\urende il carattere successivo in una stringa maiuscola . @ThisSuitIsBlackNot lo ha sottolineato per salvare 1 byte. Prima stavamo usando la funzione ucfirst.

Dai perldoc ,

Come altro caso speciale, split emula il comportamento predefinito dello strumento da riga di comando awk quando il PATTERN viene omesso o una stringa letterale composta da un singolo carattere di spazio (come '' o "\ x20", ma non ad esempio / /). In questo caso, qualsiasi spazio bianco iniziale in EXPR viene rimosso prima che si verifichi la divisione e il PATTERN viene invece trattato come se fosse / \ s + /; in particolare, ciò significa che qualsiasi spazio bianco contiguo (non solo un singolo carattere di spazio) viene utilizzato come separatore. Tuttavia, questo trattamento speciale può essere evitato specificando il modello / / invece della stringa "", consentendo in tal modo a un solo carattere di spazio di essere un separatore. Nel precedente Perls questo caso speciale era limitato all'uso di un "" semplice come argomento del modello da dividere, in Perl 5.18.

Poiché $"valuta uno spazio, ciò preserverà gli spazi. Dal momento che entrambi vogliamo impostare $,un carattere spaziale e inserire un carattere spaziale nella divisione, @nutki ha sottolineato che possiamo fare entrambi come input per la divisione. Ciò consente di risparmiare 3 byte da ciò che avevamo prima, che era prima l'impostazione $,e quindi l'immissione $"nella divisione.

Usare una ,mappa for invece di {}salvare un byte aggiuntivo, come ha sottolineato @ alexander-brett.

Corri con:

echo 'eCommerce     rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye' | perl -nE'say map"\u$_",split$,=$"'

> <> (Pesce) , 39 byte

</?-' 'o:;?(0:<-*' '*('{'$)'`'::i
i/.0e

Metodo:

• Prendi un carattere e capitalizzalo se nel raggio di azione, a-zquindi stampalo. (il codice da sinistra a destra per questa parte è i::'backquote')$'{'(*' '*+)
• Se l'ultimo carattere preso è un carattere EOF, allora esci altrimenti stampalo
• Se l'ultimo carattere intrapresa è un char spazio poi andare al punto 1 altro prendere una nuova lettera e passare al punto 2.

JAVA, 273 byte

MODIFICARE

import static java.lang.System.*;class x{public static void main(String[] s){char[] a=new java.util.Scanner(in).nextLine().toCharArray();boolean f=1>0;for(int i=0;i<a.length;i++){if(a[i]==' '){f=1>0;continue;}if(f){a[i]=Character.toUpperCase(a[i]);f=1<0;}}out.println(a);}}

JavaScript (soluzione regex) - 104 byte

Qualcuno deve mordere il proiettile e pubblicare la soluzione RegEx! 74 caratteri, più la penalità di +30 caratteri:

alert(prompt().replace(/(^| )[a-z]/g,function(m){return m.toUpperCase()}))

O se vuoi leggere e comprendere il codice nel suo modo non compattato:

//     Matches the (beginning of the line or a space), followed by a lowercase English character.  
string.replace( /(^| )[a-z]/g ,
                function(match) { return match.toUpperCase(); }

Python 2, 73 byte

i=raw_input()
print''.join((c,c.upper())[p==' ']for p,c in zip(' '+i,i))

Questo programma mette in maiuscolo una lettera se preceduto da uno spazio (con un kludge per il primo carattere nella stringa). Si basa sul .upper()metodo stringa per capitalizzare correttamente.

PHP 64 76 77 83 84 89 byte

Non $_GETconta come input in PHP?
Se è così, ecco il mio primo tentativo di CG

foreach(explode(' ',$_GET[@s])as$k=>$v)echo$k?' ':'',ucfirst($v)

Grazie manatwork :)

Si potrebbe semplicemente usare la ucwordsfunzione, che comporterebbe 21 byte:

<?=ucwords($_GET[@s])

grazie Harry Mustoe-Playfair :)

Haskell, 69

import Data.Char
main=interact$tail.scanl(!)' '
' '!c=toUpper c;_!c=c

Spiegazione:

scanlaccetta una funzione (a -> b -> a)e un valore iniziale a, quindi scorre su un elenco di [b]s per creare un elenco di [a]s:

scanl (!) z [a,b,c] == [   z
                       ,   z ! a
                       ,  (z ! a) ! b
                       , ((z ! a) ! b) ! c]

Prende ripetutamente il risultato precedente come argomento sinistro della funzione passato ad esso e un valore dall'elenco di input come argomento giusto per creare il successivo.

Ho scritto una funzione (!) :: Char -> Char -> Charche restituisce il carattere giusto che lo passi, ma lo rende maiuscolo se il carattere sinistro è ' '(spazio). Per scanlquesto significa: restituire il valore dalla lista di input , ma capitalizzare se il risultato precedente era uno spazio. Quindi scanl (!) ' ' "ab cd"diventa:

    scanl (!) ' ' "ab cd"
==> ' ' : scanl (!) (' ' ! 'a') "b cd"
==> ' ' : scanl (!)     'A'     "b cd"
==> ' ' : 'A' : scanl (!) ('A' ! 'b') " cd"
==> ' ' : 'A' : scanl (!)     'b'     " cd"
==> ' ' : 'A' : 'b' : scanl (!) ('b' ! ' ') "cd"
==> ' ' : 'A' : 'b' : scanl (!)     ' '     "cd"
==> ' ' : 'A' : 'b' : ' ' : scanl (!) (' ' ! 'c') "d"
==> ' ' : 'A' : 'b' : ' ' : scanl (!)     'C'     "d"
==> ' ' : 'A' : 'b' : ' ' : 'C' : scanl (!) ('C' ! 'd') ""
==> ' ' : 'A' : 'b' : ' ' : 'C' : scanl (!)     'd'     ""
==> ' ' : 'A' : 'b' : ' ' : 'C' : 'd' : ""
==> " Ab Cd"

Abbiamo bisogno del valore iniziale ' 'per scrivere in maiuscolo la prima lettera, ma poi lo tronciamo tailper ottenere il nostro risultato finale.

Pyth, 20 byte

uXGHr@GH1fqd@+dzTUzz

Questi spazi multipli fanno davvero schifo. Altrimenti ci sarebbe stata una soluzione davvero semplice da 12 byte.

Provalo online: Pyth Compiler / Executor

Spiegazione

                      implicit: z = input string
         f       Uz   filter [0, 1, 2, ..., len(z)-1] for elements T, which satisfy:
          qd@+dzT        " " == (" " + z)[T]
                      (this finds all indices, which should be capitalized)
u                  z  reduce, start with G = z, for H in idices ^ update G by
 XGH                     replace the Hth char of G by
    r   1                upper-case of
     @GH                 G[H]
                      implicitly print result

modifica: 16 caratteri è possibile con l'algoritmo @Dennis.

CJam, 14 byte

Non è il più corto, ma ...

qS/Sf.{\eu}s1>

Un'altra risposta usando idee simili:

qS/Laf.{;eu}S*

.x cambia il primo elemento solo se uno dei parametri ha un solo elemento.

Lua, 64 62 61 byte

Lua è una lingua orribile in cui giocare a golf, quindi sono abbastanza orgoglioso di me stesso per questo.

print(string.gsub(" "..io.read(),"%s%l",string.upper):sub(2))

[Provalo qui] 1 Non aggiornato, aggiornerà domani

JAVA, 204 211 226 byte

La mia prima voce su CG, spero che vada bene:

class U{public static void main(String[]s){int i=0;char[]r=s[0].toCharArray();r[0]=Character.toUpperCase(r[0]);for(char c:r){if(c==' '&&i>0)r[i+1]=Character.toUpperCase(r[i+1]);i++;System.out.print(c);}}}

Salvato 7 byte grazie a @TNT

PHP: 76 74 caratteri

foreach($l=str_split(fgets(STDIN))as$c){echo$l?ucfirst($c):$c;$l=$c==" ";}

Esecuzione di esempio:

bash-4.3$ php -r 'foreach($l=str_split(fgets(STDIN))as$c){echo$l?ucfirst($c):$c;$l=$c==" ";}' <<< 'eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye'
ECommerce Rocks. CrazyCamelCase Stuff. _those  Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye

C, 74 byte

a,b=1;main(){while((a=getchar())>0)b=isspace(putchar(b?toupper(a):a));}

Non fa ipotesi sul set di caratteri di runtime (ASCII, EBCDIC, Baudot, ... qualunque cosa). Suppone che EOF sia negativo (penso che C lo garantisca).

a,b=1;
main()
{
    while((a=getchar())>0)
        b=isspace(putchar(b?toupper(a):a));
}

a è il carattere di input; b è vero se l'ultimo carattere era spazio. L'unico bit non ovvio è che usiamo il fatto che putcharrestituisce il carattere stampato se non ci sono errori.

C # Linq - 187

Questo non è affatto vicino alla vittoria, ma adoro Linq troppo.

namespace System{using Linq;class P{static void Main(string[]a){Console.Write(a[0].Substring(1).Aggregate(a[0][0].ToString().ToUpper(),(b,c)=>b[b.Length-1]==32?b+char.ToUpper(c):b+c));}}}

Vim, 11 , 10 byte

qqvUW@qq@q

Spiegazione:

qq           #Start recording in register 'q'
  vU        #Make the character under the cursor uppercase
     W       #Move forward a WORD
      @q     #recursively call macro 'q'
        q    #stop recording
         @q  #Call the recursive macro

Ricevo un distintivo d'oro per aver superato Dennis?

Bash, 61

a="${@//: / }"
a=(${a//: / })
a="${a[@]^}"
echo "${a//:/ }"

Nota i due punti sono semplicemente per rendere OK il display del programma qui. In realtà questi possono essere dei caratteri non stampabili, come BEL.

Produzione

$ ./cap1st.sh "eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye"
ECommerce Rocks. CrazyCamelCase Stuff. _those  Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye
$ 

Bash, 12

Purtroppo questo non conserva spazi iniziali / multipli / finali, ma altrimenti funziona:

echo "${@^}"

Produzione

$ ./cap1st.sh eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye
ECommerce Rocks. CrazyCamelCase Stuff. _those Pigeon-toed Shennanigans. Fiery Trailblazing 345 Thirty-two Roger. The Quick Brown Fox Jumped Over The Lazy Dogs. Clancy Brown Would Have Been Cool As Lex Luthor. Good_bye
$ 

Pip , 15 + 1 per -s= 16

{IaUC:a@0a}Ma^s

Spiegazione:

                  a is first cmdline arg (implicit)
            a^s   Split a on spaces
{         }M      Map this function to each element:
 Ia                 If the word is not empty,
   UC:a@0             uppercase its first character
         a          Return the word
                  Output the resulting list (implicit) joined on spaces (-s flag)

Una caratteristica interessante di Pip su cui si basa questo programma è il :meta-operatore di assegnazione. La maggior parte dei linguaggi simili a C ha un insieme di operatori di calcolo e assegnazione: ad esempio x*=5fa la stessa cosa di x=x*5. In Pip, tuttavia, è possibile virare :su qualsiasi operatore e di trasformarlo in un operatore compute-e-assegnazione. Questo vale anche per gli operatori unari. Quindi -:xcalcola -xe lo riassegna ax , come x:-xfarebbe. In questo caso, UC:viene utilizzato (insieme alle stringhe mutabili di Pip) per mettere in maiuscolo il primo carattere di una parola.

Il programma accetta input dalla riga di comando, richiedendo una chiamata come questa:

python3 pip.py -se "{IaUC:a@0a}Ma^s" "test teSt TEST  _test"

C, 125

Non è la soluzione più breve, ma mi piace molto giocare a golf in C.

char b[99];main(c){while(scanf("%[A-Za-z_-]",b)==1)islower(*b)&&(*b&=223),printf("%s",b);~(c=getchar())&&putchar(c)&&main();}

ungolfed:

char b[99];
main(c)
{
  while(scanf("%[A-Za-z_-]", b) == 1) {
    if(islower(b[0])) {
      b[0] &= 0xDF;
    }
    printf("%s", b);
  }
  if((c = getchar()) != -1) {
      putchar(c);
      main();
  }
}

Non so chi utilizzi la sintassi simile a regex in scanfsta stringendo le regole, ma funziona abbastanza bene. (Beh, tecnicamente non è una regex completa )

Un'altra cosa da considerare è che questo codice funziona solo per parole inferiori a 99 byte. Ma penso che questa soluzione funzionerà nella maggior parte dei casi.

Haskell: 127 caratteri

import Data.List
import Data.Char
i=isSpace
s a b=i a==i b
u (w:ws)=(toUpper w):ws
f w=concatMap u$groupBy s w
main=interact f

PHP, 82

echo join(' ',array_map(function($s){return ucfirst($s);},explode(' ',$argv[1])));

Utilizzo:

$ php code.php "eCommerce rocks. crazyCamelCase stuff. _those  pigeon-toed shennanigans. Fiery trailblazing 345 thirty-two Roger. The quick brown fox jumped over the lazy dogs. Clancy Brown would have been cool as Lex Luthor. good_bye"

C #, 133 131

using C=System.Console;class P{static void Main(){var s=2>1;foreach(var c in C.ReadLine()){C.Write(s?char.ToUpper(c):c);s=c==32;}}}

Mathematica, 66 byte

Print@StringReplace[InputString[],WordBoundary~~a_:>ToUpperCase@a]

Vorrei usare ToCamelCase, ma non conserva la spaziatura.

R, 139 105 byte

for(i in 1:length(p<-strsplit(readline(),"")[[1]])){if(i<2||p[i-1]==" ")p[i]=toupper(p[i])};cat(p,sep="")

Ungolfed + spiegazione:

# Assign p to be a vector of the input read from stdin, split into characters

for(i in 1:length(p <- strsplit(readline(), "")[[1]])) {

    # If we're at the first iteration or the previous character was a space

    if (i < 2 || p[i-1] == " ") {

        # Convert the current character to its uppercase equivalent

        p[i] <- toupper(p[i])
    }
}

# Join the vector elements into a single string and print it to stdout
cat(p, sep = "")

R con regex, 49 41 + 30 = 71 byte

Sono davvero distrutto; questo ha effettivamente un punteggio migliore usando le espressioni regolari con la penalità.

gsub("(^.| +.)","\\U\\1",readline(),pe=T)

Questo corrisponde a qualsiasi singolo carattere all'inizio della stringa o seguendo un numero qualsiasi di spazi e lo sostituisce con una versione maiuscola dell'acquisizione. Si noti che l'applicazione \\Uè legittima e non ha alcun effetto per le non lettere. pe=Tviene interpretato come perl = TRUEpoiché sfrutta la corrispondenza parziale di R dei parametri di funzione e il sinonimo di TRUE. Per qualsiasi motivo, R non usa l'espressione regolare in stile Perl per impostazione predefinita.

Grazie a MickyT per aver contribuito a salvare 8 byte sull'approccio regex!