Wyzwanie

Kiedyś czytałem Google Style Guide Google'a i potknąłem się o ich algorytm, aby przekonwertować dowolny ciąg znaków na notację camelCase. W tym wyzwaniu musisz wdrożyć ten algorytm, ponieważ nie chcesz robić tych wszystkich rzeczy w swojej głowie, gdy piszesz swoje super konkurencyjne zgłoszenia Java na wyzwania związane z golfem.

Uwaga: Wprowadziłem niewielkie poprawki w algorytmie. Musisz użyć tego określonego poniżej.

Algorytm

Zaczynasz od dowolnego ciągu wejściowego i stosujesz do niego następujące operacje:

1. Usuń wszystkie apostrofy `'
2. Podziel wynik na słowa, dzieląc na
   • znaki, które nie są alfanumeryczne i nie są cyframi [^a-zA-Z0-9]
   • Wielkie litery, które są otoczone małymi literami po obu stronach. abcDefGhI jkna przykład plonyabc Def Ghi jk
3. Każde słowo ma małe litery.
4. Wielka litera pierwszy znak każdego oprócz pierwszego słowa.
5. Połącz wszystkie słowa z powrotem razem.

Dodatkowe uwagi

• Dane wejściowe będą zawierać tylko ASCII do wydruku.
• Jeśli cyfra jest pierwszą literą w słowie, pozostaw ją taką, jaka jest i nie zapisuj w tym słowie czegoś innego.
• Dane wejściowe zawsze będą miały co najmniej jeden znak.

Zasady

• Dozwolona funkcja lub pełny program.
• Domyślne reguły wejścia / wyjścia.
• Obowiązują standardowe luki .
• To jest golf golfowy , więc wygrywa najmniej bajtów. Tiebreaker to wcześniejsze zgłoszenie.

Przypadki testowe

„Programowanie zagadek i golf” -> „programowanie PuzzleCodeGolf”
„Żądanie HTTP XML” -> „xmlHttpRequest”
„obsługuje IPv6 na iOS?” -> „obsługujeIpv6OnIos”
„SomeThing w1th, apo'strophe's i„ punc] tuation ”->„ someThingW1thApostrophesAndPuncTuation ”
„nic specjalnego” -> „nic specjalnego”
„5pecial ca5e” -> „5pecialCa5e”
„1337” -> „1337”
„1337-SPEk” -> „1337Speak”
„whatA mess” -> „whataMess”
„abcD” -> „abcd”
„a” -> „a”
„B” -> „b”

Happy Coding!

Siatkówka , 56 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

T`'\`
S_`\W|_|(?<=[a-z])(?=[A-Z][a-z])
T`L`l
T`l`L`¶.
¶

Wypróbuj online!

Wyjaśnienie

To implementuje specyfikację dosłownie:

T`'\`

Usuń apostrofy i wsteczne.

S_`\W|_|(?<=[a-z])(?=[A-Z][a-z])

Podziel ciąg wokół znaków innych niż słowa (w wyrażeniu regularnym wyklucza to również cyfry i znaki podkreślenia) lub podkreślenia lub pozycje, które mają małe litery po lewej stronie i wielkie litery, małe litery po prawej stronie. Spowodowałoby to utworzenie niektórych pustych segmentów, gdy w wierszu znajdują się dwa nieliterowe, niecyfrowe znaki lub, co ważniejsze, na początku łańcucha. Pozbywamy się tych z _opcją. Tutaj „podział” oznacza umieszczenie każdej pozostałej części na osobnej linii.

T`L`l

Konwertuj wszystko na małe litery.

T`l`L`¶.

Konwertuj każdy znak występujący po wysunięciu wiersza na wielkie litery. To wygodnie pominie pierwsze słowo, ponieważ przed nim nie ma linii.

¶

Pozbądź się kanałów, aby połączyć wszystko z powrotem.

Jawa, 198 190 bajtów

+3 bajty, ponieważ zapomniałem, że \W+==[^a-zA-Z0-9_]+ i muszę dopasować[^a-zA-Z0-9]+

-11 bajtów dzięki user20093 - ?:zamiastif /else

Ponieważ Java.

s->{String[]a=s.replaceAll("`|'","").split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])");s="";for(String w:a){String t=w.toLowerCase();s+=a[0]==w?t:t.toUpperCase().charAt(0)+t.substring(1);}return s;}

To jest lambda. Zadzwoń tak:

UnaryOperator<String> op = s->{String[]a=s.replaceAll("`|'","").split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])");s="";for(String w:a){String t=w.toLowerCase();s+=a[0]==w?t:t.toUpperCase().charAt(0)+t.substring(1);}return s;};
System.out.println(op.apply("Programming Puzzles & Code Golf"));

Wersja do odczytu:

public static String toCamelCase(String s) {
    String[] tokens = s
            .replaceAll("`|'", "") // 1. Remove all apostrophes
            .split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])"); // 2. Split on [\W_]+ or between [a-z] and [A-Z][a-z]
    s = ""; // Reusing s for building output is cheap
    for (String token : tokens) {
        String lowercaseToken = token.toLowerCase(); // 3. Lowercase every word
        s += tokens[0].equals(token)?lowercaseToken:lowercaseToken.toUpperCase().charAt(0) + lowercaseToken.substring(1); // 4. Uppercase first char of all but first word
        // ^ 5. Join all words back together
    }
    return s;
}

JavaScript (ES6), 156 154 152 148 145 141 140 bajtów

Dzięki @Neil (6 bajtów), @ETHproductions (3 bajty) i @ edc65 (7 bajtów)

a=>a[r='replace'](/`|'/g,a='')[r](/[a-z](?=[A-Z][a-z])/g,'$& ')[r](/[^\W_]+/g,b=>a+=(a?b[0].toUpperCase():'')+b.slice(!!a).toLowerCase())&&a

Usuwa apostrofy, następnie zastępuje, aby podzielić na znaki specjalne / przed otoczonymi wielkimi literami, a następnie łączy się z odpowiednią obudową. Niestety toLowerCase()i toUpperCase()są denerwująco długie i trudne do uniknięcia tutaj ...

vim, 69 68 66

:s/[`']//g<cr>:s/[a-z]\zs\ze[A-Z][a-z]\|\W\|_/\r/g<cr>o<esc>guggj<C-v>GgU:%s/\n<cr>

vim krótszy niż Perl ?! Co to za szaleństwo?

:s/[`']//g<cr>           remove ` and '
:s/                      match...
 [a-z]\zs\ze[A-Z][a-z]   right before a lowercase-surrounded uppercase letter
 \|\W\|_                 or a non-word char or underscore
 /\r/g<cr>               insert newlines between parts
o<esc>                   add an extra line at the end, necessary later...
gugg                     lowercasify everything
j                        go to line 2 (this is why we added the extra line)
<C-v>G                   visual select the first char of all-but-first line
gU                       uppercase
:%s/\n<cr>               join all lines into one

Dzięki Neil za wykrycie bezużytecznego naciśnięcia klawisza!

Mathematica 10.1, 101 bajtów

""<>(ToCamelCase@{##2}~Prepend~ToLowerCase@#&@@StringCases[StringDelete[#,"`"|"'"],WordCharacter..])&

Używa nieudokumentowanej ToCamelCase, która działa podobnie, Capitalizeale ustawia inne znaki na małe litery.

Julia, 98 89 bajtów

s->lcfirst(join(map(ucfirst,split(replace(s,r"['`]",""),r"[a-z]\K(?=[A-Z][a-z])|\W|_"))))

Jest to anonimowa funkcja, która przyjmuje ciąg i zwraca ciąg. Aby go wywołać, przypisz go do zmiennej.

Podejście tutaj jest taka sama jak w klamce za Perl odpowiedziami : replaceapostrofy i backticks z pustym ciągiem, splitdo tablicy w sprawie wyrażenia regularnego, które pasuje do niezbędnych przypadków, funkcja na tablicy na wielkie pierwszą literę każdego elementu, z tyłu tablicy w ciąg, a wynik przekształca pierwszy znak na małe litery.mapucfirstjoinlcfirst

Perl 67 + 1 = 68 bajtów

y/'`//d;s/([a-z](?=[A-Z][a-z]))|\W|_/$1 /g;$_=lc;s/^ +| +(.)/\u$1/g

Wymaga -pflagi, a -ldla wielu linii:

$ perl -pl camelCase.pl input.txt
programmingPuzzlesCodeGolf
xmlHttpRequest
supportsIpv6OnIos:
someThingW1thApostrophesAndPuncTuation
nothingSpecial
5pecialCa5e
1337
1337Speak
abcd

Jak to działa:

y/'`//d;                            # Remove ' and `
s/([a-z](?=[A-Z][a-z]))|\W|_/$1 /g; # Replace according to '2. Split...' this will create
                                    #   a space separated string.
$_=lc;                              # lower case string
s/^ +| +(.)/\u$1/g                  # CamelCase the space separated string and remove any
                                    #   potential leading spaces.

Perl, 87 80 78 bajtów

y/'`//d;$_=join'',map{ucfirst lc}split/[a-z]\K(?=[A-Z][a-z])|\W|_/,$_;lcfirst

Dodano bajt dla -pflagi.

Najpierw używamy y///operatora transliteracji, aby dusunąć wszystkie '`znaki z wejścia:

y/'`//d;

Następnie pojawia się treść kodu:

                         split/[a-z]\K(?=[A-Z][a-z])|\W|_/,$_;

(podziel ciąg wejściowy $_w odpowiednich miejscach, używając fantazyjnego \Kciągu dopasowania, aby wykluczyć część poprzedzającą go z rzeczywistego dopasowania)

          map{ucfirst lc}

(odwzoruj każdą podzieloną część łańcucha i spraw, aby cały łańcuch był pisany małymi literami, a następnie uczyń pierwszy znak zmodyfikowanego łańcucha dużymi literami)

$_=join'',

(dołącz do pustej struny i ponownie przypisz do magicznego podkreślenia $_, które zostanie wydrukowane na końcu)

Na koniec zmniejszamy pierwszą literę małymi literami, dopasowując ją\l do wyrażenia regularnego i używając ciągu zastępczego z wbudowanym, co pozwala zaoszczędzić 2 bajty w stosunku do poprzedniej metody:

lcfirst

Dzięki @ MartinBüttner za 7 bajtów ( [^a-zA-Z\d]-> \W|_)!

Lua, 127 bajtów

t=''l=t.lower z=io.read()for x in z:gmatch('%w+')do t=t..(t==''and l(x:sub(1,1))or x:sub(1,1):upper())..l(x:sub(2))end return t

Akceptuje ciąg ze standardowego wejścia i zwraca wyniki camelized.

Prawdopodobnie nadal będzie szukać lepszego rozwiązania, ponieważ przechowywanie wszystkiego w zmiennej wydaje się nieefektywne.

Ale w każdym razie całkiem proste:

 z:gmatch('%w+')

To piękno uratowało mi trochę bajtów. gmatch podzieli ciąg znaków na podstawie wzorca: %w+który przechwytuje tylko znaki alfanumeryczne.

Potem są to proste operacje na łańcuchach. string.upper, string.lower i gotowe.

PHP, 145 122 133 bajtów

<?=join(split(" ",lcfirst(ucwords(strtolower(preg_replace(["#`|'#","#\W|_#","#([a-z])([A-Z][a-z])#"],[""," ","$1 $2"],$argv[1]))))));

Zapisz do pliku, zadzwoń z CLI.
Pobiera dane wejściowe z jednego argumentu wiersza poleceń; w razie potrzeby unikaj cudzysłowów i białych znaków.

awaria

<?=                 // 9. print result
join(split(" ",     // 8. remove spaces
    lcfirst(        // 7. lowercase first character
    ucwords(        // 6. uppercase first character in every word
    strtolower(     // 5. lowercase everything
    preg_replace(
        ["#`|'#",   "#\W|_#",   "#([a-z])([A-Z][a-z])#"],
        ["",        " ",        "$1 $2"],
        // 2. replace apostrophes with empty string (remove them)
                    // 3. replace non-word characters with space
                                // 4. insert space before solitude uppercase
        $argv[1]    // 1. take input from command line
    ))))
));

lcfirstpozwolono zredukować to do jednego polecenia, oszczędzając 23 bajty.
Naprawienie apostrofów kosztuje 11 bajtów dla dodatkowego przypadku zamiany.

Kotlin , 160 bajtów

fun a(s: String)=s.replace(Regex("['`]"),"").split(Regex("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])")).map{it.toLowerCase().capitalize()}.joinToString("").decapitalize()

Moim celem była Scala, druga „alternatywna Java”, więc jestem trochę zadowolony z moich wyników. Ukradłem wyrażenie regularne z odpowiedzi Java .

Przetestuj za pomocą:

fun main(args: Array<String>) {
    val testCases = arrayOf(
            "Programming Puzzles & Code Golf",
            "XML HTTP request",
            "supports IPv6 on iOS?",
            "SomeThing w1th, apo'strophe's and' punc]tuation",
            "nothing special",
            "5pecial ca5e",
            "1337",
            "1337-spEAk",
            "abcD",
            "a",
            "B")
    testCases.forEach { println(a(it)) }

}

Scala, 181 170 144

def f(s:String)={val l=s.replaceAll("'|`","")split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])")map(_.toLowerCase);l(0)+l.tail.map(_.capitalize).mkString}

Próbnik:

val testCases = List(
  "Programming Puzzles & Code Golf" -> "programmingPuzzlesCodeGolf",
  "XML HTTP request" -> "xmlHttpRequest"
  // etc
)
println(testCases.map(t=>if(t._2!=f(t._1))s"FAIL:${f(t._1)}"else"PASS").mkString("\n"))

Rekwizyty do CAD97 i przeprosiny dla Nathana Merrilla :)

C 272 znaków

Program C przekazuje ciąg znaków do camelCase w cudzysłowach jako argument 1. W opisie problemu jest wiele gotchas ...

#define S strlen(t)
#define A isalnum(t[i])
j=0;main(i,v)char**v;{char*p=v[1],*t;char o[99]={0};while(t=strtok(p," [{(~!@#$%^*-+=)}]")){i=0;p+=S+1;while((!A)&&i<S)i++;if(i!=S){o[j]=((j++==0)?tolower(t[i++]):toupper(t[i++]));while(i<S){if(A)o[j++]=t[i];i++;}}}puts(o);}

JavaScript, 123 bajty

v=>v[r="replace"](/[`']/g,"")[r](/^.|.$|[A-Z][^a-z]+/g,x=>x.toLowerCase())[r](/[^a-z0-9]+./ig,x=>x.slice(-1).toUpperCase())

Wersja do odczytu

v=>
  v.replace(/[`']/g,"")
  .replace(/^.|.$|[A-Z][^a-z]+/g,x=>x.toLowerCase())
  .replace(/[^a-z0-9]+./ig,x=>x.slice(-1).toUpperCase())

Usuń apostrofy, umieść pierwszy znak małymi literami, ostatni znak małymi literami i dowolną grupę wielu wielkich liter, dopasuj dowolną grupę 1 lub więcej znaków niealfanumerycznych + 1 inny znak, zamień na ostatni znak wielkimi literami.

[r = "replace"] trick z rozwiązania Mrw247.