目的

您的目标是制作一个程序，将输入转换为其缩写。您输入的内容保证只有字母和空格。输入将在单词之间恰好有一个空格。您必须输出输入的首字母缩写词。

规则

• 您的代码不能区分大小写（例如foo和Foo相同）
• 您的代码必须忽略以下单词，并且不要将它们放在首字母缩写词中： and or by of
• 您不能假设单词都是小写。
• 输出必须全部大写，字符之间不能分隔。
• 尾随换行符可以接受，但不是必需的。
• 如果您的语言内置了首字母缩写词功能，则您可能无法使用它。

例子

（输入/输出分组）

United States of America
USA

Light Amplification by Stimulation of Emitted Radiation
LASER

united states of america
USA

Jordan Of the World
JTW

计分

这是一个代码高尔夫球挑战，因此最短的代码获胜。

排行榜

var QUESTION_ID=75448,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Pyth，25 21 20字节

shM-crz1dc4."@YK½¼

在这里尝试！

感谢@Jakube节省了一个字节！

说明

shM-crz1dc4。“ @YK½¼＃z =输入

     rz1＃将输入转换为大写
    cd＃在空格处分割输入
         c4。“ @ YK1 /2¼＃从打包字符串中创建单词列表，该列表将被忽略
   -＃过滤掉那些词
 HM＃只取所有单词的首字母
s＃将它们连接成一个字符串

打包的字符串变为 ANDBYOROF

果冻，21 20字节

,“°ɲịĊs°gɗ»ṣ€⁶Œuḟ/Ḣ€

在线尝试！

（-1感谢@Dennis。）

,“°ɲịĊs°gɗ»              Pair input with the string "OR OF by AND"
           ṣ€⁶           Split both by spaces
              Œu         Uppercase
                ḟ/       Reduce filter (removing ignored words from input)
                  Ḣ€     Keep first letters of remaining words

果冻的字典有点古怪，因为它AND的字母是大写的，而by小写的...

视网膜，29 31 36字节

T`l`L
 |(AND|OR|BY|OF)\b|\B.

预期换行符结尾。

感谢MartinBüttner节省了5个字节

在线尝试

T`l`L                  # Replace lowercase with uppercase
 |(AND|OR|BY|OF)\b|\B. # Regex match, it doesn't matter if we match 'AND' in SHAND
                       #   since the 'SH' will still become 'S' or am I missing something?
                       # Replace with nothing

JavaScript（ES6），56个字节

感谢@ edc65，节省了一个字节。

s=>s.toUpperCase().replace(/\B.| |(AND|O[RF]|BY)\b/g,"")

说明

该代码是不言自明的，我只解释正则表达式：

\B.          // Matches any character (`.`), that's not the start of a word
|            // Matches spaces
|(...)\b     // Matches all the words that should be ignored

它删除了所有这些匹配的字符，并将单词大写

JavaScript，61 64 66 63字节

a=>a.toUpperCase().replace(/(AND|O[FR]|BY|(\w)\w+)( |$)/g,"$2")

它使用正则表达式查找不在列表中的获取单词：and, or, of, by，并捕获第一个字母。然后将大写的字母字符串大写。

编辑： 64字节-固定单词开头of,or,by,and

编辑： 66字节-固定为检查所有单词，包括最后一个单词。

编辑： 63字节-感谢@ edc65和@Cyoce节省了3个字节！

vim，46岁

gUU:s/ /\r/g<cr>:g/\vAND|OR|OF|BY/d<cr>:%s/.\zs.*\n<cr>

gUU                      make line uppercase
:s/ /\r/g<cr>            replace all spaces with newlines
:g/\vAND|OR|OF|BY/d<cr>  remove unwanted words
:%s/.\zs.*\n<cr>         remove all non-initial characters and newlines

我特别喜欢那最后一点。第一次.在正则表达式行的第一个字符相匹配。然后，我们\zs开始使用“实际上已被替换”部分，实际上不替换初始字符。.*匹配行的其余部分，并\n匹配尾随的换行符。由于我们没有指定替换字符串，因此vim会删除匹配中的所有内容，仅保留首字母。

CJam，28 24 22字节

qeuS/"AOBONRYFD"4/z-:c

在线尝试。感谢Sp3000指出一个错误并提出修复建议，并感谢Dennis保存了4个 6（！）字节。

说明

qeuS/  e# Convert the input to uppercase and split on spaces
"AOBONRYFD"4/z  e# Push the array of short words. See more below
-      e# Remove each short word from the input words
:c     e# Cast the remaining words to characters, which is a
       e# shorter way of taking the first letter

丹尼斯（Dennis）建议使用此技巧来缩短单词列表：AOBONRYFD分成四个部分，我们得到

AOBO
NRYF
D

用z运算符将列转换为行，我们得到正确的单词！

朱莉娅72 63 61 55字节

s->join(matchall(r"\b(?!AND|OR|OF|BY)\S",uppercase(s)))

这是一个匿名函数，它接受一个字符串并返回一个字符串。要调用它，请将其分配给变量。

我们将字符串转换为uppercase，选择正则表达式的每个匹配项\b(?!AND|OR|OF|BY)\S作为数组，然后将join其转换为字符串。

感谢Dennis，节省了8个字节！

Perl，32个字节

say uc=~/\b(?!AND|OR|OF|BY)\S/g

+1字节的-n标志。

@AlexA的Julia答案中的算法被盗。

Ruby，45个 43字节

->s{s.upcase.scan(/\b(?!AND|OR|OF|BY)\S/)*''}

这是一个lambda函数，它接受一个字符串并返回一个字符串。要调用它，请将其分配给变量并执行f.call(input)。

它使用与我的Julia答案相同的方法，即转换为大写字母，获取正则表达式的匹配项\b(?!AND|OR|OF|BY)\S并加入字符串。

在这里尝试

通过操作节省了2个字节！

PHP，92字节

第一次尝试打高尔夫。

foreach(explode(" ",str_replace(["AND","OR","BY","OF"],"",strtoupper($s)))as$x){echo$x[0];}

变量$s是要转换的短语：$s = "United States of America"。

需要PHP 5.4或更高版本才能使用短数组语法。

Bash + GNU coreutils，103 76字节

for i in ${@^^};do grep -qE '\b(AND|OR|BY|OF)\b'<<<$i||echo -n ${i:0:1};done

与运行

./codegolf.sh Light Amplification BY Stimulation of Emitted Radiationofo

要么用单引号引起来，要么用多引号引起来。

（我扭曲的最后一个字包含的）。

60字节

感谢@manatwork。

for i in ${@^^};{ [[ $i = @(AND|OR|BY|OF) ]]||printf %c $i;}

JavaScript，104 85字节

@ Aplet123节省了19个字节。

用空格分割字符串，然后检查它是否是or或or和or的词。如果是，它将忽略它，否则将使用它的第一个字母。然后，它加入数组并使字符串大写。

a=_=>_.split` `.map(v=>/\b(o(f|r)|and|by)\b/i.test(v)?"":v[0]).join("").toUpperCase()

取消高尔夫：

function a(_) {
       _ = _.split` `; //Split on spaces
       _ = _.map(function(v){return new RegExp("\b(o(f|r)|and|by)\b","i").test(v)}); //Check if the banned words are in the result
       _ = _.join(""); //Join it into a string
       _ = _.toUpperCase(); //Convert it to uppercase
};

MATL，34 27字节

@AandN少了1个字节

KkYb'OF AND OR BY'YbX-c1Z)!

在线尝试！

Xk                  % convert to uppercase
Yb                  % split by spaces. Gives a cell array of input words
'AND OR BY OF'      % ignored words separated by spaces
Yb                  % split by spaces. Gives a cell array of ignored words
X-                  % setdiff: remove ignored words (result is stable)
c                   % convert to 2D char array, padding words with spaces
1Z)                 % take first column
!                   % transpose into a row

05AB1E，33 32 28字节

码：

‘€ƒ€—€‚€‹‘ð¡)Uuð¡)vXyQO>iy¬?

使用CP-1252编码。

Python，81个字节

lambda s:''.join(c[0]for c in s.upper().split()if c not in'AND OF OR BY'.split())

Haskell，100 99 98 82 75字节

我肯定它可以被缩短了很多，因为我在使用还是吸$，.等于是我继续使用()insted的=）

感谢@nimi为您提供帮助！

import Data.Char
w=words
x=[h!!0|h<-w$toUpper<$>x,notElem h$w"OF BY OR AND"]

例：

*Main> a "united states by america"
"USA"

Python，103 96字节

这是我第一次尝试打码高尔夫，而且可能还会打更多次。感谢DenkerAffe保存了七个字符。

lambda x:"".join([x[0]for y in x.split(" ") if y.lower() not in ['and','or','of','by']]).upper()

它接受输入，将其转换为单词列表，如果不是禁止的单词之一，则采用它们的第一个字母，然后将所有内容都转换为大写。

JavaScript，80 72 55 53字节

码

function a(t){t=t.toUpperCase();t=t.replace(/AND|OR|BY|OF|\B.| |/g,"");return t}

function a(t){return t.toUpperCase().replace(/AND|OR|BY|OF|\B.| |/g,"")}

我刚刚阅读了箭头功能，并意识到我可以进一步缩短它。

a=t=>t.toUpperCase().replace(/AND|OR|BY|OF|\B.| |/g,"")

根据这个，你不要指望在长度分配，所以-2字节。

t=>t.toUpperCase().replace(/AND|OR|BY|OF|\B.| |/g,"")

这是我的第一次高尔夫，所以不太好。

PHP，68 61 58字节

使用ISO-8859-1编码。

for(;$w=$argv[++$x];)stripos(_AND_OR_BY_OF,$w)||print$w&ß;

像这样运行（-d仅出于美观目的而添加）：

php -d error_reporting=30709 -r 'for(;$w=$argv[++$x];)stripos(_AND_OR_BY_OF,$w)||print$w&ß; echo"\n";' united states oF america

取消高尔夫：

// Iterate over the CLI arguments (words).
for(;$w = $argv[++$x];)
    // Check if the word is one of the excluded words by substring index.
    // The check is case insensitive.
    stripos("_AND_OR_BY_OF", $w) ||
        // Print the word, converting to uppercase and getting only the
        // first char by using bitwise AND.
        print $w & "ß";

• 通过使用按位与（而不是）节省了7个字节ucwords。
• 通过使用ISO-8859-1编码并将ß（binary 11011111）用作二进制AND而不是取反空间（binary 00100000），节省了3个字节。

数学，132个 117字节

ToUpperCase[First/@Characters@DeleteCases[StringDelete[StringSplit@#,"of"|"and"|"or"|"by",IgnoreCase->True],""]<>""]&

@CatsAreFluffy节省了15个字节。

PowerShell，81字节

(-join($args[0].Split(" ")|?{$_-notmatch"^(and|or|by|of)$"}|%{$_[0]})).ToUpper()

说明

在空格上分割以创建数组。删除违规成员。拉第一个角色并加入。使用ToUpper()上生成的字符串。

Lua，122字节

我很想使用一种模式来摆脱被禁止的单词，但是可悲的是，lua不能匹配字符组……所以我不得不使用for循环，这要昂贵得多。

s=arg[1]for k,v in next,{"of","and","by","or"}do
s=s:gsub(v,"")end
print(s:gsub("(%a)%a+",string.upper):gsub("%s","").."")

不打高尔夫球

s=arg[1]                               -- initialise s with the argument
for k,v in next,{"of","and","by","or"} -- iterate over the array of banned words
do
    s=s:gsub(v,"")                     -- replace the occurences of v by 
end                                    --   an empty string
print(s:gsub("(%a)%a+",                -- replace words (separated by spaces)
              string.upper)            -- by their first letter capitalised
         :gsub("%s","")                -- replace spaces with empty strings
                       .."")           -- concatenate to prevent the number of 
                                       -- substitutions to be shown

因子175字节

通过写这篇文章，我学到了很多东西。

USING: strings ascii sets splitting kernel sequences math.ranges ;
>lower " " split [ { "and" "or" "by" "of" } in? not ] filter [ first dup [a,b] >string ] map "" join >upper 

一句话：

USING: strings ascii sets splitting kernel sequences math.ranges ;

: >initialism ( str -- str )
  >lower " " split                            ! string.lower.split(" ")
  [ { "and" "or" "by" "of" } in? not ] filter ! word in { } ?
  [ first dup [a,b] >string ]          map    ! word[0]
  "" join >upper ;                            ! "".join.upper

单元测试：

USING: tools.test mk-initialism ;
IN: mk-initialism.tests

{ "LASER" } [ "Light Amplification by Stimulation of Emitted Radiation" >initialism ] unit-test
{ "USA"   } [ "United States OF Americaof" >initialism ]                              unit-test
{ "USA"   } [ "united states and america" >initialism ]                               unit-test
{ "JTW"   } [ "Jordan Of the World" >initialism ]                                     unit-test

通过！

Lua中，113个 112 93字节

arg[1]:upper():gsub("%w+",function(w)io.write(("AND OR BY OF"):find(w)and""or w:sub(0,1))end)

C＃，134个字节

打高尔夫球

class P{static void Main(string[] a){foreach (var s in a){if(!"AND OR BY OF".Contains(s.ToUpper())){Console.Write(s.ToUpper()[0]);}}}}

可读的

class P
{
    static void Main(string[] a)
    {
        foreach (var s in a)
        {
            if (!"AND OR BY OF".Contains(s.ToUpper()))
            {
                Console.Write(s.ToUpper()[0]);
            }
        }
    }
}

从命令行执行

75448.exe通过刺激发射辐射进行光放大

激光

75448.exe美国

美国

IPOS-非竞争性，27个字节

uS`"AND|OR|BY|OF"ER`%S!h%S-

这在解释器的当前版本（v0.2）中有效。

运行示例

python IPOS.py -i“美利坚合众国”美国`\“ AND | OR | BY | OF \” ER`％S！h％S-
美国

此处的反斜杠仅用于转义引号，程序不需要。

说明

u＃使输入大写
S＃将一个空间压入堆栈
`“ AND | OR | BY | OF” ER`＃将命令压入堆栈，以替换正则表达式的匹配项
                   ＃带空字符串
％＃在空格上分割大写输入字符串，应用命令并
                   ＃重新加入空格。这将从输入中删除必需的单词。
S＃将一个空间压入堆栈
！h＃推送仅选择字符串首字符的命令
％＃在空格上分割，应用命令并在空格上重新加入
S-＃删除剩余的空间（忘记使用该空间
                   ＃使用正则表达式，可以在这里为我节省一些字节:(）

bash / GNU coreutils，60个字节

sed -e's/\b'{and,o[rf],by}'\W*//Ig' -re's/(\w)\S* ?/\u\1/g'

Pylongolf2，14个字节（UTF-8）

c| l1╨3♀~

Pylongolf2有许多非ASCII字符，算作2个字节。

c| l1╨3♀~
c         read input
 |        split by space (note the space after |)
   l1     substring(0, 1)
     ╨3   convert to uppercase
       ♀~ pop the array into the stack and print it.

05AB1E，19字节（非竞争...？）

lð¡“€ƒ€—€‹€‚“#K€нJu

在线尝试！

一个肯定有竞争的版本（21字节）：

lð¡“€ƒ€—€‹€‚“#Kvy0èuJ

在线尝试！