Ваша мета - взяти подібний внесок

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"{...}/виконує блок для кожного букви «лама»,
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]
  

Безголівки:

Останній варіант включає більш-менш інші варіанти.

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 може знайти ламу. Ні, сед не може займатися математикою. Це найдовша відповідь поки що: 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рядок введення. Наступні п’ять команд знаходять ламу, тому всі болі на всіх плечах можуть боліти. стає A %% зброєю на% 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.\"

Я перевірив цю команду компіляції за допомогою gcc 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

Я найгірший гольфіст коли-небудь. : 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 містить масив після.

EDIT : Виправлено.

EDIT 2 : len(g)to g, o==5too>4 відповідно з @ XNOR - х пропозицій.

EDIT 3 : @WolframH виправив це.

Пітон 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 байти.

Пітон 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]

Матлаб, 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 буде визначено, як потрібно), якщо лама не буде знайдена.

Впровадження:

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

Я можу скоротити його до 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.

EDIT: Коротший приклад регулярного вираження:

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

Безумовно

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

Визначає функцію, яка приймає рядок як єдиний аргумент (другий аргумент - дешевий 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. Повертає порожній список[] якщо послідовності лами не знайдено (регістр нечутливий).

Безголівки:

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)