이 사이트 에 따르면 미국 정부 인쇄소 스타일 매뉴얼에서 권장하는 일반적인 규칙 은 다음과 같습니다.

a, an, the, at, by, for, in, on, to, up, and, as, but, or 및 nor를 제외한 출판물 및 문서 제목의 모든 단어를 대문자로 표기하십시오.

Style Manual 에서 그러한 권장 사항을 찾을 수 없으므로 이것은 사실이 아니지만 어쨌든이 규칙을 사용합시다.

도전

공백으로 구분 된 소문자로 구성된 입력 문자열이 제공된 경우 다음 규칙에 따라 문자열의 대문자를 출력하십시오.

• 첫 단어와 마지막 단어는 대문자입니다.
• 다른 모든 단어를 제외하고, 대문자 , , , 에 , 에 의해 , 에 , 에 , 의 , 에 , 에 , 최대 , 및 , 등 , 하지만 , 나 , 그리고 나 .

입력 문자열에는 하나 이상의 단어가 포함되며 각 단어에는 하나 이상의 문자와 a~ 사이의 문자 만 포함 됩니다 z.

이것은 코드 골프 도전이므로 선택한 언어로 가능한 적은 바이트를 사용하십시오. 과제를 완수하기 위해 전체 프로그램 또는 기능을 작성할 수 있습니다.

테스트 케이스

"the rule of thumb for title capitalization" -> "The Rule of Thumb for Title Capitalization"
"programming puzzles and code golf" -> "Programming Puzzles and Code Golf"
"the many uses of the letter a" -> "The Many Uses of the Letter A"
"title" -> "Title"
"and and and" -> "And and And"
"a an and as at but by for in nor of on or the to up" -> "A an and as at but by for in nor of on or the to Up"
"on computable numbers with an application to the entscheidungsproblem" -> "On Computable Numbers With an Application to the Entscheidungsproblem"

파이썬 2, 118 바이트

엄마 좀 봐, 정규식!

for w in`input()`.split():print[w.title(),w][`w`in"'a'an'and'as'at'the'by'but'for'nor'in'of'on'or'to'up'"].strip("'"),

입력은 따옴표로 묶어야합니다. 출력에는 후행 공백이 있고 후행 줄 바꿈이 없습니다 (괜찮습니다). Ideone의 모든 테스트 사례를 확인하십시오 .

설명

입력 a or an을 예로 들어 봅시다 .

Python 2의 `x`바로 가기를 사용 repr하여 입력을 작은 따옴표로 묶습니다 'a or an'. 그런 다음 공백으로 나누고 단어를 반복합니다.

루프 내부에서 repr 다시 가져옵니다 . 첫 번째와 마지막 단어의 경우, 이것은 제공 "'a"하고 "an'". 다시 말해, 그것은을 제공합니다 'or'. 우리는 단어가 후자의 패턴에 적합하고 짧은 단어 목록에 있으면 대문자를 사용하지 않기를 원합니다. 따라서 단어 목록을 문자열로 나타낼 수 있고 짧은 단어 중 하나가 하위 문자열이 "'a'an'...'up'"된다는 것을 알 repr수 있습니다.

`w` in "..."boolean 값을 제공하며 ,리스트로 색인화 할 목적 으로 0또는이 1를 처리 할 수 ​​있습니다 [w.title(), w]. 요컨대, 단어의 시작, 끝 또는 짧은 단어 목록에없는 경우 제목을 붙입니다. 그렇지 않으면 우리는 그것을 내버려 둡니다. 다행히도 title()여전히 같은 입력에서 예상대로 작동합니다 'a.

마지막으로 단어에서 작은 따옴표를 제거하고 후행 공백으로 인쇄합니다.

05AB1E , 68 61 바이트

Adnan 덕분에 7 바이트 절약

™ð¡Dg<UvyN__NXQ_“a€¤€€€›€‹€‡€†€‚€‰€„€¾€ƒ€œ€³€—š¯“#™yå&&il})ðý

온라인으로 사용해보십시오!

설명

“a€¤€€€›€‹€‡€†€‚€‰€„€¾€ƒ€œ€³€—š¯“로 번역 된 사전 문자열 a an the at by for in of on to up and as but or nor입니다.

™                          # title case input string
ð¡                         # split on spaces
Dg<U                       # store index of last word in X

vy                         # for each word
  N__                      # is it not first index?
     NXQ_                  # is it not last index
         “...“             # the compressed string 
              #            # split on spaces
               ™           # convert to title case
                yå         # is current word in this list?
                  &&       # and the 3 previous conditions together
                    il     # if all are true, convert to lower case
                      }    # end loop
)ðý                        # wrap stack in list and join by spaces

GNU sed 81 74 73 바이트

-r에 +1 포함

s/\b./\u&/g
:;s/.(And?|A[st]?|The|By|But|[FN]or|In|O[fnr]|To|Up) /\L&/;t

첫 줄은 모든 단어의 첫 글자를 대문자로 표시합니다. 두 번째는 필요한 모든 단어를 소문자로 다시 전환합니다.

온라인으로 사용해보십시오!

레티 나, 69 66 바이트

모든 단어의 첫 글자를 대문자로 한 다음 선택한 단어가 첫 단어 나 마지막 단어가 아닌 경우 소문자로 변경하십시오. 마지막 줄 끝에 공백이 있습니다.

T`l`L`\b.
+T`L`l` (And?|A[st]?|The|By|But|[FN]or|In|O[fnr]|To|Up) 

온라인으로 사용해보십시오

이것은 .첫 번째 공간 대신에 작동 합니다.

같은 길이의 정규 표현식이 많이 있지만 더 이상자를 수있는 방법을 찾을 수 없습니다 ...

자바 스크립트 (ES6) 141 138 135 133 바이트

mbomb007 덕분에 3 바이트 절약

s=>s.replace(/(\w+)( ?)/g,(a,w,n,i)=>i&&n&&/^(a[nst]?|the|by|in|of|on|to|up|and|but|[fn]?or)$/.exec(w)?a:a[0].toUpperCase()+a.slice(1))

테스트 사례

let f =

s=>s.replace(/(\w)(\w*)( ?)/g,(a,l,w,n,i)=>i&&n&&/^(a[nst]?|the|by|in|of|on|to|up|and|but|[fn]?or)$/.exec(l+w)?a:l.toUpperCase()+w+n)

console.log(f("the rule of thumb for title capitalization"));
console.log(f("programming puzzles and code golf"));
console.log(f("the many uses of the letter a"));
console.log(f("title"));
console.log(f("and and and"));
console.log(f("a an and as at but by for in nor of on or the to up"));
console.log(f("on computable numbers with an application to the entscheidungsproblem"));

젤리 , 58 바이트

“Ð/ṃƇ¬þṄẊƙ€,⁽ṙƬ®OṪJ"ɦ3×kf3Ṙç%ġu’b26ịØaṣ”z
e€¢¬T;2Ḷ¤
ḲŒtǦK

TryItOnline! 또는 모든 테스트를 실행

방법?

단어를 분리 구역으로 압축 된 문자열이 될 47IT 비용 분할 바이트 1에 대한 바이트를 48바이트.

길이의 말씀의 두 분리되지 않은 압축 된 문자열 2과 3각각 것 (하나의 끝 부분에 'A'와) 40바이트 + 2각을 분할하고 1위해, 그들과 합류하는 45바이트.

아래에 설명 된대로 하나 개의 기본 250 수는 32바이트, 다음 3,베이스 (26)로 변환 3소문자 알파벳으로 색인하고 3, 사용되지 않는 문자에 분할 'z'을 위해, 41바이트.

따라서 대문자를 사용하지 않는 단어에 대한 조회는 다음
“Ð/ṃƇ¬þṄẊƙ€,⁽ṙƬ®OṪJ"ɦ3×kf3Ṙç%ġu’
과 같이 구성되었습니다.

그 단어를 가져 와서 구분 기호로 결합하십시오.
s="a an the at by for in of on to up and as but or nor"

다음 라벨 'a'로서 1, 'b'같은 2세퍼레이터와 같이 0:

alpha = ' abcdefghijklmnopqrstuvwxyz'
x = [alpha.index(v) for v in s]
x
[1,0,1,14,0,20,8,5,0,1,20,0,2,25,0,6,15,18,0,9,14,0,15,6,0,15,14,0,20,15,0,21,16,0,1,14,4,0,1,19,0,2,21,20,0,15,18,0,14,15,18]

이것을 기본 26숫자 로 변환하십시오 (마지막으로 사용한 문자 'y'는 구분 기호의 숫자와 파이썬 코드입니다 :
n=sum(v*26**i for i,v in enumerate(x[::-1]))

250숫자를 목록을 사용하여 기본 번호 로 변환하십시오 .

b=[]
while n:
    n,d = divmod(n,250)
    b=[d]+b
b
[16,48,220,145,8,32,202,209,162,13,45,142,244,153,9,80,207,75,35,161,52,18,108,103,52,205,24,38,237,118]

젤리의 코드 페이지에서 해당 색인의 문자를 찾으십시오.

codepage = '''¡¢£¤¥¦©¬®µ½¿€ÆÇÐÑ×ØŒÞßæçðıȷñ÷øœþ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR TUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¶°¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ƁƇƊƑƓƘⱮƝƤƬƲȤɓƈɗƒɠɦƙɱɲƥʠɼʂƭʋȥẠḄḌẸḤỊḲḶṂṆỌṚṢṬỤṾẈỴẒȦḂĊḊĖḞĠḢİĿṀṄȮṖṘṠṪẆẊẎŻạḅḍẹḥịḳḷṃṇọṛṣṭụṿẉỵẓȧḃċḋėḟġḣŀṁṅȯṗṙṡṫẇẋẏż«»‘’“”'''
r=''.join(codepage[i-1] for i in b)
r
'Ð/ṃƇ¬þṄẊƙ€,⁽ṙƬ®OṪJ"ɦ3×kf3Ṙç%ġu'

(참고 : 실제 구현은 형 용성 b이 없으므로 0숫자가 있으면 먼저 수행해야합니다)

나머지:

ḲŒtǦK - Main link: title string
Ḳ      - split on spaces
    ¦  - apply to indexes
   Ç   -     given by calling the last link (1) as a monad (with the split title string)
 Œt    -     title case (first letter of each (only) word to upper case)
     K - join on spaces

e€¢¬T;2Ḷ¤ - Link 1, find indexes to capitalise: split title string
e€        - is an element of, for €ach
  ¢       - the result of calling the last link (2) as a nilad
   ¬      - logical not
    T     - get the truthy indexes (indexes of words that are not in the list)
     ;    - concatenate with
        ¤ - nilad followed by link(s) as a nilad
      2Ḷ  - range(2) -> [0,1]
                (we always want to capitalise the first index, 1, and the last index, 0)

“Ð/ṃƇ¬þṄẊƙ€,⁽ṙƬ®OṪJ"ɦ3×kf3Ṙç%ġu’b26ịØaṣ”z - Link 2, make the word list: no arguments
“Ð/ṃƇ¬þṄẊƙ€,⁽ṙƬ®OṪJ"ɦ3×kf3Ṙç%ġu’          - the base 250 number
                                b26       - convert to base 26
                                   ị      - index into
                                    Øa    - lowercase alphabet
                                      ṣ   - split on
                                       ”z - literal 'z' (the separator 0 indexes into `z`)

PHP, 158 바이트

@Titus 님이 저장 한 10 바이트

foreach($w=explode(" ",$argv[1])as$k=>$v)echo" "[!$k],$k&&$k+1<count($w)&&preg_match("#^(a[snt]?|and|[fn]or|up|by|but|the|to|in|o[rnf])$#",$v)?$v:ucfirst($v);

이전 버전 PHP, 174 바이트

foreach($w=explode(" ",$argv[1])as$k=>$v)$k&&$k+1<count($w)&&in_array($v,[a,an,the,at,by,"for",in,of,on,to,up,"and","as",but,"or",nor])?:$w[$k]=ucfirst($v);echo join(" ",$w);

TI 기본, 295 + 59 + 148 = 502 바이트

이제 계산기를 활용할 수 있습니다. 학교에 좋습니다 :)

메인 프로그램, 295 바이트

기본적으로 단어가 일치 A하지 않도록 일치시키는 요령 a은로 바꾸기 " A "와 같이 공백으로 묶는 것 입니다 " a ". 또한 첫 번째 단어와 마지막 단어가 양쪽에 공백이 없으므로 단어와 일치하지 않기 때문에 첫 단어와 마지막 단어는 대문자로 유지됩니다. (천재, 맞습니까? 그리고 소문자가 각각 2 바이트이기 때문에 매우 깁니다 ...)

"("+Ans+")→Str1
"@A ~ a@An ~ an@The ~ the@At ~ at@By ~ by@For ~ for@In ~ in@Of ~ of@On ~ on@To ~ to@Up ~ up@And ~ and@As ~ as@But ~ but@Or ~ or@Nor ~ nor@→Str2
For(I,2,length(Ans
If "@"=sub(Str2,I-1,1
Then
" "+Str1+"~"+sub(Str2,I,inString(Str2,"@",I)-I)+" "
prgmQ
Ans→Str1
End
End

서브 프로그램 ( prgmQ), 59 바이트 :

Ans→Str9
inString(Ans,"~
sub(Str9,Ans,length(Str9)-Ans+1→Str8
Str9
prgmR
Repeat Str9=Ans+Str8
Ans+Str8→Str9
prgmR
End

서브 프로그램 ( prgmR), 148 바이트 :

Ans→Str0
inString(Ans,"~→Z
inString(Str0,"~",Ans+1→Y
inString(sub(Str0,1,Z-1),sub(Str0,Z+1,Ans-Z-1→X
sub(Str0,1,-1+inString(Str0,"~
If X
sub(Str0,1,X-1)+sub(Str0,Y+1,length(Str0)-Y)+sub(Str0,X+length(sub(Str0,Z+1,Y-Z-1)),Z-X-length(sub(Str0,Z+1,Y-Z-1

PS ~는 토큰을 나타내고 토큰 0x81을 @나타냅니다 . 0x7F자세한 내용은 여기를 참조 하십시오 .

자바 7, 271 259 258 바이트

String c(String x){String a[]=x.split(" "),s=" ",r=w(a[0])+s;for(int i=0,l=a.length-1;i<l;r+=(!s.matches("^(a[nst]?|the|by|in|of|on|to|up|and|but|[fn]?or)$")|i==l?w(s):s)+" ")s=a[++i];return r;}String w(String w){return(char)(w.charAt(0)-32)+w.substring(1);}

언 골프 및 테스트 코드 :

여기에서 시도하십시오.

class M{
  static String c(String x){
    String a[] = x.split(" "),
           s = " ",
           r = w(a[0]) + s;
    for(int i = 0, l = a.length-1; i < l; r += (!s.matches("^(a[nst]?|the|by|in|of|on|to|up|and|but|[fn]?or)$") | i == l
                                                 ? w(s)
                                                 : s)   + " "){
      s = a[++i];
    }
    return r;
  }

  static String w(String w) {
    return (char)(w.charAt(0) - 32) + w.substring(1);
  }

  public static void main(String[] a){
    System.out.println(c("the rule of thumb for title capitalization"));
    System.out.println(c("programming puzzles and code golf"));
    System.out.println(c("the many uses of the letter a"));
    System.out.println(c("title"));
    System.out.println(c("and and and"));
    System.out.println(c("a an and as at but by for in nor of on or the to up"));
    System.out.println(c("on computable numbers with an application to the entscheidungsproblem"));
  }
}

산출:

The Rule of Thumb for Title Capitalization 
Programming Puzzles and Code Golf 
The Many Uses of the Letter A 
Title 
And and And 
A an and as at but by for in nor of on or the to Up 
On Computable Numbers With an Application to the Entscheidungsproblem 

당연, 131 (129)

카루소 컴퓨팅 덕분에 2 바이트 절약

{it.split()*.with{a->a in "a an the at by for in of on to up and as but or nor".split()?a:a.capitalize()}.join(" ").capitalize()}

C #, 305 바이트

여전히 개선의 여지가 많이 있지만 여기에 있습니다.

s=>{;var b=s.Split(' ');b[0]=((char)(b[0][0]-32))+b[0].Substring(1);int i=0,n=b.Length;for(;++i<n;)if(!"a,an,the,at,by,for,in,of,on,to,up,and,as,but,or,nor".Split(',').Contains(b[i]))b[i]=((char)(b[i][0]-32))+b[i].Substring(1);b[n-1]=((char)(b[n-1][0]-32))+b[n-1].Substring(1);return string.Join(" ",b);};

루비, 123 117 111 102 바이트

->s{s.gsub(/ .|^./,&:upcase).gsub(/ (A[nts]?|The|By|In|To|Up|And|But|[NF]or|O[rnf])(?= )/,&:downcase)}

모든 수정 사항에 대해 죄송합니다. 마지막 수정 사항입니다.

파이썬, 177 바이트

바이트 저장 목적으로 함수 형식으로 제공됩니다. 이것은 특히 경쟁적인 답변은 아니지만 요구하지 않는 답변입니다.repr() 하거나 regex속이지 입니다. 또한 버전에 구애받지 않습니다. Python 2 또는 3에서 작동합니다.

아마도 매우 규칙적인 해결책 일 것입니다.

def t(s):
 w="a an the the at by for in of on to up and as but or nor".split()
 l=[(s.title(),s)[s in w]for s in s.split()]
 for x in(0,-1):l[x]=l[x].title()
 return' '.join(l)

PHP, 109 142 바이트

<?=preg_replace_callback("# (A[snt]?|And|[FN]or|Up|By|But|The|To|In|O[rnf])(?= )#",function($m){return strtolower($m[0]);},ucwords($argv[1]));

의 합병 user59178's 및 mbomb007's 대답.

모든 단어의 첫 글자를 대문자로 한 다음 공백으로 둘러싸인 목록의 모든 단어를 소문자로 만듭니다.
불행히도 콜백은 전체 세트에서 작동해야합니다. 이 비용은 29 바이트입니다.

라켓 353 바이트

(define(cap i)(set! i(string-append i))(define c(string-ref i 0))(string-set! i 0(if(char-upper-case? c)c(integer->char(-(char->integer c)32))))i)
(let*((ex(list"a""an""the""at""by""for""in""of""on""to""up""and""as""but""or""and""nor"))(sl(string-split s)))
(string-join(for/list((i sl)(n(in-naturals)))(cond[(= n 0)(cap i)][(member i ex)i][(cap i)]))))

언 골프 드 :

(define (f s)

  (define (cap i)                 ; sub-fn to capitalize first letter of a word
    (set! i (string-append i))
    (define c (string-ref i 0))
    (string-set! i 0
                 (if (char-upper-case? c)
                     c
                     (integer->char (-(char->integer c)32))))
    i)

  (let* ((ex (list "a""an""the""at""by""for""in""of""on""to""up""and""as""but""or""and""nor"))
         (sl (string-split s)))
    (string-join
     (for/list
         ((i sl)
          (n (in-naturals)))
       (cond
         [(= n 0) (cap i)]
         [(member i ex) i]
         [(cap i)]
         )))))

테스트 :

(f "the rule of thumb for title capitalization")

산출:

"The Rule of Thumb for Title Capitalization"

자바 7, 431 317 311 바이트

114 바이트의 @KevinCruijssen에게 감사 합니다. 6 바이트
를 절약 해 준 @RosLup에게 감사 합니다.

String c(String s){String v="",x,l[]=s.split(" "),b[]={"a","an","the","at","but,"by","for","in","of","on","to","‌​up","as","or","and","nor"};int i=0,f=0,z=0;for(String c:l){for(f=0;f<b.length;z=c.equals(b[f++])|z>0?1:0);x=(char)(c.charAt(0)-32)+c.substring(1);v+=(z>0?i<1|i>l.length-2?x:c:x)+" ";i++;}return v;}

언 골프

250 바이트 이상의 첫 번째 답변

 static String c(String s) {
      String v = "", x, l[] = s.split(" "),
b[]={"a","an","the","at","by","for","in","of","on","to",
                                         "‌​up","and","as","or","nor","but"};
    int i , f , z = i = f = 0;
    for (String c : l) {

   for (f = 0; f < b.length; z = c.equals( b[f++] ) | z > 0 ? 1 : 0);
        x = (char)(c.charAt(0) - 32) + c.substring(1);

        v += (z > 0 ? i < 1 | i > l.length - 2 ? x : c : x) + " ";
        i++;
   }
    return v;
    }

PHP, 117 (118) 112 바이트

<?=strtr(ucwords(preg_replace("# (?=(a[snt]?|and|[fn]or|up|by|but|the|to|in|o[rnf]) )#","!",$argv[1])),'!',' ');

동작을 사용합니다 ucwords()공백으로 둘러싸인 관련 단어 하고 이스케이프 한 다음 이스케이프 문자를 삭제합니다.

나는 복사 (a[snt]?|and|[fn]or|up|by|but|the|to|in|o[rnf])Jörg Hülsermann의 답변을 했지만 접근법이 완전히 다르기 때문에 별도의 답변으로 게시하고 있습니다.

편집 : Titus가 발견 한 버그로 1 바이트를 수정했습니다. 또한 : strtr에 대한 유용한 의견 덕분에 6 바이트가 절약되었습니다.

순수한 bash -253

(외부 프로그램이 호출되지 않음)-bash v4 필요

declare -A b;for x in A An The At By For In Of On To Up And As But Or Nor;do b[$x]=1;done
while read -a w;do
n=${#w[@]};o[0]=${w[0]^}
for((i=1;i<n-1;i++)){
g=${w[$i]^};((${b[$g]}))&&o+=(${g,,})||o+=($g);}
((n>1))&&o[$n]=${w[-1]^}
echo ${o[@]};o=()
done

주석이있는 일반보기

#create the "blacklist"
declare -A b
for w in A An The At By For In Of On To Up And As But Or Nor
do
    b[$x]=1
done

# logic:
# read each line (split by words) into array
# and each word is assigned capitalized to the new output array
# but the blacklisted ones

#read each line to array w (split on spaces)
while read -a w
do
    n=${#w[@]}         # get the number of words
    o[0]=${w[0]^}          # copy the capitalized word1
    for((i=1 ; i<n-1 ; i++)) { # loop over 2 up to last -1 words

        g=${w[$i]^}    # for the given word
        # check if it is in the blacklisted ones
        # if yes - convert to lowercase, if not leave as it is
        # and append to the output array
        (( ${b[$g]} )) && o+=(${g,,}) || o+=($g)
    }
    # capitalize the last word if here is more words
    (( n>1 )) && o[$n]=${w[-1]^}
    # make a line from the words
    echo ${o[@]}
    o=() #cleanup
done

산출

Title
And and And
The Rule of Thumb for Title Capitalization
Programming Puzzles and Code Golf
The Many Uses of the Letter A
A an and as at but by for in nor of on or the to Up
On Computable Numbers With an Application to the Entscheidungsproblem

Japt , 71 바이트

£`a  e  by f     up d  ¿t  n`¸aX >0©Y¦0©YĦZl ?X:Xg u +XÅ}S

온라인으로 사용해보십시오!

설명:

£`a  e  by f     up d  ¿t  n`¸aX >0©Y¦0©YĦZl ?X:Xg u +XÅ}S
£`...`qS aX >0&&Y!=0&&Y!=UqS l -1?X:Xg u +Xs1}S

£                                            }S   // Split at spaces and map each item X by this function:
 `...`                                            //  Backticks are used to decompress strings
      qS                                          //  Split the decompressed string at spaces.
         aX >J                                    //  If this contains X
              &&Y!=0                              //  and the index is non-zero (it's not the first word)
                    &&Y!=UqS l -1                 //  and the index is not the length of the input -1 (it's not the last word),
                                 ?X               //  return X.
                                   :Xg u +Xs1     //  Else, return X capitalized. (Literally X[0].toUpperCase() + X.slice(1))
                                             }S   // Rejoin with spaces

내가 가장 좋아하는 Japt 기능 중 하나는 shoco 라이브러리 를 사용하는 문자열 압축입니다 입니다.

줄을 감아 서 압축 할 수 있습니다 Oc"{string}"→Oc"a an the at by for in of on to up and as but or nor"

그런 다음 백틱으로 압축을 풀거나 Od"{compressed string}"→Od"a e by f up d ¿t n"

순수 bash - 205 192 181 바이트

tc(){
while read -a x
do x=(${x[@]^})
for ((i=1;i<${#x[@]}-1;i++))
do
case "${x[i]}" in
A|A[nts]|The|By|[FN]or|In|O[fnr]|To|Up|And|But)x[i]=${x[i],};;
esac
done
echo ${x[@]}
done
}

처럼 jm66의 답변 tc 표준 입력을 허용합니다.

사실은 79 바이트

' ,ÿsd@p@`;0"A0An0The0At0By0For0In0Of0On0To0Up0And0As0But0Or0Nor"síu'ù*ƒ`Moq' j

온라인으로 사용해보십시오!

설명:

' ,ÿsd@p@`;0"longstring"síu'ù*ƒ`Moq' j
' ,ÿs                                   title case input, split on spaces
     d@p@                               pop first and last words to stack
         `;0"longstring"síu'ù*ƒ`M       for every word except the first and last:
          ;0"longstring"s                 duplicate word, split the long string on 0s
                         íu               1-based index of word in list (0 if not found)
                           'ù*            "ù"*(index)
                              ƒ           execute the resulting string as a function (lowercases word if it's in the list)
                                 oq' j  put the first and last word back in the list, join with spaces

배치, 323 바이트

@echo off
set s=
for %%w in (@%*@)do call:w %%w
echo%s%
exit/b
:w
for %%s in (a an the at by for in of on to up and as but or nor)do if %%s==%1 set s=%s% %1&exit/b
set w=%1
set w=%w:@=%
set f=%w:~0,1%
for %%c in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)do call set f=%%f:%%c=%%c%%
set s=%s% %f%%w:~1%

의견 :

@echo off
rem Start with an empty output string
set s=
rem Wrap the parameters in @ signs to identify the first and last words 
for %%w in (@%*@) do call :w %%w
rem Ignore the leading space when printing the result
echo%s%
exit/b
:w
rem Check whether this is a word that we don't change
for %%s in (a an the at by for in of on to up and as but or nor) do if %%s==%1 set s=%s% %1&exit/b
set w=%1
rem Delete any @ signs from the first and last words
set w=%w:@=%
rem Get the first character
set f=%w:~0,1%
rem Case insensitively replace each upper case letter with itself
for %%c in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z) do call set f=%%f:%%c=%%c%%
rem Concatenate with the rest of the word
set s=%s% %f%%w:~1%