是增加，减少，还是没有？

9

就拿两个输入，包含数字的非空矢量/列表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 / []

计分

因为这是 代码高尔夫球，则以字节数最少的答案为准。

鼓励解释！

code-golf  number  parsing 
— 斯蒂夫·格里芬
source
@RobertoGraham是的。
— Stewie Griffin
@KevinCruijssen您是一个不错的猜测者：）
— Stewie Griffin
到目前为止，所有答案似乎都没有输出示例中所示的列表。（即，以“，”连接，没有结尾的分隔符）。由于质询文本没有说明列表的灵活性，因此这种质询通常接受什么？
— 塔赫格
通常非常灵活。只要是数字列表，就可以了。
— Stewie Griffin

Answers:

7

JavaScript（Firefox 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个字节。

— 尼尔
source
3

Python 2中，136个 131 119 108 97字节

  • 保存了五个字节；使用lambda功能。
  • TFeld节省了十二个字节；打高尔夫球两个条件。
  • 多亏了Xcoder先生，节省了11个字节；使用enumerate()代替range(len())。
  • 通过使用列表而不是字典并使用0-indexing 来保存11个字节（如 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]]

在线尝试！

— 乔纳森·弗雷奇
source
由于输入总是1或者2，您可以更改(l[j]>1)*(l[~-j]<2)到(l[j]>l[~-j]) 的119个字节
— TFeld
另外，您可以通过切换到0索引来保存字节
— -TFeld
@TFeld谢谢；尽管我认为我会坚持使用1-indexed。
— 乔纳森·弗雷希
108字节，使用enumerate()
— Xcoder先生，2017年
2

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
— 路易斯·门多
source
1

外壳，27个字节

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

在线尝试！

-9感谢H.PWiz。

我为这个答案感到骄傲。

— 暴民埃里克
source
Golfed大多采用ΘẊ>与ΘẊ<和`fN
— H.PWiz
@ H.PWiz我怎么没老实地看到这些
— Erik the Outgolfer
-1字节索引0为的列表是最后一个元素。
— H.PWiz
@ H.PWiz噢，我想压缩字符串会¨₆Żσa¨代替，这就是为什么我不使用该功能的原因，谢谢。现在我可以说与Jelly息息相关。
— 暴民埃里克（Erik the Outgolfer）'17
1

的Java（OpenJDK的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+",");}}

在线尝试！

— 罗伯托·格雷厄姆
source
如果定义y为char，你可以打高尔夫球平等测试，如y.equals("a")到y=='a'，y==97甚至y<98。
— 乔纳森·弗雷希
@JonathanFrech只是在更改它：)
— Roberto Graham
TIO至少不是我期望的输出。尽管仅以示例形式给出，但列表在元素之间需要有空格，并且没有尾部逗号。
— 塔赫格
由于19是c的最高值，c==19所以等于c>18。
— 乔纳森·弗雷希
2
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+",");}}
— Nevay
1

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

在线尝试！

— jq170727
source
1

J，73个字节

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

奇怪的是，如何将其精简一下-我相信可以做到这一点（仅10个字符可用于所有议程项目！）

  • g-用于增加和减少的辅助动词，仅相当于比较\大小为2的中缀游程的值
  • 其余的仅从“命令”中获取第一个字符，并使用议程执行相应的大小写 @.

在线尝试！

— 约拿
source
不要1=]和2=]不工作？同样，如果g将数字作为左参数，将列表作为右参数，并返回2-/\ 应用于列表的索引等于左参数，该怎么办。这样，您可以通过它_1或1找到减少和增加的方式，而不必使用副词。
— 科尔
@cole好评论。我进行了更改，结果更加简洁，尽管73仍然看起来像一个高字节数。我的意思是，J在这里绑了JS。
— 乔纳
0

爪哇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);}

这种String方法结束的时间比我预期的要长。。但是，即使认为我对Java 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
— 凯文·克鲁伊森
source
0

Perl 5 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
— Xcali
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.