因此，如果短语是单词的缩写，则需要一种更好的方法来解决。您还认为，看看所涉及的短语和单词是否是递归首字母缩写是值得的。

你的任务：

给定一个单词，然后给出一个由行分隔的词组，如果该词组是首字母缩写词，然后是递归首字母缩写词，则输出。（该短语包含其含义）

输入将由字母字符以及空格组成。
您的程序不应区分大小写。

输入/输出示例：

情况1：

输入：

Acronyms
Acronyms can really obviously narrow your message sensors

输出：

True 
True

情况2：

输入：

FAQ
frequently asked questions

输出：

True 
False

情况3：

输入：

foo
bar baz

输出：

False
False

情况4：

输入：

GNU
GNU is not Unix

输出：

False
False

情况5：

输入：

Aha
A huge Aha

输出：

True
True

code-golf decision-problem

— 蓝色
source

69

首字母缩略词可以递归吗？哦! 现在，您说得通了。

— Geobits，2015年

2

不，只要清楚输出的是什么

— Blue Blue

9

这让我想起了XKCD：xkcd.com/917

— ETHproductions

1

有关。

— Martin Ender

4

ABCDE：另一个明确定义的基本示例。

— John Dvorak

10

佩斯，19 18

&pqJrz0hCKcrw0)}JK

这样会以相当奇怪的格式打印结果，例如：TrueFalse。

您可以在线尝试或运行测试套件。

说明：

&pqJrz0hCKcrw0)}JK      :
    rz0    rw0          : read two lines of input, and convert each to lower case
          c   )         : chop the second input on whitespace
   J     K              : store the first line in J and the chopped second line in K
  q    hC               : zip K and take the first element, check if it is the same as J
 p                      : print and return this value
&              }JK      : and the value with whether J is in K, implicit print

— 弗莱姆·埃格曼
source

15

Python 3、89

由于使用了SOPython，节省了很多字节。

a=input().lower()
d=input().lower().split()
h=tuple(a)==next(zip(*d))
print(h,h&(a in d))

此解决方案最复杂的部分是h=tuple(a)==next(zip(*d))。
这会将列表解压缩d为zip，然后调用next以返回每个可迭代对象的第一个元素的zip元组，然后将其与（tuple(a)）中每个字母的元组进行比较。

— 摩根·塔普
source

您可以通过替换节省7个字节[0]==l 的.startswith(l)。

— 斯凯勒

7

CJam，21个 20字节

qeuN/)S/_:c2$s=_p*&,

在CJam解释器中尝试这种小提琴或立即验证所有测试用例。

怎么运行的

qeu                  e# Read from STDIN and convert to uppercase.
   N/                e# Split at linenfeeds.
     )S/             e# Pop the second line form the array.
      S/             e# Split it at spaces.
        _:c          e# Push a copy and keep on the initial of each word.
           2$s       e# Push a copy of the line array and flatten it.
                     e# This pushes the first line.
              =      e# Check for equality.
               _p    e# Print a copy of the resulting Boolean.
                 *   e# Repeat the word array 1 or 0 times.
                  &  e# Intersect the result with the line array.
                   , e# Push the length of the result (1 or 0).

— 丹尼斯
source

4

Haskell，81个 80字节

import Data.Char
f[a,b]|c<-words b=(a==map(!!0)c,elem a c)
p=f.lines.map toLower

输出格式没有严格定义，因此我返回一对布尔值，例如p "Aha\na huge arm"-> (True,False)。

— 妮米
source

今天，我了解了防卫图案（<-），谢谢！

— wchargin

4

Scala中，135 110 108个字节

val Array(x,y)=args.map(_.toLowerCase)
val z=y.split(" ").map(_(0)).mkString
print(z==x,z==x&&y.contains(z))

通过使用命令行参数节省了一些字节（感谢J Atkin的提示），将布尔值作为tupel输出，使用mkString而不是new Stringand print而不是println。

编辑：误解了问题，并且不得不重新实现解决方案

— 浪费
source

3

Python 3，106个字节

好吧，至少它击败了Scala;）

x=input().lower()
y=input().lower().split()
g=all(x[i]==y[i][0]for i in range(len(y)))
print(g,g&(x in y))

— Beta衰变
source

1

@muddyfish可能需要对每个示例进行更多的说明，才能防止其他人遇到这种情况。

— Beta Decay 2015年

沙箱中的更多时间会有所帮助吗？根据我的经验（显然相当有限），您只会在它几乎位于顶部时得到答复

— Blue Blue

@muddyfish好吧，我不知道您还等了多久，我也不知道

— Beta Decay 2015年

我离开那里了大约一天

— 蓝

@muddyfish建议每周使用一次

— Beta Decay，

3

AppleScript的，302 301 297 293个字节

w，是的。甚至不怕我输了，这对AppleScript很有竞争力。

设置x为（显示对话框““默认答案”“）的文本返回
将y设置为（显示对话框““默认答案”“））返回的文字
将n设置为y的项目编号
重复n
尝试
如果不是y的项n的字符1 =（x作为文本）的字符n，则返回{false，false}
结束
将n设置为n-1
结束
return {true，x in y}

输出为：

{真假}

或无论答案是什么。

— 艾迪生·克伦普
source

2

PHP，120字节

大小写不敏感（26字节）。通过了所有测试案例：

foreach($c=explode(' ',strtolower($argv[2]))as$l)$m.=$l[0];var_dump($x=$m==$a=strtolower($argv[1]),$x&&in_array($a,$c));

以这种形式输出两个布尔值：

bool(true)
bool(false)

从命令行读取两个参数，例如：

a.php Acronyms "Acronym can really obviously narrow your message sensors"

不打高尔夫球

$acronym = strtolower($argv[1]);
$words = strtolower($argv[2]);
$words = explode(' ', $words);

foreach($words as $word) {
    $letters .= $word[0];
}

$isAcronym = $letters == $acronym;

var_dump(
    $isAcronym,
    $isAcronym && in_array($acronym, $words)
);

— 在此处插入用户名
source

2

红宝石， 77 74字节

b=gets.chop.upcase
a=gets.upcase
p c=a.scan(/\b\w/)*''==b,c&&a.include?(b)

— 达涅罗
source

1

Ruby，52个字节

p !!gets[/^#{x=gets.scan(/\b\w/)*""}$/i],!! ~/#{x}/i

例：

$ echo "Aha
A huge AHA" | ruby acronym.rb
true
true

— 文特罗
source

1

Matlab，90个字节

function z=f(r,s)
z=[sum(regexpi(s(regexpi(s,'(?<=(\s|^))\S')),r))>0 nnz(regexpi(s,r))>0];

实施例（注意，Matlab的显示true/ false作为1/ 0）：

>> f('Aha', 'A huge Aha')
ans =
     1     1

— 路易斯·门多
source

1

的JavaScript ES6，95 92个字节

(a,b)=>[(r=eval(`/^${a}$/i`)).test((s=b.split` `).map(c=>c[0]).join``),s.some(c=>r.test(c))]

输入两个字符串作为参数。输出具有两个值的数组：每个布尔值一个。

— Mwr247
source

1

我不会考虑使用regex代替.indexOf。干得好！也许r=eval(`/^${a}$/i`)可以代替您当前的r设置。

— ETHproductions 2015年

@ETHproductions反过来我也不会想到它eval是一个RegExp对象简化器。谢谢你的提示！

— Mwr247

0

GNU sed，118个字节

需要-r标志，得分为+1。请注意，\b尽管我找不到在GNU sed中记录的内容，但我正在使用单词边界匹配。它对我有用 ...

N
h
s/^(.*)\n.*\b\1\b.*/True/i
/\n/s/.*/False/
x
:
s/(.)(.*\n)\1[^ ]* ?/\2/i
t
/../s/.*/False/
/F/h
/F/!s/.*/True/
G

展开：

#!/bin/sed -rf

N
h

# Is it recursive?
s/^(.*)\n.*\b\1\b.*/True/i
# If no replacement, there's still a newline => false
/\n/s/.*/False/

x

# Is it an acronym?
# Repeatedly consume one letter and corresponding word
:
s/(.)(.*\n)\1[^ ]* ?/\2/i
t
# If more than just \n remain, then false
/../s/.*/False/
# And falsify recursive, too
/F/h
# !False => true
/F/!s/.*/True/

G

— 托比·斯皮特（Toby Speight）
source

0

Groovy，91个字节

a=args*.toLowerCase()
println([a[1].split()*.charAt(0).join("")==a[0],a[1].contains(a[0])])

输出格式为[bool, bool]。这是从命令行args输入的格式。

— 阿特金
source

0

Lua 5.3，182字节

a=""b=io.read c=a.lower d=a.reverse e=d(c(b()))f=~e:len()h=a.sub g=d(c(b()))for m in g:gmatch"[^ ]+"do f=-~f if h(e,f,f)~=h(m,~0)then break end k=k or m==e end f=f>~1print(f,f and k)

— MeepDarknessMeep
source

0

R，93个字节

a=tolower(readLines(,2));cat(a[1]==gsub("([^ ])\\w* ?","\\1",a[2]),a[1]%in%scan(t=a[2],w=""))

用法：

> a=tolower(readLines(,2));cat(a[1]==gsub("([^ ])\\w* ?","\\1",a[2]),a[1]%in%scan(t=a[2],w=""))
Aha
A huge Aha
Read 3 items
TRUE TRUE
> a=tolower(readLines(,2));cat(a[1]==gsub("([^ ])\\w* ?","\\1",a[2]),a[1]%in%scan(t=a[2],w=""))
Acronyms
Acronyms can really obviously narrow your message sensors
Read 8 items
TRUE TRUE
> a=tolower(readLines(,2));cat(a[1]==gsub("([^ ])\\w* ?","\\1",a[2]),a[1]%in%scan(t=a[2],w=""))
FAQ
frequently asked questions
Read 3 items
TRUE FALSE
> a=tolower(readLines(,2));cat(a[1]==gsub("([^ ])\\w* ?","\\1",a[2]),a[1]%in%scan(t=a[2],w=""))
foo
bar baz
Read 2 items
FALSE FALSE

— 浮游动物
source

0

`awk` 137字节

awk 'BEGIN{T="True";F="False"}NR*NF<2{a=tolower($1)}END{for(i=1;i<=NF;i++)b=b substr(tolower($i),1,1);print(a==b?T:F)"\n"(a==tolower($1)?T:F)}'

初始化T="True";F="False"以简化输出。
NR*NF<2{a=tolower($1)}：a仅在第一行只有一个字段时设置。
END{...}：仅假设两行...
- for(i=1;i<=NF;i++)b=b substr(tolower($i),1,1)：构造递归首字母缩写词。
- print(a==b?T:F)"\n"(a==tolower($1)?T:F)：打印两个比较的输出，a==b和a==tolower($1)。

如果有人知道如何优化递归首字母缩写词的构造，请随时提出建议。

— j
source

0

SpecBAS-144字节

1 INPUT a$,b$: LET a$=UP$(a$),b$=UP$(b$),d$="": DIM c$(SPLIT b$,NOT " ")
2 FOR EACH w$ IN c$(): LET d$=d$+w$(1): NEXT w$
3 TEXT d$=a$'POS(a$,b$)>0

将2 x输入转换为大写可节省字符与小写转换。现在可以在一个LET语句中完成多个分配，这也很有帮助。并TEXT保存一个字符PRINT。

使用1/0表示对/错（撇号仅将输出移至下一行）。

— 布赖恩
source

0

Perl5，90个字节

($a,$b)=map{chomp;lc}<>;print((join"",map{substr($_,0,1)}split/ /,$b)ne $a?0:($b=~$a?2:1))

作弊：0 =全部为假，1 =一个为真，2 =都为真。我不是高尔夫球手，但是浏览时缺少心烦的perl！

($a,$b)=map{chomp;lc}<>;              # get the two lines as lowercase
print((                               #
join"",map{substr($_,0,1)}split/ /,$b # collapse first letters of secondline
     ) ne $a  ? 0 : ( $b=~$a ? 2 : 1))# 0 nothing, 1 not recursive, or 2

— 将
source

0

JavaScript（ES6）93

(w,s)=>s[L='toLowerCase'](w=w[L](z=y='')).replace(/\w+/g,v=>y+=v[z=z||v==w,0])&&[y=y==w,y&&z]

在任何符合EcmaScript 6的浏览器中测试运行以下代码段

f=(w,s)=>s[L='toLowerCase'](w=w[L](z=y='')).replace(/\w+/g,v=>y+=v[z=z||v==w,0])&&[y=y==w,y&&z]

// TEST

out=x=>O.innerHTML+=x+'\n';

;[
 ['Acronyms', 'Acronyms can really obviously narrow your message sensors', true, true]
,['FAQ', 'frequently asked questions', true, false]
,['foo', 'bar baz', false, false]
,['GNU', 'GNU is not Unix', false, false]
,['Aha', 'A huge Aha', true, true]
,['Lolcat', 'Laughing over lolcat captions and tearing.', true, true]
,['ABCDE', 'Another basic clearly defined example.', true, false]
,['GNU', 'Gnus nettle unicorns', true, false]
,['PHP', 'PHP Hypertext Preprocessor', true, true]
].forEach(([a,b,c,d]) => (
  [r,s]=f(a,b), 
  out(((r==c && s==d)?'OK ':'KO ') + a + ',' + b + ' -> ' + f(a,b))
))

<pre id=O></pre>

展开摘要

— edc65
source

0

JavaScript（ES6），89 96 95字节

(a,b)=>[p=(a=a[l='toLowerCase']())==(c=b[l]().split` `).map(x=>x[0]).join``,p&&c.some(x=>x==a)]

cks ...我以为我把一切都整理好了，但是显然我错了。

这定义了一个匿名函数，该函数将输入作为两个字符串，并返回两个布尔项的数组。通过将所有小写字母的第一个字符串与第二个字符串中每个单词的第一个字符进行比较来计算出第一项。仅通过检查第二个字符串是否包含第一个字符串即可计算出第二个项目。

这是第二项的另一个解决方案。短2个字节，但很少有浏览器支持它：

p&&c.includes(a)

— ETH生产
source

检查第二个字符串是否包含第一个字符串失败GNU: Gnus nettle unicorns

— edc65

请再次检查：尝试过，甚至无法正常工作：（之前ReferenceError: l is not defined缺少）l=toLowerCase

— edc65

...修复了该错误，对于'GNU','GNU is not unix'（测试用例4）应为false，false 失败

— edc65

@ edc65糟糕，我l=在寻找错误的同时清除了该内容，却忘记了将其放回原处。感谢您提出来！其他测试用例也应固定。

— ETHproductions 2015年

0

Pyke（发布时无标题），（非竞争性），20字节

l1c"jFh)J"iQl1qDji{&

您可以在此处找到源代码，语言是完全不稳定的（这是它的第一个测试挑战），所以不要指望它将来会起作用（commit 8）

或18个字节（稳定）

l1idcmhsRl1jqDji{&

在这里尝试！

— 蓝色
source

首字母缩略词确实可以明显缩小您的消息感应器

你的任务：

输入/输出示例：

佩斯，19 18

说明：

Python 3、89

CJam，21个 20字节

怎么运行的

Haskell，81个 80字节

Scala中，135 110 108个字节

Python 3，106个字节

AppleScript的，302 301 297 293个字节

PHP，120字节

红宝石， 77 74字节

Ruby，52个字节

Matlab，90个字节

的JavaScript ES6，95 92个字节

GNU sed，118个字节

展开：

Groovy，91个字节

Lua 5.3，182字节

R，93个字节

awk 137字节

SpecBAS-144字节

Perl5，90个字节

JavaScript（ES6）93

JavaScript（ES6），89 96 95字节

Pyke（发布时无标题），（非竞争性），20字节

或18个字节（稳定）

`awk` 137字节