Il tuo obiettivo è quello di prendere input come

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

e crea una matrice degli indici della stringa in cui compaiono le lettere che compongono la parola "Lama" (una di ciascuna in ordine). Ad esempio, lasciami mostrare le lettere puntate con i punti di inserimento per mostrare gli indici:

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

Quindi l'array sarebbe simile a:

[44, 67, 76, 105, 114]

(Se l'applicazione utilizza un'indicizzazione non basata su 0, i numeri appariranno diversi. Va bene.)

Se il testo non ha lama, l'array dovrebbe essere vuoto, nullo, nullo o indefinito.

È accettato qualsiasi linguaggio di codice. Questa è una gara di code-golf , quindi i personaggi meno vincenti!

CJam - 33

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

Ottiene gli indici basati su 1 (2 byte in più per base 0)

Spiegazione:

llegge una riga dall'input (sostituisci con qper l'intero input)
elconverte in minuscolo
"llama"{...}/esegue il blocco per ogni lettera "lama"
1$copia la stringa corrente
#trova l'indice degli
)_incrementi della lettera e duplicati
T+:Taggiunge T (inizialmente 0), aggiorna T e lo lascia sullo stack
\@scambia gli elementi intorno, ora abbiamo gli attuali-T, index, string
>slice la stringa che inizia dall'indice
;pops la stringa rimanente
]raccoglie gli indici in un array
A questo punto abbiamo tutti gli indici basati su 1; se non viene trovata alcuna lettera, l'array avrà duplicati.
___effettua altre 3 copie dell'array
|(con 2 copie dell'array) rimuove i duplicati
= confrontando, risultando in 0 se ci fossero duplicati o 1 in caso contrario
* moltiplica l'array 0 o 1 volte di conseguenza

Perl, 52 byte

La soluzione viene fornita come funzione che accetta la stringa come argomento e restituisce un elenco di posizioni.

• Posizioni a una base, ricerca con distinzione tra maiuscole e minuscole, senza righe: 52 byte

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

  La ricerca con distinzione tra maiuscole e minuscole restituisce un array vuoto nell'esempio della domanda, poiché dopo aver trovato le prime tre lettere la lettera minuscola mmanca nel testo di input.

• Supporto di newline: + 1 byte = 53 byte

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

  Il testo può ora comprendere più righe.

• Ricerca senza distinzione tra maiuscole e minuscole: + 1 byte = 54 byte

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

  Ora l'esempio nella domanda riporta un elenco di posizioni di indice, sono numeri a una base:

  [45 68 77 106 115]
  

• Posizioni a base zero: + 9 byte = 63 byte

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

  Risultato per l'esempio nella domanda:

  [44 67 76 105 114]
  

Ungolfed:

Quest'ultima variante include più o meno le altre varianti.

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

Sì, sed può trovare un lama. No, sed non può fare matematica. Questa è la risposta più lunga finora, con 299 + 1 caratteri, perché ho dovuto insegnare a sed a contare.

Questa risposta richiede un sed con espressioni regolari estese ( sed -Eo sed -r). Ho usato OpenBSD sed (1) . L'input è una stringa per riga. (Pertanto, la stringa potrebbe non contenere una nuova riga.) L'output è una riga di numeri o nulla.

Utilizzo (+1 carattere per -r):

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

Codice sorgente (299 caratteri):

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

Il programma sostituisce prima il lama con cinque %. (Tutti %in questo programma sono letterali.) Il primo comando s/%/z/gcambia qualsiasi %inz nella riga di immissione. I successivi cinque comandi trovano il lama, quindi tutte le braccia su tutte le spalle possono far male. diventa A %% armi su% ll spalle% ay% che. Poiché ognuno .*è avido, trovo sempre il lama sulla destra: il lama diventerà lama %%%%% . Se non riesco a ottenere cinque %, quindi /(.*%){5}/!delimina la riga di input e salta i comandi successivi.

s/[^%]/z/gcambia ogni personaggio ma %a z. Quindi entro in un ciclo. s/(z*)%/\10 z\1/cambia il primo %in 0, copia zero o più zda sinistra a destra e ne aggiunge uno in più za destra. Questo è quindi il numero di zsarà uguale all'indice. Ad esempio, zz%zzz%...diventa zz0 zzzzzzzz%...perché il primo %era all'indice 2 e il successivo %all'indice 8. s/z*$//rimuove il resto zdalla fine della stringa.

I successivi undici comandi contano zrimuovendoli ze contando da 0. Conta come zzz0, zz1, z2, 3. Inoltre, 1zzzz9diventa z1zzz0(più tardi 23) o zzzz9diventa 1zzz0(più tardi 13). Questo ciclo continua fino a quando non ci sono più %o z.

Fortran - 154 148

Fortran fa schifo al golf, ma solo per dimostrare che l'analisi delle stringhe può essere eseguita in un linguaggio matematico, l'ho fatto:

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

Ho salvato alcuni personaggi eliminando il non necessario falla fine endfunctione usato al if(any(r==0))posto di if(.not.all(r>0)).

Questo richiede:

1. s essere la stringa con il testo
2. aessere il test in minuscolo (cioè, llama)
3. bessere il test maiuscolo (cioè, LLAMA)

Il programma completo, senza golf è

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

Accetta stringa, genera array. Nulla se non lama nella stringa.

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

modificare : +9 caratteri in modo che non faccia distinzione tra maiuscole e minuscole.

Definisce una funzione (lambda, tecnicamente) f.

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

Ritorna nilse non c'è lama. Se deve essere [](matrice vuota), basta aggiungere ||[]prima dell'ultimo }per un totale di 4 caratteri extra .

Versione leggibile:

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

Compilare con:

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

Ho testato questo comando di compilazione con gcc di cygwin. Altri ambienti potrebbero gestire spazi e altri caratteri speciali in modo diverso.

Il risultato basato su 0 viene archiviato nell'array r. Il suo contenuto è indefinito se non c'è lama nella stringa.

• Case sensitive (53)

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

• Insensibile alle maiuscole / minuscole (58)

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

JavaScript (ECMAScript 6) - 68 caratteri

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

Presuppone che la stringa da testare sia nella variabile s. Se vuoi trasformarlo in una funzione, allora anteponif=s=> (per altri 5 caratteri).

Uscite:

[]

Insensibile alle maiuscole / minuscole: 69 caratteri

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

Uscite:

[68, 80, 93, 105, 114]

Insensibile al maiuscolo e primo incontro - 74 personaggi

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

Uscite:

[44, 67, 76, 105, 114]

Python, 100

Sono il peggior golfista di sempre. : P

Grazie a @xnor per la rasatura di 6 byte.

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 contiene l'array dopo.

EDIT : fisso.

EDIT 2 : len(g)a g, o==5a o>4secondo di @ XNOR suggerimenti.

EDIT 3 : @WolframH risolto.

Python 71

Presuppone l'ingresso s. Uscita in o.

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

Modifica: modificato dagli elenchi alle tuple per salvare 2 byte.

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

Campione:

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"

Esempio:

*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

Cerca la stringa e sostituisce tutto con una corrispondenza senza rimbalzi prima di cercare il carattere successivo. Lascerà sindefinito se non compare una parola.

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

Si noti che il numero di caratteri potrebbe essere ridotto se la sensibilità del case è consentita.

Versione precedente

 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

Cerca la stringa e sostituisce tutto con ogni incomprensione con incomprensibile prima di cercare il carattere successivo. La gestione degli errori (try-catch-end) potrebbe essere eliminata, quindi il programma si arresterebbe in modo anomalo (ma sarebbe indefinito come richiesto) se il lama non fosse trovato.

Implementazione:

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

Senza gestione degli errori:

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

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

Cerchiamo 'llama'a turno ogni personaggio , iniziando dopo la posizione del personaggio trovato in precedenza. Se non viene trovato alcun carattere, cdiventa il valore predefinito di -1, nel qual caso l'ultima riga girar in un elenco vuoto.

Modifica: scoperto che str.find(s,...)può essere invocato come s.find(...), salvando 4 caratteri.

OpenEuphoria, 147 128

Ho due esempi. Innanzitutto, il più breve:

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

Posso ottenere fino a 126 caratteri se uso "o" invece di "e" come fa la versione C sopra. Tuttavia, questo corrisponde anche alla stringa ''!-!come llama. Non comune, ma ancora possibile errore.

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 poi la versione usando espressioni regolari:

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

Entrambi prendono input da STDIN e inviano a STDOUT.

EDIT: esempio regex più breve:

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

Sto ancora facendo pratica con Powershell, mi aspetto che questo possa essere migliorato

$ s contiene la stringa, il risultato è nella matrice $ a

Versione originale

$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

Nuova versione, con enormi grazie a @goric

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

PHP

nessuna risposta PHP ancora? Penso che una lingua fortemente orientata alle stringhe possa battere almeno una matematica

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 contro fortran 154, lavoro svolto: 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[];
}

se il chiamante passa sempre una stringa minuscola, scende a 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:[]}

Definisce una funzione che accetta una stringa come unico argomento (il secondo argomento è economico var) e restituisce una matrice vuota o una matrice a 5 elementi.

Passa a 108 se prendo l'input su una singola variabile char ( s) e lascio l'output in un altro ( b):

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

Modifica: mappa scambiata per il ciclo 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]

Esempio di utilizzo nella console di 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 utilizza l'indicizzazione basata su 1. Restituisce un elenco vuoto[] se non viene trovata alcuna sequenza di lama (senza distinzione tra maiuscole e minuscole).

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

Non il codice più breve, ma piuttosto deformato, in un modo APL.

Spiegazione

'amall',⊂⍬⍞ Crea un array di 6 elementi: le lettere "amall" e un subarray di 2 elementi, essi stessi subarrays: l'array vuoto e una riga di caratteri letti dall'input.

{...}/... Ridurre (piegare a destra) l'array a 6 elementi utilizzando la funzione fornita.

a s←⍵ Decomponi l'argomento giusto nella matrice di indici e nella sottostringa rimanente (inizialmente la matrice vuota e la stringa completa).

~⍺∊s:⍬⍬ Se la sottostringa non contiene la lettera successiva, ⍺interrompere il calcolo e restituire l'array vuoto.

a,←n←s⍳⍺ Altrimenti, trova la sua posizione, chiamala n e aggiungila alla matrice di indici.

a(n↓s) Crea e restituisci una matrice di 2 elementi: la matrice estesa di indici e la sottostringa rimanente.

+\↑⊃... Disimballare l'output del pieghevole, prendere il primo elemento (la matrice di indici) e scansionarlo con l'aggiunta, per trasformare gli offset relativi in ​​assoluti.

Esempi

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

Un altro esempio di regex che usa il linguaggio Julia.

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