Ваша цель состоит в том, чтобы воспринимать как

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

и создайте массив индексов строки, где появляются буквы, составляющие слово «лама» (по одной по порядку). Например, позвольте мне показать буквы, на которые указывают каретки, чтобы показать индексы:

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, числа будут выглядеть иначе. Это нормально.)

Если текст не имеет ламы, то массив должен быть пустым, нулевым, нулевым или неопределенным.

Любой код языка принимается. Это соревнование по коду-гольфу , поэтому выигрывает меньше всего персонажей!

CJam - 33

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

Он получает индексы на основе 1 (еще 2 байта для основанных на 0)

Объяснение:

lчитает строку из ввода (заменить qна весь ввод)
elпреобразует в нижний регистр
"llama"{...}/выполняет блок для каждой буквы "llama"
1$копирует текущую строку,
#находит индекс
)_приращения буквы и дублирует,
T+:Tдобавляет T (изначально 0), обновляет T и оставляет его в стеке происходит
\@обмен элементами, теперь у нас есть current-T, index, string,
>срезы строки, начинающиеся с индекса,
;всплывающие, оставшаяся строка
]собирает индексы в массиве.
На данный момент у нас есть все индексы, основанные на 1; если ни одна буква не была найдена, массив будет иметь дубликаты.
___делает еще 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]
  

Ungolfed:

Последний вариант включает более или менее другие варианты.

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

сед, 299 + 1

Да, сед может найти ламу. Нет, Сед не умеет заниматься математикой. Это самый длинный ответ, до 299 + 1 символов, потому что я должен был научить sed считать.

Этот ответ требует sed с расширенными регулярными выражениями ( sed -Eили sed -r). Я использовал 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

Программа сначала заменяет ламу пятью %. (Все %в этой программе являются буквальными.) Первая команда s/%/z/gменяет любое %на zво входной строке. Следующие пять команд находят ламу, поэтому все руки на всех плечах могут болеть. становится %% оружия на% ll плечи% ay% che. Потому что каждый.* жадный, я всегда нахожу ламу справа: лама становится ламой %%%%% . Если я не могу получить пять %, то /(.*%){5}/!dудаляет строку ввода и пропускает следующие команды.

s/[^%]/z/gменяет каждый символ, кроме %как z. Затем я вхожу в цикл. s/(z*)%/\10 z\1/изменяет первый %на 0, копирует ноль или более zслева направо и добавляет еще одинz справа. Это так, число zбудет равно индексу. Например, zz%zzz%...становится, zz0 zzzzzzzz%...потому что первый %был с индексом 2, а следующий %- с индексом 8. s/z*$//удаляет лишние zиз конца строки.

Следующие одиннадцать команд считаются z, удаляя каждую zи считая от 0. Он считает , как zzz0, zz1, z2, 3. Также 1zzzz9становится z1zzz0(позже 23) или zzzz9становится 1zzz0(позже 13). Этот цикл продолжается до тех пор, пока нет больше %или z.

Фортран - 154 148

Фортран отстой в игре в гольф, но просто чтобы доказать, что разбор строк можно сделать на математическом языке, я сделал это:

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

Принимает строку, выводит массив. Нуль, если в строке нет ламы.

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 символов, так что он не зависит от регистра.

Определяет функцию (лямбда, технически) f.

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

Возвращает, nilесли нет ламы. Если это должно быть [](пустой массив), то просто добавьте ||[]перед последним }всего 4 дополнительных символа.

Читаемая версия:

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

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

Я протестировал эту команду компиляции с помощью gg cygwin. В других средах пробелы и другие специальные символы могут обрабатываться иначе.

Результат на основе 0 сохраняется в массиве 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]

Питон, 100

Я самый худший игрок в гольф. :П

Спасибо @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 содержит массив после.

РЕДАКТИРОВАТЬ : Исправлено.

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

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"

Пример:

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

Матлаб, 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

Поиск строки и заменяет все до каждого совпадения на тарабарщину перед поиском следующего символа. Обработка ошибок (try-catch-end) может быть отброшена, тогда программа будет аварийно завершать работу (но s будет неопределенным при необходимости), если llama не найдена.

Реализация:

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

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

Я могу уменьшить его до 126 символов, если буду использовать «или» вместо «и», как в версии C выше. Однако это также соответствует строке ''!-!как 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

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

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

Новая версия, с огромной благодарностью @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 против Фортрана 154, работа сделана: P

ungolfed

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

Определяет функцию, которая принимает строку в качестве единственного аргумента (второй аргумент является дешевым var ) и возвращает либо пустой массив, либо массив из 5 элементов.

Сбрасывается до 108, если я беру входные данные для одной переменной char ( s) и оставляю выходные данные в другом ( b):

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

Изменить: поменять карту для цикла.

Реболь, 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. Возвращает пустой список[] если последовательность ламы не найдена (без учета регистра).

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

Не самый короткий код, но довольно искаженный, в стиле 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

Еще один пример регулярного выражения с использованием языка Юлии.

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