당신의 목표는 다음과 같은 입력을받는 것입니다

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이거나 정의되지 않아야합니다.

모든 코드 언어가 허용됩니다. 이것은 코드 골프 대회이므로 최소의 캐릭터가 승리합니다!

CJam-33

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

1 기반 인덱스를 얻습니다 (0 기반의 경우 2 바이트 더)

설명:

l입력에서 한 줄을 읽습니다 ( q전체 입력으로 대체 ). 각 "라마"문자에 대한 블록
el을 소문자로 변환 합니다. 현재 문자열 은 문자 증분 의 인덱스를 찾은 다음 T를 추가합니다 (처음 0). 스택에서 항목을 스왑 하면 현재 T, 인덱스, 문자열 슬라이스가 있습니다. 인덱스에서 시작하는 문자열이 튀어 나옵니다. 나머지 문자열 은 배열 에서 인덱스를 수집합니다 .이 시점에서 모든 1 기반 인덱스가 있습니다. 문자가 없으면 배열에 중복이 생깁니다. 배열의 사본 3 개를 더 만들고 (2 개의 배열 사본으로) 중복을 제거합니다.
"llama"{...}/
1$
#
)_
T+:T
\@
>
;
]

___
|
=중복 된 경우 0을, 그에
*따라 배열에 0 또는 1 배를 곱 하지 않으면 1을 비교합니다.

펄, 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..$#+]}

  이제이 질문의 예는 색인 위치 목록을보고하며 1부터 시작하는 숫자입니다.

  [45 68 77 106 115]
  

• 0부터 시작하는 위치 : + 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는 수학을 할 수 없습니다. 이것은 sed에게 세어 가르쳐야했기 때문에 299 + 1 문자로 지금까지 가장 긴 대답입니다.

이 답변에는 확장 정규 표현식 ( 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/gany %를 변경합니다 z. 다음 5 개의 명령은 라마를 찾아 모든 어깨의 모든 팔이 아플 수 있습니다. 가된다 % 게요 어깨 %의 바깥 % 체에 %% 팔을. 각각 .*은 탐욕 스럽기 때문에 항상 오른쪽에 라마 가 있습니다 . 라마 라마 는 라마 %%%%% 될 것 입니다. 5를 얻을 수 없으면 입력 줄 %을 /(.*%){5}/!d삭제하고 다음 명령을 건너 뜁니다.

s/[^%]/z/g모든 문자를로 변경 %합니다 z. 그런 다음 루프를 시작합니다. s/(z*)%/\10 z\1/첫 번째 %를로 변경하고 왼쪽에서 오른쪽으로 00 이상을 복사 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됩니다.

포트란 - 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마지막에 필요하지 않은 문자를 제거하여 몇 개의 문자를 저장했습니다.endfunctionif(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자를 입력 .

함수를 정의합니다 (기술적으로 람다) 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 || []
}

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]

파이썬, 100

나는 최악의 골퍼입니다. :피

6 바이트를 줄인 @xnor에게 감사합니다.

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가 수정했습니다.

파이썬 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]

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

문자열을 검색하고 다음 문자를 검색하기 전에 일치하는 모든 항목을 횡설수설로 바꿉니다. 라마를 찾지 못하면 오류 처리 (try-catch-end)가 중단되고 프로그램이 중단 될 수 있습니다 (필요에 따라 정의되지 않음).

이행:

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

언어 자바

 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자를 저장할 수 있음을 알았습니다 .

유포리아, 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 버전이 위와 같이 "and"대신 "or"를 사용하면 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[];}

포트란 154에 152, 작업 완료 : 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로 줄어 듭니다.

자바 스크립트, 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는 cheap var) 빈 배열 또는 5 요소 배열을 리턴합니다.

단일 char 변수 ( s) 에서 입력을 가져 와서 다른 출력 ( )에 그대로두면 108로 떨어집니다 b.

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',⊂⍬⍞ 문자 'amall'과 2 개의 요소로 구성된 하위 배열 인 6 개의 요소로 구성된 배열을 만듭니다. 하위 배열 : 빈 배열과 입력에서 읽은 문자 행.

{...}/... 제공된 기능을 사용하여 6 요소 배열을 줄입니다 (오른쪽으로 접기).

a s←⍵ 올바른 인수를 인덱스 배열과 나머지 부분 문자열 (처음에는 빈 배열과 전체 문자열)로 분해합니다.

~⍺∊s:⍬⍬ 부분 문자열에 다음 문자가 포함되지 않은 경우 ⍺ 계산을 중지하고 빈 배열을 반환하십시오.

a,←n←s⍳⍺ 그렇지 않으면 해당 위치를 찾아서 n으로 지정한 다음 인덱스 배열에 추가합니다.

a(n↓s) 확장 된 인덱스 배열과 나머지 부분 문자열 인 두 요소의 배열을 만들고 반환합니다.

+\↑⊃... 폴딩의 출력을 풀고 첫 번째 요소 (인덱스 배열)를 가져 와서 추가로 스캔하여 상대 오프셋을 절대 오프셋으로 바꿉니다.

예

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