बढ़ते हुए, घटते हुए, कोई नहीं या सभी?

Question

दो आदानों, एक गैर खाली वेक्टर / सूची अंक युक्त ले लो 1और 2और एक स्ट्रिंग (नहीं, तुम नहीं लग सकता है 0/1बजाय)। स्ट्रिंग निम्न में से एक होगी (निचले भाग में, जैसा कि नीचे लिखा गया है:

increasing
decreasing
ones
twos
all
none

यदि स्ट्रिंग ____ है तो आप सूचकांक लौटा देंगे ___:

• increasing... जहां से सूची में परिवर्तन होता 1है 2(प्रत्येक 2जो सीधे बाद में आता है 1)
• decreasing... जहां से सूची में परिवर्तन होता 2है 1(प्रत्येक 1जो सीधे बाद में आता है 2)
• ones ... जो सभी अंक हैं 1
• twos ... जो सभी अंक हैं 2
• all ... सभी अंक
• none... अंकों में से कोई भी नहीं। 0यदि सूची 1-अनुक्रमित है तो ठीक है। यदि सूची 0-अनुक्रमित है, तो एक ऋणात्मक संख्या ठीक है। आप एक खाली सूची या स्ट्रिंग का उत्पादन भी कर सकते हैं।

परीक्षण के मामलों:

ये 1-अनुक्रमित हैं। यदि आप 1-अनुक्रमित या 0-अनुक्रमित चाहते हैं, तो आप चुन सकते हैं। परीक्षण मामलों में अलग-अलग तारों के लिए एक ही वैक्टर का उपयोग किया जाता है।

--------------------------------
Vector:
1 1 2 2 2 1 2 2 1 1 2

String       - Output
increasing   - 3, 7, 11
decreasing   - 6, 9
ones         - 1, 2, 6, 9, 10 
twos         - 3, 4, 5, 7, 8, 11
all          - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
none         - 0 / []

------------------------------------
Vector:
1

String:
ones         - 1
all          - 1
decreasing / increasing / twos / none  - 0 / []

स्कोरिंग

जैसा कि यह है कोड गोल्फकम से कम बाइट के साथ जवाब जीतता है।

स्पष्टीकरण को प्रोत्साहित किया जाता है!

Comments

@ ररबेट्राहम हां।

— स्टीवी ग्रिफिन

@ केविनक्रूजसेन आप एक अच्छे अनुमानक हैं :)

— स्टीवी ग्रिफिन

अब तक कोई भी उत्तर उदाहरण के रूप में दर्शाई गई सूची का उत्पादन नहीं करता है। (यानी, "द्वारा शामिल किया गया," कोई अनुगामी परिसीमन के साथ)। जैसा कि चुनौती पाठ में यह नहीं बताया गया है कि सूची कितनी लचीली हो सकती है, इस तरह की चुनौतियों के लिए सामान्य रूप से क्या स्वीकार किया जाता है?

— तहग सिप

यह सामान्य रूप से बहुत लचीला है। जब तक यह संख्याओं की एक सूची है आप ठीक हैं।

— स्टीवी ग्रिफ़िन

Answer 1

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 74 73 बाइट्स

(a,[s],i=0,p)=>[for(e of a)if({i:e>p,d:e<p,o:e<2,t:e>1,a:1}[p=e,i++,s])i]

एरियर कॉम्प्रिहेंशन संयोजन का एक अच्छा तरीका है mapऔर filterएक ही बार में। संपादित करें: @ edc65 के लिए 1 बाइट का धन्यवाद सहेजा गया।

Answer 2

पायथन 2 , 136 131 119 108 97 बाइट्स

• पांच बाइट्स बचाए; एक lambdaसमारोह का उपयोग कर ।
• बफ़ेल के लिए धन्यवाद बारह बाइट्स बचाए ; गोल्फ की दो स्थितियाँ।
• श्री Xcoder के लिए ग्यारह ग्यारह बाइट्स सहेजे गए ; के enumerate()बजाय का उपयोग कर range(len())।
• एक शब्दकोश के बजाय एक सूची का उपयोग करके और 0-indexing ( TFeld के जवाब के रूप में ) और गोल्फिंग "adinot".find(m[0])करने के लिए ग्यारह बाइट्स सहेजे ord(m[0])/3-32।

lambda l,m:[j for j,k in enumerate(l)if[1,j*k<j*l[~-j],0,j*k>j*l[~-j],0,k<2,k>1][ord(m[0])/3-32]]

इसे ऑनलाइन आज़माएं!

Comments

इनपुट हमेशा होता है के बाद से 1या 2, आप बदल सकते हैं (l[j]>1)*(l[~-j]<2)करने के लिए (l[j]>l[~-j]) के लिए 119 बाइट्स

— TFeld

इसके अलावा, आप 0-अनुक्रमित

— TFeld

@TFeld धन्यवाद; हालांकि मुझे लगता है कि मैं 1-indexed के साथ रहना होगा ।

— जोनाथन फ्रेच

108 बाइट्स , का उपयोग करenumerate()

— श्री एक्सकोडर

Answer 3

पायथन 2 , 117 111 110 99 97 92 बाइट्स

lambda l,t:[i for i,v in enumerate(l)if[l[i+i/~i]<v,0,v<2,v>1,1,l[i+i/~i]>v][ord(t[0])/3%7]]

इसे ऑनलाइन आज़माएं!

0-indexed

जोनाथन की इंडेक्सिंग का उपयोग करने के लिए स्विच किया गया , और गोल्फ ord(m[0])/3-32कोord(t[0])/3%7

Comments

आप गोल्फ कर सकते हैं l[i]==2करने के लिए l[i]>1।

— जोनाथन फ्रैच

Answer 4

हास्केल , 112 83 81 बाइट्स

s%l=[i|(i,p,q)<-zip3[1..]l$l!!0:l,elem(s!!0,1<2)$zip"idota"[q<p,p<q,p<2,1<p,1<2]]

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: "increasing"%[1,1,2,1,2]। परिणाम 1-अनुक्रमित हैं।

आंशिक रूप से लिन के हास्केल जवाब से प्रेरित है ।

Answer 5

MATL , 32 31 30 29 बाइट्स

dQ~fQGqfOOGofGd1=fQGfO[]Xhjs)

आउटपुट 1-आधारित, या खाली है।

इसे ऑनलाइन आज़माएं!

व्याख्या

कोड सरणी इनपुट के लिए छह संभावित आउटपुट की गणना करता है, और फिर स्ट्रिंग इनपुट के आधार पर उपयुक्त आउटपुट का चयन करता है।

आउटपुट का चयन करने के लिए, स्ट्रिंग इनपुट के सभी वर्णों के ASCII कोड बिंदु जोड़े जाते हैं। परिणाम सापेक्ष 9 देता है 6, 1, 5, 2, 7, 0क्रमशः के लिए 'increasing', 'decreasing', 'ones', 'twos', 'all','none' । चूंकि सभी परिणामी संख्याएं भिन्न हैं, इसलिए इसे चयन मानदंड के रूप में उपयोग किया जा सकता है।

योग पर वास्तव में एक मोडुलो 9 ऑपरेशन करने के बजाय, संभावित इनपुट की सूची को 9 प्रविष्टियों तक बढ़ा दिया जाता है (जिनमें से कुछ डमी हैं), और इसलिए उस सूची में अनुक्रमण स्वचालित रूप से मोडुलो 9 किया जाता है।

d     % Implicit input: numeric vector. Push vector of consecutive differences.
      % Contains -1, 0 or 1
Q~    % For each entry: add 1, negate. This turns -1 into 1, other values into 0
f     % Push indices of nonzeros
Q     % Add 1 to each entry (compensates the fact that computing consecutive
      % differences removes one entry). This the output for 'decreasing'
Gq    % Push input again. Subtract 1 from the code points
f     % Push indices of nonzeros. This is the output for 'twos'
OO    % Push two zeros. These are used as placeholders
Go    % Push input and compute parity of each entry
f     % Push indices of nonzeros. This is the output for 'ones'
Gd    % Push input and compute consecutive differences
1=    % Test each entry for equality with 1
f     % Push indices of nonzeros 
Q     % Add 1. This is the output for 'increasing'
Gf    % Push indices for all input (nonzero) entries. This is the output for 'all'
O     % Push zeros. Used as placeholder
[]    % Push empty array. This is the output for 'none'
Xh    % Concatenate stack into a cell array
j     % Input a string
s     % Sum of code points
)     % Use as an index into the cell aray. Implicitly display

Answer 6

पायथन 2 , 92 बाइट्स

lambda a,s:[i for i,(x,y)in enumerate(zip([0]+a,a))if[0<x<y,0,y<2,y>1,1,x>y][ord(s[0])/3%7]]

इसे ऑनलाइन आज़माएं!

Answer 7

जेली , 27 बाइट्स

>2\0;
NÇ
Ị
=2

ḟ
⁹Ḣ“hɠ»iµĿT

इसे ऑनलाइन आज़माएं!

-3 जोनाथन एलन को धन्यवाद ।

Comments

शब्दकोश शब्द "डायोटा" का उपयोग करके तीन बाइट्स बचाएं - ध्यान दें कि लिंक 0 सही हो जाता है, लेकिन आप फिर से पुन: उपयोग कर सकते हैं और "एंटीडोट" या ऐसे अन्य शब्द का उपयोग कर सकते हैं और अपने परीक्षण को फिर से काम करने की अनुमति दे सकते हैं।

— जोनाथन एलन

@JonathanAllan मैंने सोचा 0था कि लिंक सबसे नीचे की कड़ी थी, लेकिन जाहिर है कि यह पसंद है Çलेकिन weirder, धन्यवाद! (यह भी मैंने बस एक नया शब्द सीखा: पी)

— एर्ग आउटगोल्फर सेफ़

Answer 8

भूसी , 27 बाइट्स

`fN!+mmëI=2ε¬moΘẊe><€¨Ÿȧö¨←

इसे ऑनलाइन आज़माएं!

-9 H.PWiz का धन्यवाद ।

मुझे इस जवाब पर काफी गर्व है।

Comments

Golfed का उपयोग करके ज्यादातर ΘẊ>और ΘẊ<और`fN

— H.PWiz

@ H.PWiz मैंने ईमानदारी से उन लोगों को कैसे नहीं देखा

— एरिक आउटगॉल्फ

-1 बाइट ए लिस्टेड इंडेक्स 0अंतिम तत्व है।

— H.PWiz

@ H.PWiz ऊह मैंने सोचा था कि संपीड़ित स्ट्रिंग ¨₆Żσa¨इसके बजाय होगा इसलिए मैंने उस सुविधा का उपयोग नहीं किया, धन्यवाद। और अब मैं कह सकता हूं कि यह जेली को बाँधता है ।

— आउटगॉल्फ

Answer 9

जावा (ओपनजेडके 8) , 266 217 213 205 172 171 155 131 बाइट्स

s->a->{int i=0,l=0,c=s.charAt(0)-97;for(int e:a){if(++i>1&(c==8&e>l|c==3&e<l)|c==14&(l=e)<2|c>18&l>1|c<1)System.out.print(i+",");}}

इसे ऑनलाइन आज़माएं!

Comments

आप निर्धारित करते हैं yएक के रूप में char, आप गोल्फ समानता परीक्षण की तरह कर सकते हैं y.equals("a")करने के लिए y=='a', y==97या यहाँ तक कि y<98।

— जोनाथन फ्रेच

@ जोनाथनफ्रेच सिर्फ इसे बदल रहा था :)

— रॉबर्टो ग्राहम

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

— ताहग

चूंकि 19यह है cकी सबसे अधिक मूल्य, c==19के बराबर है c>18।

— जोनाथन फ्रेच

131 बाइट्स:s->a->{int i=0,l=0,c=s.charAt(0)-97;for(int e:a){if(++i>1&(c==8&e>l|c==3&e<l)|c==14&(l=e)<2|c>18&l>1|c<1)System.out.print(i+",");}}

— नेवई सेप

Answer 10

Jq 1.5 , 131 बाइट्स

स्ट्रिंग मिलान के बाद से xcali के दृष्टिकोण के आधार पर मेरा सरणी संस्करण छोटा है।

def D(s):[.[1]|gsub(" ";"")|match(s;"g").offset+(s|length)];./"
"|{i:D("12"),d:D("21"),o:D("1"),t:D("12"),a:D("."),n:[]}[.[0][0:1]]

मान लेता है कि jq -Rsविकल्पों के साथ लगाया जाता है और इनपुट दो लाइनों जैसे पर दिखाई देता है

decreasing
1 1 2 2 2 1 2 2 1 1 2

विस्तारित:

def D(s): [
      .[1]                              # find where s appears
    | gsub(" ";"")                      # in the input and add
    | match(s;"g").offset + (s|length)  # length to get ending index
  ]
;

  ./"\n"                                # split on newline
| {i:D("12"),                           # increasing
   d:D("21"),                           # decreasing
   o:D("1"),                            # ones
   t:D("2"),                            # twos
   a:D("."),                            # all
   n:[]                                 # none
  }[.[0][0:1]]

इसे ऑनलाइन आज़माएं!

Answer 11

हास्केल , 91 बाइट्स

(c:_)!l=[i|(i,y,x)<-zip3[1..]l$l!!0:l,c/='i'||x<y,c>'d'||x>y,c/='o'||y<2,c<'t'||y>1,c/='n']

इसे ऑनलाइन आज़माएं!

लाईकोनी ने एक बाइट को बचाया।

Comments

आप के साथ एक बाइट बचा सकते हैं (i,y,x)<-zip3[1..]l$l!!0:l।

— लाकोनी

कुछ प्रतियोगिता

— लिकोनी

Answer 12

जे, 73 बाइट्स

g=.[:I.[=0,2-/\]
(_1 g])`(1 g])`(1=])`(2=])`(i.@#@])`_1:@.('idotan'i.{.@[)

यह देखने के लिए उत्सुक होंगे कि यह कैसे काफी संघनित हो सकता है - मेरा मानना ​​है कि यह (उन सभी एजेंडे परिनियनों के लिए 10 चार्ट) कर सकता है!

• g - वृद्धि और घटने के लिए सहायक क्रिया, जो कि सिर्फ इन्फिक्स के मूल्यों की तुलना करने के लिए राशि है \ आकार 2 रन के
• बाकी सिर्फ "कमांड" से पहला वर्ण पकड़ता है और एजेंडा का उपयोग करके संबंधित मामले को निष्पादित करता है @.

इसे ऑनलाइन आज़माएं!

Comments

काम करो 1=]और 2=]न करो ? इसके अलावा, क्या होगा अगर gइसके बाएं तर्क के रूप में एक संख्या और इसके सही तर्क के रूप में एक सूची है और सूची में 2-/\ लागू किए गए सूचकांकों को वापस छोड़ दिया है। इस तरह से आप इसे पारित कर सकते हैं _1या 1क्रिया विशेषण का उपयोग करने के बजाय घटते और बढ़ते हुए पा सकते हैं ।

— कोल

@ अच्छी टिप्पणी। मैंने बदलाव किए, और परिणाम बहुत साफ है, हालांकि 73 अभी भी एक उच्च बाइट गिनती की तरह लगता है। मेरा मतलब है, जे यहाँ जेएस बांध रहा है .... शर्म की बात है!

— योना

Answer 13

जावा 8, 233 229 216 बाइट्स

l->s->{int i=s.charAt(0)-97,k=0,j=1;for(s=(l+"").replaceAll("[^12]","");s.length()*j>0;System.out.print(j++<0?"":(k+=j)+","),s=s.substring(j))j=i<1?0:s.indexOf(i<4?"21":i<9?"12":i<14?" ":i<15?"1":"2")+(i>2&i<9?1:0);}

यह स्ट्रिंग दृष्टिकोण जितना मैं उम्मीद कर रहा था उससे अधिक समय तक समाप्त हो गया था .. लेकिन यहां तक ​​कि मुझे लगा कि मैं अन्य जावा 8 उत्तर से बेहद घबरा रहा हूं, मैंने इसे वैसे भी पोस्ट करने का फैसला किया।
यह निश्चित रूप से गोल्फ हो सकता है, यहां तक ​​कि इस दृष्टिकोण के साथ भी .. "कोई नहीं" और "वृद्धि / घटती" मुख्य रूप से कुछ वर्कअट की वजह से कुछ बाइट्स की लागत होती है।

परिणाम 1-अनुक्रमित है।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

l->s->{                          // Method with List and String parameters
  int i=s.charAt(0)-97,          //  First character of the String - 97
                                 //   (i=8; d=3; o=14; t=19; a=0; n=13)
      k=0,                       //  Total counter
      j=1;                       //  Index integer
  for(s=(l+"")                   //  toString of the List,
         .replaceAll("[^12]","");//   and leave only the 1s and 2s 
      s.length()*j>0             //  Loop as long as `j` and the size of the String
                                 //  are both larger than 0
      ;                          //   After every iteration:
      System.out.print(          //    Print:
       j++<0?                    //     If `j` is -1:
        ""                       //      Print nothing
       :                         //     Else:
        (k+=j)+",")              //      Print the current index
      ,s=s.substring(j))         //    And then remove the part of the String we've checked
    j=i<1?                       //   If "all":
                                 //    Change `j` to 0
      :                          //   Else:
       s.indexOf(                //    Replace `j` with the next index of:
        i<1?                     //     If "all":
         s.charAt(0)+""          //      The next character
        :i<4?                    //     Else-if "decreasing":
         "21"                    //      Literal "21"
        :i<9?                    //     Else-if "increasing":
         "12"                    //      Literal "12"
        :i<14?                   //     Else-if "none":
         " "                     //      Literal space (any char that isn't present)
        :i<15?                   //     Else-if "one":
         "1"                     //      Literal "1"
        :                        //     Else(-if "two"):
         "2")                    //      Literal "2"
       +(i>2&i<9?1:0);           //     +1 if it's "increasing"/"decreasing"
                                 //  End of loop (implicit / single-line body)
}                                // End of method

Answer 14

पर्ल 5 , 71 + 2 ( -nl) = 73 बाइट्स

$p=/l/?'.':/t/?2:/^o/?1:/d/?21:/i/?12:0;$_=<>;s/ //g;say pos while/$p/g

इसे ऑनलाइन आज़माएं!

संशोधित तर्क प्रभावी रूप से नीचे दिए गए स्पष्टीकरण के समान है, लेकिन पैटर्न मैचों को छोटा कर दिया गया है।

पहले:

$p=/all/?'.':/^o/?1:/^t/?2:/^d/?21:/^i/?12:0;$_=<>;s/ //g;say pos while/$p/g

इसे ऑनलाइन आज़माएं!

मापदंड से मिलान नहीं होने पर आउटपुट कुछ भी नहीं।

व्याख्या की:

$p=          # set the pattern to seach based on the input string
  /all/?'.'  # any character
 :/^o/?1     # starts with 'o', find ones
 :/^t/?2     # starts with 't', find twos
 :/^d/?21    # starts with 'd', find decreasing
 :/^i/?12    # starts with 'i', find increasing
 :0;         # anything else: create pattern that won't match
$_=<>;s/ //g;# read the digits and remove spaces
say pos while/$p/g # output position(s) of all matches