33

आपका उद्देश्य इनपुट की तरह है

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-आधारित नहीं है, तो अनुक्रमणिका का उपयोग करता है, संख्या भिन्न दिखाई देगी। यह ठीक है।)

यदि पाठ में कोई लामा नहीं है, तो सरणी खाली, शून्य, अशक्त या अपरिभाषित होनी चाहिए।

कोई भी कोड भाषा स्वीकार की जाती है। यह एक कोड-गोल्फ प्रतियोगिता है, इसलिए कम से कम अक्षर जीतते हैं!

code-golf

— Cilan
स्रोत

7

@ TheWobbuffet आप अपना उपयोगकर्ता नाम और चित्र बदलते रहते हैं। एक समय था जब आप "Doorknob" थे और उनकी तस्वीर थी। अब, आपकी तस्वीर एक भेड़ है। आपको इसे एक लामा में बदलना चाहिए।

— जस्टिन

1

0-आधारित बनाम 1-आधारित अनुक्रमण के बारे में क्या? क्या हम केवल अपनी भाषा द्वारा उपयोग की जाने वाली अनुक्रमणिका का उपयोग कर सकते हैं या क्या सभी प्रस्तुतियाँ एक सम्मेलन (जो एक) के अनुरूप होनी चाहिए?

— मार्टिन एंडर

1

@Quincunx भेड़ इस पर '42' कहती है!

— सीलन

2

@ TheWobbuffet तरीका बहुत सारे गणित को उन्मुख करता है: - / (मैटलैब, मैथेमेटिका, जूलिया, मैं आर के बारे में नहीं जानता) ... लुआ और स्मॉलटाक भी। कोड गोल्फिंग के लिए प्रासंगिक उन में से केवल एक ही गणितज्ञ होगा, लेकिन शायद स्ट्रिंग हेरफेर कार्यों के लिए नहीं।

— मार्टिन एंडर

3

क्या आप केवल उस फ़ंक्शन को चाहते हैं जो इसे या पूरे कार्यक्रम को करता है? क्या आप इनपुट / आउटपुट कोड भी चाहते हैं?

— jzm

11

CJam - 33

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

इसे 1-आधारित इंडेक्स मिलता है (0-आधारित के लिए 2 और बाइट्स)

स्पष्टीकरण:

lइनपुट से एक पंक्ति पढ़ता है ( qपूरे इनपुट के साथ प्रतिस्थापित करें )
elलोअरकेस में कनवर्ट
"llama"{...}/करता है प्रत्येक "लामा" पत्र के लिए ब्लॉक निष्पादित करता
1$है वर्तमान स्ट्रिंग
#को अक्षर
)_वृद्धि और डुप्लिकेट के सूचकांक का पता चलता है
T+:T टी (शुरुआत में 0) जोड़ता है, अपडेट टी और पत्तियों को छोड़ देता है स्टैक
\@स्वैप आइटम पर चारों ओर, अब हमारे पास वर्तमान-टी, सूचकांक, स्ट्रिंग
>स्लाइस हैं जो सूचकांक पर शुरू होने वाले स्ट्रिंग को
;पॉप करता है शेष स्ट्रिंग
]एक सरणी में अनुक्रमित इकट्ठा करता है
इस बिंदु पर हमारे पास सभी 1-आधारित इंडेक्स हैं; यदि कोई पत्र नहीं मिला, तो सरणी में डुप्लिकेट होंगे।
___सरणी की 3 और प्रतियां बनाता है
|(2 सरणी प्रतियों के साथ) डुप्लिकेट को निकालता है
=तुलना करता है, जिसके परिणामस्वरूप 0 होता है अगर डुप्लिकेट थे या 1 यदि नहीं
*तो सरणी को 0 या 1 के अनुसार गुणा करें

— aditsu
स्रोत

sourceforge.net/p/cjam/wiki/Home भाषा की अधिक जानकारी के लिए। मेरे लिए नया है।

— टंकशालाशाम

12

पर्ल, 52 बाइट्स

समाधान को फ़ंक्शन के रूप में प्रदान किया जाता है जो स्ट्रिंग को तर्क के रूप में लेता है और पदों की सूची देता है।

एक-आधारित स्थिति, केस-सेंसिटिव सर्च, बिना न्यूलाइन्स के: 52 बाइट्स
```
sub l{pop=~/(l).*?(l).*?(a).*?(m).*?(a)/;@+[1..$#+]}
```
केस-संवेदी खोज प्रश्न के उदाहरण में एक खाली सरणी देता है, क्योंकि पहले तीन अक्षरों के मिलान के बाद mइनपुट पाठ में लोअरकेस अक्षर गायब है।
Newlines का समर्थन: + 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";

— हेइको ओबर्डिएक
स्रोत

1

यह भी मानता है कि इनपुट ASCII है, या कम से कम पूर्ण यूनिकोड नहीं है। जब तक पर्ल की रेग्जेस इन दिनों में अंगूर की सीमाओं का सही ढंग से सम्मान नहीं करती (वे निश्चित रूप से वापस नहीं आईं जब मुझे इसका उपयोग करने का दुर्भाग्य था।)

— ट्रेजकज़

यहाँ (b) मल्टी-बाइट एन्कोडिंग्स को ध्यान में रखते हुए, प्रश्न में "इंडेक्स" शब्द को रेखांकित किया जाएगा। सूचकांक चरित्र की स्थिति या बाइट (भंडारण) की स्थिति से संबंधित हो सकता है। (c) किसी भी एन्कोडिंग का समर्थन वर्ण स्थितियों के साथ करने का अर्थ होगा, एन्कोडिंग ज्ञात होना चाहिए और अतिरिक्त तर्क के रूप में प्रदान करने की आवश्यकता है।

— हेइको ओबर्डिएक

आपका पहला दो समाधान प्रिंट []और तीसरा प्रिंट [ ]मेरे लिए (लंबे वाले सही ढंग से काम करते हैं)। मैं "perl, v5.8.8 msys-64int के लिए बनाया गया" चला रहा हूं। क्या आपके पास एक बग है, या यह पर्ल के एक अलग संस्करण पर काम करता है?

— टिम एस

@TimS .: []पहले समाधान के लिए सही है, Mकेस-संवेदी खोज में मेल नहीं खाता है। केस-सेंसिटिविटी को लेकर सवाल काफी अस्पष्ट है।

— हेइको ओबर्डिएक

ठीक है, तो []पहले दो के लिए स्वीकार्य है। लेकिन पहले तीन समाधान अभी भी मेरे लिए सही काम नहीं कर रहे हैं: यदि आप इसे इनपुट देते हैं जो अनुक्रमित करना चाहिए, तो यह वापस आ जाता है[ ]

— टिम एस

10

सेड, २ ९९ + १

हाँ, sed को एक लामा मिल सकता है। नहीं, sed गणित नहीं कर सकता। 299 + 1 वर्णों पर यह अब तक का सबसे लंबा उत्तर है, क्योंकि मुझे गिनती करने के लिए sed सिखाना था।

इस उत्तर को विस्तारित नियमित अभिव्यक्तियों ( sed -Eया sed -r) के साथ एक सेड की आवश्यकता होती है । मैंने ओपनबीएसडी सेड का इस्तेमाल किया (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 कंधे पर%% हथियार बन जाते हैं % a%% 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।

— kernigh
स्रोत

1

गिनती करने के लिए sed सिखाने के लिए +1। Sed की तुलना में गिनना सिखाने के लिए आसान है।

— आंद्रे

9

फोरट्रान - 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के अंत में आवश्यक नहीं को हटाकर मैंने कुछ पात्रों को बचायाendfunctionif(any(r==0)) इसके स्थान पर उपयोग किए जाने केif(.not.all(r>0)) ।

ये आवश्यक:

s पाठ के साथ स्ट्रिंग होना
a लोअर-केस टेस्ट (यानी, llama )
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

— काइल कानोस
स्रोत

आधुनिक फोरट्रान को कम से कम पिच और पुट क्षेत्रों पर अनुमति दी जाती है। फोरट्रान IV अभी भी पागल गोल्फ खेल रहा होगा।

— क्लिक करें

4

@ClickRick: फोरट्रान IV कुछ ऐसा है जो मैंने नहीं सीखा है। पक्का नहीं है कि मुझे चाहिए। ज़बरदस्ती इंडेंटेशन और कैपिटलाइज़ेशन के बारे में कुछ मुझे परेशान करता है।

— काइल कानोस

7

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

— jzm
स्रोत

1

+1 के लिएx=>x>=0

— क्लिक करें

मैं प्रभावित हु। इस एक के लिए मेरे किसी भी विचार से छोटा रास्ता। मैंने पाया कि आप इसे i-1 से छोटा करके और .ToArray () को .Select स्टेटमेंट पर डालकर छोटा कर सकते हैं , जैसेint[]a(string s){var i=-1;var o="llama".Select(x=>i=s.IndexOf(x,i+1)).ToArray();return o.All(x=>x>=0)?o:null;}

— Grax32

7

रूबी, 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 || []
}

— Doorknob
स्रोत

मैं कुछ समय बाद अपने प्रश्न को संपादित करने के लिए माफी माँगता हूँ, लेकिन मैंने सिर्फ इतना ही जोड़ा कि अगर कोई लामा, शून्य, शून्य, खाली या अपरिभाषित नहीं हो सकता है।

— सीलन

21

तो तुम एक llambda के साथ किया था?

— मेसन व्हीलर

@Doorknob दो डाउन बाइट के बजाय डाउनकेस का उपयोग करके छोटा होगा?

— dstarh

@dstarh हाँ, धन्यवाद

— दरवाज़े

लगता है कि आप केस-असंवेदनशीलता को एक बाइट के index(/#{c}/iबजाय सस्ता करके प्राप्त कर सकते हैं upcase।

— हिस्टोक्रेट

6

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

मैंने इस संकलित आदेश का साइबरविन जीसीसी के साथ परीक्षण किया। अन्य वातावरण रिक्त स्थान, और अन्य विशेष वर्णों को अलग तरीके से संभाल सकते हैं।

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

— Allbeert
स्रोत

4

जावास्क्रिप्ट (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]

— MT0
स्रोत

4

अजगर, १००

मैं अब तक का सबसे बुरा गोल्फर हूं। : पी

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 के सुझावों के अनुसार।

EDIT 3 : @WolframH ने इसे ठीक किया।

— cjfaure
स्रोत

2

o*=(len(o)==5)है उत्कृष्ट । यह भयानक है, लेकिन मैं इसे प्यार करता हूँ!

— केविन्सा

मुझे नहीं लगता कि उस लाइन पर बाहरी कोष्ठक आवश्यक हैं। आप उन्हें हटाकर दो वर्णों को बचा सकते हैं।

— user2357112

@ user2357112 उस दूसरी अंतिम पंक्ति पर? मैं उन्हें निकाल दूंगा।

— cjfaure

मुझे लगता sहै कि इनपुट स्ट्रिंग है, है ना? तो नहीं करना चाहिए s.lowerहो i.lower? हालाँकि, वह डो

— मोनिक

@WolframH आह, हाँ, कल ठीक करेंगे।

— cjfaure

3

अजगर on१

में इनपुट मानता है s। में आउटपुट o।

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

संपादित करें: 2 बाइट्स को बचाने के लिए सूचियों से ट्यूपल्स में बदला गया।

— मोनिका को बहाल करो
स्रोत

1

बुलियन द्वारा सूची गुणा करना मजेदार है, है ना? ; डी

— cjfaure

मुझे पसंद है कि आप कैसे oलेने के लिए nonempty शुरू करने की आवश्यकता की समस्या को चकमा देते हैं o[-1]। हो सकता है कि यह छोटा हो, लेकिन बाद में शुरू होता oहै [-1]और बाद में शुरू होता है o=o[1:]? -1यदि संभव हो तो , प्रारंभिक यात्राएं चेक-अप करती oहैं -1।

— xnor

@ xnor: मुझे नहीं लगता कि -Idea -1को काम करने के लिए बनाया जा सकता है। कम से कम, मैं सफल नहीं हुआ :-( हालांकि, मैंने 2 बाइट्स को बचाने के लिए सूचियों को ट्यूपल्स में बदल दिया है। :-)

— मोनिका

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

— काया
स्रोत

2

हास्केल, 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]

— danmcardle
स्रोत

2

मतलाब, 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

स्ट्रिंग खोजता है और अगले चरित्र की खोज करने से पहले जिबरिश के साथ प्रत्येक मैच तक सब कुछ बदल देता है। त्रुटि से निपटने (ट्राइ-कैच-एंड) को शायद गिराया जा सकता है, तो प्रोग्राम क्रैश हो जाएगा (लेकिन आवश्यकता के अनुसार अपरिभाषित होगा) यदि लामा नहीं मिला।

कार्यान्वयन:

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

— Jørgen
स्रोत

विचार की तरह, थोड़ा कम कर दिया है।

— डेनिस जहरुद्दीन

2

भाषा जावा

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

— सुदर्शन
स्रोत

2

पायथन (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 वर्णों को बचाने के रूप में लागू किया जा सकता है ।

— XNOR
स्रोत

2

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 पर पोस्ट करते हैं।

संपादित करें: छोटा रेगेक्स उदाहरण:

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

— टिन सैनिक
स्रोत

क्या regex को split/ joinया explode/ के साथ बनाकर कुछ सहेजना संभव है implode, या OpenEuphoria के पास लघु संस्करण नहीं हैं?

— पीटर टेलर

OpenEuphoria विभाजित कर सकते हैं / पात्रों के तार के साथ जुड़ सकते हैं, लेकिन मुझे इसे छोटे तरीके से करने का कोई तरीका नहीं दिखता है। मैं नियमित अभिव्यक्ति के साथ बहुत अच्छा नहीं हूँ; यहाँ इस्तेमाल किया गया रेगेक्स इस पृष्ठ पर अन्य उदाहरणों में से "प्रेरित" (बेशर्मी से चुराया हुआ) था।

— टिनसेलियर

2

शक्ति कोशिका - 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

नए संस्करण, बड़े पैमाने पर धन्यवाद @ के साथ

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

— ब्रायन
स्रोत

आप 112 तक की चीजों को छोटा करने के लिए बहुत सी जगह निकाल सकते हैं:$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-gt4

— 19

इसके अलावा, आप के foreach($i in $s.tochararray())साथ बदल सकते हैं [char[]]$s|%, जब तक आप बाद $iमें एक में बदल जाते हैं $_। यह घटकर 93 हो गया:$a=@();$w="llama";$n=$c=0;[char[]]$s|%{if($_-eq$w[$n]){$a+=$c;$n+=1}$c+=1};$a*=$a.length-gt4

— गोरख

$wचर को पूरी तरह से हटाकर 5 और चार्ट बचाएं , क्योंकि इसका केवल एक बार उपयोग किया गया है। बस इसे इनलाइन करें:if($i-eq"llama"[$n])

— गोरिक

..और, निश्चित रूप से, s+=1++

— goric

1

पीएचपी

कोई 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, काम किया: पी

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 तक कम हो जाता है

— Einacio
स्रोत

<?इसे मान्य बनाने के लिए आपको अपने कोड की शुरुआत में जोड़ना होगा। क्षमा करें ...

— avall

1

जावास्क्रिप्ट, 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 एक सस्ता है var) और एक खाली सरणी या 5-तत्व सरणी देता है।

अगर मैं एक चार चर पर इनपुट लेता हूं तो 108 पर गिरता है ( sऔर दूसरे में आउटपुट छोड़ता हूं b):

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

संपादित करें: लूप के लिए मैप को स्वैप किया।

— हारून डफ़ोर
स्रोत

ECMAScript 6 संस्करण (81 वर्ण) -b=(z=[].map.call("llama",a=>b=s.toLowerCase().indexOf(a,++b))).indexOf(-1)<0?z:[]

— MT0

1

प्रतिबल, ९,

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
]

— draegtun
स्रोत

1

एपीएल, ४ AP

+\↑⊃{a s←⍵⋄~⍺∊s:⍬⍬⋄a,←n←s⍳⍺⋄a(n↓s)}/'amall',⊂⍬⍞

सबसे छोटा कोड नहीं है, लेकिन एपीएल तरीके से, यह काफी विकृत है।

व्याख्या

'amall',⊂⍬⍞ 6 तत्वों की एक सरणी बनाएं: अक्षर 'अमल' और 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.

— Tobia
स्रोत

1

जूलिया, 76

जूलिया भाषा का उपयोग करते हुए एक और रेगेक्स उदाहरण।

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

— टिन सैनिक
स्रोत

एक वाक्य के भीतरी लामा बाहर लाओ

CJam - 33

पर्ल, 52 बाइट्स

सेड, २ ९९ + १

फोरट्रान - 154 148

C # - 119

रूबी, 56 65 63

सी - 53

जावास्क्रिप्ट (ECMAScript 6) - 68 वर्ण

अजगर, १००

अजगर on१

अजगर 100

हास्केल, 111

मतलाब, 61 96

पायथन (70)

OpenEuphoria, 147 128

शक्ति कोशिका - 121 85

पीएचपी

जावास्क्रिप्ट, 122 115

प्रतिबल, ९,

एपीएल, ४ AP

जूलिया, 76