Seu objetivo é receber informações como

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

e crie uma matriz dos índices da cadeia de caracteres onde as letras que compõem a palavra "lhama" aparecem (uma de cada em ordem). Por exemplo, deixe-me mostrar as letras apontadas com sinais de intercalação para mostrar os índices:

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

Portanto, a matriz seria semelhante a:

[44, 67, 76, 105, 114]

(Se o seu aplicativo usar uma indexação que não seja baseada em 0, os números parecerão diferentes. Tudo bem.)

Se o texto não tiver lhama, a matriz deverá estar vazia, nula, nula ou indefinida.

Qualquer idioma de código é aceito. Este é um concurso de código-golfe , portanto, o mínimo de personagens vence!

CJam - 33

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

Obtém os índices baseados em 1 (mais 2 bytes para os baseados em 0)

Explicação:

llê uma linha da entrada (substitua qpor toda a entrada)
elconverte em minúsculas
"llama"{...}/executa o bloco para cada letra "lhama"
1$copia a string atual
#encontra o índice dos
)_incrementos da letra e duplicatas
T+:Tadiciona T (inicialmente 0), atualiza T e deixa-o na pilha
\@troca os itens ao redor, agora temos a corrente-T, índice,
>fatias de sequência; a sequência iniciada no índice
;aparece; a sequência restante
]reúne os índices em uma matriz.
Nesse ponto, temos todos os índices baseados em 1; Se nenhuma letra foi encontrada, a matriz terá duplicatas.
___faz mais 3 cópias da matriz
|(com 2 cópias da matriz) remove duplicatas
=compara, resultando em 0 se houver duplicatas ou 1 se não
*multiplica a matriz 0 ou 1 vezes de acordo

Perl, 52 bytes

A solução é fornecida como função que pega a string como argumento e retorna uma lista de posições.

• Posições com base única, pesquisa com distinção entre maiúsculas e minúsculas, sem novas linhas: 52 bytes

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

  A pesquisa com distinção entre maiúsculas e minúsculas retorna uma matriz vazia no exemplo da pergunta, porque depois de corresponder as três primeiras letras, a letra minúscula mestá faltando no texto de entrada.

• Suporte de novas linhas: + 1 byte = 53 bytes

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

  O texto agora pode abranger várias linhas.

• Pesquisa que não diferencia maiúsculas de minúsculas: + 1 byte = 54 bytes

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

  Agora, o exemplo da pergunta relata uma lista de posições de índice, são números baseados em um:

  [45 68 77 106 115]
  

• Posições baseadas em zero: + 9 bytes = 63 bytes

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

  Resultado para o exemplo na pergunta:

  [44 67 76 105 114]
  

Ungolfed:

A última variante inclui mais ou menos as outras variantes.

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

Sim, o sed pode encontrar uma lhama. Não, sed não pode fazer contas. Esta é a resposta mais longa até agora, com 299 + 1 caracteres, porque eu tive que ensinar sed a contar.

Esta resposta requer um sed com expressões regulares estendidas ( sed -Eou sed -r). Eu usei o OpenBSD sed (1) . A entrada é uma sequência por linha. (Portanto, a seqüência de caracteres pode não conter uma nova linha.) Saída é uma linha de números ou nada.

Uso (+1 caractere para -r):

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

Código fonte (299 caracteres):

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

O programa primeiro substitui a lhama por cinco %. (Todos %neste programa são literais.) O primeiro comando s/%/z/galtera qualquer um %para zna linha de entrada. Os próximos cinco comandos encontram a lhama, então todos os braços em todos os ombros podem doer. torna-se A %% nos braços de% ll ombros% ay% che. Como cada um .*é ganancioso, sempre encontro a lhama à direita: lhama lhama se tornaria lhama %%%%% . Se eu não conseguir cinco %, /(.*%){5}/!dexclui a linha de entrada e pula os próximos comandos.

s/[^%]/z/gmuda todos os caracteres, exceto %para z. Então eu insiro um loop. s/(z*)%/\10 z\1/altera o primeiro %para 0, copia zero ou mais zda esquerda para a direita e adiciona mais um zpara a direita. É assim que o número de zserá igual ao índice. Por exemplo, zz%zzz%...torna-se zz0 zzzzzzzz%...porque o primeiro %estava no índice 2 e o próximo %no índice 8. s/z*$//remove extra zdo final da string.

Os próximos onze comandos contam z, removendo cada um deles ze contando 0. Ele conta como zzz0, zz1, z2, 3. Além disso, 1zzzz9torna-se z1zzz0(mais tarde 23) ou zzzz9torna - se 1zzz0(mais tarde 13). Esse loop continua até que não exista mais %ou z.

Fortran - 154 148

O Fortran é péssimo no golfe, mas apenas para provar que a análise de strings pode ser feita em uma linguagem baseada em matemática, eu fiz isso:

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

Salvei alguns caracteres eliminando o não obrigatório fno final endfunctione usei em if(any(r==0))vez de if(.not.all(r>0)).

Isto exige:

1. s ser a string com texto
2. apara ser o teste em minúsculas (ou seja llama)
3. bpara ser o teste em maiúsculas (ou seja, LLAMA)

O programa completo, sem golfe, é

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

Pega string, gera matriz. Nulo se não houver lhama na corda.

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;}

Ruby, 56 65 63

Editar : +9 caracteres para não fazer distinção entre maiúsculas e minúsculas.

Define uma função (lambda, tecnicamente) f.

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

Retorna nilse não houver lhama. Se tiver que ser [](matriz vazia), basta adicionar ||[]antes da última }para um total de 4 caracteres extras .

Versão legível:

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

Ajuntar com:

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.\"

Testei esse comando de compilação com o gcc do cygwin. Outros ambientes podem manipular espaços e outros caracteres especiais de maneira diferente.

O resultado baseado em 0 é armazenado na matriz r. Seu conteúdo é indefinido se não houver lhama na string.

• Sensível a maiúsculas e minúsculas (53)

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

• Não diferenciando maiúsculas de minúsculas (58)

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

JavaScript (ECMAScript 6) - 68 caracteres

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

Supõe que a sequência a ser testada esteja na variável s . Se você deseja transformá-lo em uma função, f=s=>acrescente (para 5 caracteres adicionais).

Saídas:

[]

Não diferencia maiúsculas de minúsculas - 69 caracteres

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

Saídas:

[68, 80, 93, 105, 114]

Insensível a maiúsculas e minúsculas - 74 caracteres

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

Saídas:

[44, 67, 76, 105, 114]

Python, 100

Eu sou o pior jogador de golfe de todos os tempos. : P

Agradecemos ao @xnor por remover 6 bytes.

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 contém a matriz depois.

EDIT : Fixed.

EDIÇÃO 2 : len(g)para g, o==5de o>4acordo com as sugestões do @ xnor.

EDIT 3 : @WolframH corrigiu.

Python 71

Assume entrada s. Saída em o.

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

Editar: Alterado das listas para tuplas para economizar 2 bytes.

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)]

Amostra:

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']

Haskell, 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"

Ungolfed:

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"

Exemplo:

*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

Pesquisa a string e substitui tudo até cada correspondência por sem sentido antes de procurar o próximo caractere. Não será sdefinido se a palavra não ocorrer.

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

Observe que o charcount pode ser reduzido se a distinção entre maiúsculas e minúsculas for permitida.

Versões prévias

 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

Pesquisa a string e substitui tudo até cada correspondência por sem sentido antes de procurar o próximo caractere. O tratamento de erros (try-catch-end) pode ser eliminado e o programa falhará (mas s seria indefinido conforme necessário) se o lhama não for encontrado.

Implementação:

>> 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

Sem tratamento de erros:

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

Linguagem 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;
  }

Python (70)

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

Por 'llama'sua vez, pesquisamos cada personagem , começando após a localização do personagem encontrado anteriormente. Se nenhum caractere for encontrado, cse tornará o valor padrão de -1, nesse caso a última linha será girada.r na lista vazia.

Editar: descoberto que str.find(s,...)pode ser invocado como s.find(...), salvando 4 caracteres.

OpenEuphoria, 147 128

Eu tenho dois exemplos Primeiro, o mais curto:

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

Eu posso diminuir para 126 caracteres se eu usar "ou" em vez de "e" como a versão C acima. No entanto, isso também corresponde à string ''!-!como llama. Incomum, mas ainda possível.

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

E então a versão usando expressões regulares:

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))

Ambos recebem entrada de STDIN e postam em STDOUT.

EDIT: Exemplo de regex mais curto:

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

Powershell - 121 85

Ainda pratico com o PowerShell, espero que isso melhore

$ s contém a string, o resultado está na matriz $ a

Versão original

$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

Ungolfed

$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

Nova versão, com grandes agradecimentos a @goric

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

PHP

nenhuma resposta PHP ainda? Eu acho que uma linguagem fortemente orientada a strings pode superar pelo menos uma baseada em matemática

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 contra fortran 154, trabalho realizado: P

destroçado

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[];
}

se o chamador sempre passa uma string em minúscula, diminui para 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:[]}

Define uma função que usa uma string como seu único argumento (o segundo argumento é barato var) e retorna uma matriz vazia ou uma matriz de 5 elementos.

Desce para 108 se eu pegar a entrada em uma única variável char ( s) e deixar a saída em outra ( b):

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

Edit: Trocou o mapa para o loop for.

Rebol, 97

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

Exemplo de uso no console 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 usa indexação baseada em 1. Retorna a lista vazia []se nenhuma sequência de lhama for encontrada (sem distinção entre maiúsculas e minúsculas).

Ungolfed:

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',⊂⍬⍞

Não é o código mais curto, mas bastante distorcido, de uma maneira APL.

Explicação

'amall',⊂⍬⍞ Faça uma matriz de 6 elementos: as letras 'amall' e uma sub-matriz de 2 elementos, elas mesmas sub-matrizes: a matriz vazia e uma linha de caracteres lidas na entrada.

{...}/... Reduza (dobre à direita) a matriz de 6 elementos usando a função fornecida.

a s←⍵ Decomponha o argumento correto na matriz de índices e na subsequente substring (inicialmente a matriz vazia e a sequência completa).

~⍺∊s:⍬⍬ Se a substring não contiver a próxima letra, ⍺interrompa o cálculo e retorne a matriz vazia.

a,←n←s⍳⍺ Caso contrário, encontre sua posição, chame-a de n e anexe-a à matriz de índices.

a(n↓s) Crie e retorne uma matriz de 2 elementos: a matriz estendida de índices e a subsequente substring.

+\↑⊃... Desembale a saída da dobra, pegue o primeiro elemento (a matriz de índices) e faça a varredura com adição, para transformar as compensações relativas em absolutas.

Exemplos

      +\↑⊃{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.
 

Julia, 76

Outro exemplo de regex usando a linguagem Julia.

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