您的目标是像

Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good.

并创建一个字符串索引数组，其中组成单词“ Llama”的字母出现（顺序一个）。例如，让我显示用尖号指向的字母以显示索引：

Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good.
                                            ^                      ^        ^                            ^        ^

所以数组看起来像：

[44, 67, 76, 105, 114]

（如果您的应用程序使用的索引不是基于0的，则数字看起来会有所不同。可以。）

如果文本中没有驼峰，则数组应为空，nil，null或未定义。

接受任何代码语言。这是一场代码高尔夫比赛，因此最少的字符获胜！

果酱-33

lel"llama"{1$#)_T+:T\@>}/;]___|=*

它获取从1开始的索引（从0开始的更多2个字节）

说明：

l从输入中读取一行（替换q为整个输入）
el转换为小写字母
"llama"{...}/，对每个“美洲驼”字母执行该块，
1$复制当前字符串，
#找到字母的索引
)_增量，然后重复
T+:T添加T（最初为0），更新T并保留它在堆栈上
\@交换项目，现在我们有了current-T，索引，字符串
>切片，从索引开始的字符串会
;弹出，剩余的字符串会
]在数组中收集
索引。如果未找到任何字母，则该数组将重复。
___再制作3
|个阵列副本（包含2个阵列副本），以删除重复项
=比较，结果为0（如果有重复项）或1（如果没有）
*将数组乘以0或1次

Perl，52个字节

该解决方案作为将字符串作为参数并返回位置列表的函数提供。

• 基于位置的位置，区分大小写的搜索，不带换行符：52个字节

  sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/;@+[1..$#+]}

  区分大小写的搜索在问题示例中返回一个空数组，因为在匹配前三个字母后m，输入文本中缺少小写字母。

• 支持换行符：+ 1字节= 53字节

  sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/s;@+[1..$#+]}

  文本现在可以跨越几行。

• 不区分大小写的搜索：+ 1字节= 54字节

  sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/si;@+[1..$#+]}

  现在，问题中的示例报告了一个索引位置列表，它们是一个基于数字的数字：

  [45 68 77 106 115]
  

• 从零开始的位置：+ 9字节= 63字节

  sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/si;map{$_-1}@+[1..$#+]}

  问题中示例的结果：

  [44 67 76 105 114]
  

取消高尔夫：

后一种变体或多或少包括其他变体。

sub l {
    # pop() gets the last argument 
    pop() =~ /(l).*?(l).*?(a).*?(m).*?(a)/si;
    # the letters inbetween are matched against ".*?",
    # the non-greedy variant of ".*". Thus ".*?"
    # matches only as few as possible characters.
    # The modifier /i controls the case-sensitivity
    # and means ignore case. Without the case matters.
    # Modifier /s treats the string as single line,
    # even if it contains newlines.
    map { $_-1 }   # subtract 1 for zero-based positions
        @+[1..$#+]
    # Array @+ contains the end-positions of the last
    # submatches, and of the whole match in the first position.
    # Therefore the first value is sliced away.
    # @+ is available since Perl 5.6.
}

# test
my @result = l(<<"END_STR");
Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good.
END_STR
print "[@result]\n";

sed，299 + 1

是的，sed可以找到美洲驼。不，sed不能做数学。这是迄今为止最长的答案，为299 + 1个字符，因为我必须教sed才能计数。

此答案要求使用带有扩展正则表达式（sed -E或sed -r）的sed 。我使用了OpenBSD sed（1）。输入是每行一个字符串。（因此，字符串可能不包含换行符。）输出是一行数字，或者什么也没有。

用法（为+1个字符-r）：

$ echo 'All arms on all shoulders may ache.' | sed -rf llama.sed
1 2 12 26 30 

源代码（299个字符）：

s/%/z/g
s/(.*)[Aa]/\1%/
s/(.*)[Mm](.*%)/\1%\2/
s/(.*)[Aa]((.*%){2})/\1%\2/
s/(.*)[Ll]((.*%){3})/\1%\2/
s/(.*)[Ll]((.*%){4})/\1%\2/
/(.*%){5}/!d
s/[^%]/z/g
:w
s/(z*)%/\10 z\1/
s/z*$//
s/z0/1/
s/z1/2/
s/z2/3/
s/z3/4/
s/z4/5/
s/z5/6/
s/z6/7/
s/z7/8/
s/z8/9/
s/([0-9]z*)z9/z\10/g
s/(z*)z9/1\10/
/[%z]/bw

该程序首先用5个替换美洲驼%。（%此程序中的所有内容都是文字。）第一个命令将输入行中的s/%/z/g更改%为z。接下来的五个命令将查找美洲驼，因此所有肩膀上的所有手臂都可能疼痛。在％ll的肩膀上％ay％che变成了A %%的手臂。因为每个人.*都很贪婪，所以我总是在右边找到骆驼：骆驼骆驼会变成llama %%%%%。如果我不能得到5个%，则/(.*%){5}/!d删除输入行并跳过下一个命令。

s/[^%]/z/g改变每一个角色，但%到z。然后我进入一个循环。s/(z*)%/\10 z\1/将第一个更改%为0，z从左到右复制零个或多个，并在右边添加一个或多个z。因此，数量z等于索引。例如，由于第一个在索引2处，而第二个在索引8 处，则zz%zzz%...成为，zz0 zzzzzzzz%...这从字符串的末尾删除了多余的内容。%%s/z*$//z

接下来的11个命令z通过删除每个命令z并从开始计数来进行计数0。它计算像zzz0，zz1，z2，3。同样，1zzzz9变为z1zzz0（以后23）或zzzz9变为1zzz0（以后13）。该循环继续进行，直到没有更多%或z。

Fortran语言- 154 148

Fortran很喜欢打高尔夫球，但只是为了证明可以使用基于数学的语言来解析字符串，我做到了：

function f result(r);integer::r(5),j=1;do i=1,len(s);if(s(i:i)==a(j:j).or.s(i:i)==b(j:j)) then;r(j)=i;j=j+1;endif;enddo;if(any(r==0))r=0;endfunction

我通过消除f末尾不需要的字符来节省了一些字符，endfunction并使用if(any(r==0))代替if(.not.all(r>0))。

这要求：

1. s 成为文本字符串
2. a为小写测试（即llama）
3. b成为大写测试（即LLAMA）

完整，完整的程序是

program find_llama
   character(len=123) :: s = "Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good."
   character(len=5) :: a="llama",b="LLAMA"

   print *,f()
 contains
   function f result(r)
     integer::r(5),j=1
     do i=1,len(s)
        if(s(i:i)==a(j:j).or.s(i:i)==b(j:j)) then
           r(j)=i
           j=j+1
        endif
     enddo
     if(any(r==0)) r=0
   end function
end program find_llama

C＃-119

取字符串，输出数组。如果字符串中没有美洲驼，则为Null。

int[]a(string s){var i=0;var o="llama".Select((x,y)=>i=s.IndexOf(x,y>0?i+1:0));return o.All(x=>x>=0)?o.ToArray():null;}

红宝石，56 65 63

编辑：+9个字符，因此不区分大小写。

定义一个函数（lambda，从技术上来说）f。

f=->s{i=0;'LLAMA'.chars.map{|c|i=s.upcase.index(c,i+1)||break}}

nil如果没有骆驼返回。如果必须是[]（空数组），则只需||[]在最后}一个字符之前添加，总共四个额外字符。

可读版本：

innerLlama = -> str{
    index = 0;
    str.downcase!
    arr = 'llama'.each_char.map{|char|
        index = str.index(char, index + 1)
        break unless index
    }
    # uncomment this line for empty array on failure
    #arr || []
}

C-53

编译：

gcc -D L=\"llama\" -D W=\"Lie\ is\ good.\ \ I\ just\ ate\ a\ bunch\ of\ pies\ early\ this\ morning.\ \ Actually,\ it\ was\ closer\ to\ the\ afternoon.\ \ Mornings\ are\ good.\"

我用cygwin的gcc测试了此编译命令。其他环境可能对空格和其他特殊字符的处理方式有所不同。

从0开始的结果存储在array中r。如果字符串中没有驼峰，则其内容是不确定的。

• 区分大小写（53）

  i,m,r[5];main(){for(;W[i];i++)W[i]==L[m]?r[m++]=i:i;}

• 不区分大小写（58）

  i,m,r[5];main(){for(;W[i];i++)(W[i]|96)==L[m]?r[m++]=i:i;}

JavaScript（ECMAScript 6）-68个字符

(/((((.*l).*l).*a).*m).*a/.exec(s)||[]).map(x=>x.length-1).reverse()

假设要测试的字符串在变量中 s。如果您想将其转换为功能f=s=>，请添加前缀（附加5个字符）。

输出：

[]

不区分大小写-69个字符

(/((((.*l).*l).*a).*m).*a/i.exec(s)||[]).map(x=>x.length-1).reverse()

输出：

[68, 80, 93, 105, 114]

不区分大小写和首次匹配-74个字符

(/((((.*?l).*?l).*?a).*?m).*?a/i.exec(s)||[]).map(x=>x.length-1).reverse()

输出：

[44, 67, 76, 105, 114]

Python，100

我是有史以来最糟糕的高尔夫球手。：P

感谢@xnor削减了6个字节。

g,n,o='llama',0,[]
for i in s:
 if g:exec("o+=[n];g=g[1:];"*(i.lower()==g[0])+"n+=1")
o*=len(o)>4

o 包含之后的数组。

编辑：固定。

编辑2：len(g)对g，o==5要o>4按照@ XNOR的建议。

编辑3：@WolframH修复了它。

Python 71

假设输入s。在中输出o。

F=s.lower().find
o=F('l'),
for c in'lama':o+=F(c,o[-1]+1),
o*=min(o)>=0

编辑：从列表更改为元组以节省2个字节。

Python 100

import re
x=input()
print[re.search(r"l.*?(l).*?(a).*?(m).*?(a)",x,re.I).start(i) for i in range(5)]

样品：

in  = Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good.
out = [44, 67, 76, 105, 114]
in[out] = ['l', 'l', 'a', 'M', 'a']

哈斯克尔（111）

import Data.Char
l i(a:as)t@(b:bs)|a==b=i:l(i+1)as bs|True=l(i+1)as t
l _ _ _=[]
r s=l 0(map toUpper s)"LLAMA"

取消高尔夫：

import Data.Char

llama :: Int -> String -> String -> [Int]
llama i (a:as) t@(b:bs)
  | a==b      = i : llama (i+1) as bs
  | otherwise = llama (i+1) as t
llama _ _ _ = []

runme :: String -> [Int]
runme s = llama 0 (map toUpper s) "LLAMA"

例：

*Main> r "Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good."
[44,67,76,105,114]

Matlab，61 96

搜索字符串，并在搜索下一个字符之前用乱码替换所有匹配项。会离开s，如果不发生词不确定的。

t='llama';for q=1:5;s(q)=min(regexpi(z,t(q))),z(1:s(q))=0;end

请注意，如果允许区分大小写，则可以减少字符数。

之前的版本

 try;t='llama';for q=1:length(t);s(q)=find(lower(z)==t(q),1);z(1:s(q))=ones(1,s(q));end;catch;end

搜索字符串，并在查找下一个字符之前用乱码替换所有匹配项。如果找不到llama，则可能会丢弃错误处理（try-catch-end），然后程序将崩溃（但根据需要未定义s）。

实现方式：

>> z='Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good.';
>> try;t='llama';for q=1:length(t);s(q)=find(lower(z)==t(q),1);z(1:s(q))=ones(1,s(q));end;catch;end
>> s
s =

    45    68    77   106   115

没有错误处理：

t='llama';for q=1:length(t);s(q)=find(lower(z)==t(q),1);z(1:s(q))=ones(1,s(q));end

语言Java

 final int[] wordIndexInSentence(String sentence, String word)
  {
    final int[] returnArr = new int[word.length()];
    int fromIndex = 0;
    word = word.toUpperCase();
    sentence = sentence.toUpperCase();
    for (int i = 0; i < word.length(); i++)
    {
      final char c = word.charAt(i);
      returnArr[i] = sentence.indexOf(c, fromIndex);
      fromIndex = returnArr[i] > 0 ? returnArr[i] + 1 : fromIndex;
    }
    return returnArr;
  }

巨蟒（70）

r=[];c=-1
for x in'llama':c=s.lower().find(x,c+1);r+=[c]
r*=1-(-1in r)

我们'llama'依次搜索每个字符，从先前找到的字符的位置开始。如果未找到任何字符，则c成为的默认值-1，在这种情况下，最后一行变为r空列表。

编辑：发现str.find(s,...)可以调用s.find(...)，节省4个字符。

OpenEuphoria，147 128

我有两个例子。首先，最短：

object t=and_bits(gets(0),#DF),L="LLAMA",i=0,X={}for j=1 to 5 do 
i=find(L[j],t,i+1)X&=i 
end for 
if find(0,X) then X={} end if?X

如果我像上面的C版本那样使用“或”而不是“和”，则可以将其减少到126个字符。但是，这也将字符串匹配''!-!为llama。罕见，但仍然可能是错误。

object t=or_bits(gets(0),96),L="llama",i=0,X={}for j=1 to 5 do 
i=find(L[j],t,i+1)X&=i 
end for 
if find(0,X) then X={} end if?X

然后使用正则表达式的版本：

include std/regex.e
include std/sequence.e
include std/utils.e
object X=regex:find(new("(?i)(l).*?(l).*?(a).*?(m).*?(a)"),gets(0))
? iff(atom(X),{},vslice(X[2..6],2))

两者都从STDIN输入并发布到STDOUT。

编辑：较短的正则表达式示例：

include std/regex.e
include std/sequence.e
object X=regex:find(new("(?i)(l).*?(l).*?(a).*?(m).*?(a)"),gets(0))
if atom(X)then?{}else?vslice(X[2..6],2)end if

电源外壳 - 121 85

我仍在与Powershell一起练习，希望可以改进

$ s包含字符串，结果在数组$ a中

原始版本

$a=@();$w="llama";$n=$c=0;foreach ($i in $s.tochararray()) {if ($i -eq $w[$n]) {$a+=$c;$n+=1} $c+=1};$a*=$a.length -gt 4

不打高尔夫球

$a=@()
$w="llama"
$n=$c=0
foreach ($i in $s.tochararray()) {
 if ($i -eq $w[$n]) {
  $a+=$c
  $n+=1
 } $c+=1
}
$a*=$a.length -gt 4

新版本，感谢@goric

$a=@();$n=$c=0;[char[]]$s|%{if($_-eq"llama"[$n]){$a+=$c;$n++}$c++};$a*=$a.length-gt4

的PHP

还没有PHP的答案吗？我认为以字符串为导向的语言至少可以胜过基于数学的语言

function x($s){$i=$j=0;$r=str_split('llama');$s=strtolower($s);while($i<strlen($s)){if($s[$i]==$r[$j]){$r[$j]=$i;$j++;if($j>4)return$r;}$i++;}return[];}

152对fortran 154，已完成工作：P

不打高尔夫球

function x($s){
    $i=$j=0;$r=str_split('llama');
    $s=strtolower($s);
    while($i<strlen($s)){
        if ($s[$i]==$r[$j]){
            $r[$j]=$i;
            $j++;
            if($j>4)
                return $r;
        }
        $i++;
    }
    return[];
}

如果调用方始终传递小写字符串，则降低到137

JavaScript，122 115

function(s,b){z=[];for(i=0;i<5;i++){z.push(b=s.toLowerCase().indexOf("llama"[i],++b))};return z.indexOf(-1)<0?z:[]}

定义一个函数，该函数将字符串作为唯一参数（第二个arg便宜var），并返回一个空数组或5个元素的数组。

如果我将输入作为单个char变量（s）并将输出保留在另一个（b）中，则降至108 ：

var b=((z="llama".split('').map(function(a){return (b=s.toLowerCase().indexOf(a,++b))})).indexOf(-1)<0?z:[])

编辑：交换出地图的for循环。

雷布尔，97

f: func[s][a: copy[]foreach n"llama"[if none? s: find s n[return[]]append a index? s s: next s]a]

Rebol控制台中的用法示例：

>> f "Pie is good.  I just ate a bunch of pies early this morning.  Actually, it was closer to the afternoon.  Mornings are good." 
== [45 68 77 106 115]

>> f "nearly llami"       
== []

>> f "Llama"
== [1 2 3 4 5]

>> f reverse "llama"
== []

Rebol使用基于1的索引。[]如果找不到骆驼序列（不区分大小写），则返回空列表。

取消高尔夫：

f: func [s] [
    a: copy []
    foreach n "llama" [
        if none? s: find s n [return []]
        append a index? s
        s: next s
    ]
    a
]

APL，47岁

+\↑⊃{a s←⍵⋄~⍺∊s:⍬⍬⋄a,←n←s⍳⍺⋄a(n↓s)}/'amall',⊂⍬⍞

它不是最短的代码，但是以APL的方式相当复杂。

说明

'amall',⊂⍬⍞ 创建一个由6个元素组成的数组：字母“ amall”和一个由2个元素组成的子数组，它们本身是子数组：空数组和从输入中读取的一行字符。

{...}/... 使用提供的函数减少（右折）6元素数组。

a s←⍵ 将正确的参数分解为索引数组和剩余的子字符串（最初为空数组和完整字符串）。

~⍺∊s:⍬⍬ 如果子字符串不包含下一个字母 ⍺停止计算并返回空数组。

a,←n←s⍳⍺ 否则，找到它的位置，将其称为n，然后将其附加到索引数组。

a(n↓s) 生成并返回一个包含2个元素的数组：扩展的索引数组和其余的子字符串。

+\↑⊃... 解压缩折叠的输出，取出第一个元素（索引数组）并对其进行加法扫描，以将相对偏移量转换为绝对偏移量。

例子

      +\↑⊃{a s←⍵⋄~⍺∊s:⍬⍬⋄a,←n←s⍳⍺⋄a(n↓s)}/'amall',⊂⍬⍞
All cats meow aloud.
2 3 6 10 15

      +\↑⊃{a s←⍵⋄~⍺∊s:⍬⍬⋄a,←n←s⍳⍺⋄a(n↓s)}/'amall',⊂⍬⍞
Some cats purr instead.
 

朱莉娅76岁

使用Julia语言的另一个正则表达式示例。

f(s)=(m=match(r"(?i)(l).*?(l).*?(a).*?(m).*?(a)",s);m==nothing?m:m.offsets)