Увеличивается, уменьшается, нет или все?

9

Возьмите два ввода, непустой вектор / список, содержащий цифры 1и 2строку (нет, вы не можете взять 0/1вместо этого). Строка будет одной из следующих (в нижнем регистре, точно так, как написано ниже:

increasing
decreasing
ones
twos
all
none

Если строка ____, вы должны вернуть индексы ___:

  • increasing... где список меняется с 1на 2(все, 2что следует сразу после a 1)
  • decreasing... где список меняется с 2на 1(все, 1что следует сразу после a 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 
— Стьюи Гриффин
источник
@RobertoGraham да.
— Стьюи Гриффин
@KevinCruijssen Вы хороший догадчик :)
— Стьюи Гриффин
Пока что ни один из ответов не выводит список, как показано в примере. (т. е. соединяется с "," без конечного разделителя). Поскольку в тексте запроса не указано, насколько гибким может быть список, что обычно принимается за такие вызовы?
— Таг
Обычно это очень гибкий. Пока это список номеров, у вас все в порядке.
— Стьюи Гриффин

Ответы:

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за один раз. Редактировать: 1 байт сохранен благодаря @ edc65.

— Нил
источник
3

Python 2 , 136 131 119 108 97 байт

  • Сохранено пять байтов; используя lambdaфункцию.
  • Сохранено двенадцать байтов благодаря TFeld ; игра в гольф в двух условиях.
  • Спасен одиннадцать байтов благодаря мистеру 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]]

Попробуйте онлайн!

— Джонатан Фрех
источник
Поскольку вход всегда 1или 2, вы можете изменить (l[j]>1)*(l[~-j]<2)в (l[j]>l[~-j]) течение 119 байт
— TFeld
Кроме того, вы можете сохранить байт , переключившись на 0-индексированный
— TFeld
@TFeld Спасибо; хотя я думаю, что буду придерживаться 1-indexed.
— Джонатан Фрех
108 байт , используяenumerate()
— г-н Xcoder
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
— Луис Мендо
источник
1

Желе , 27 байт

>2\0;
NÇ
Ị
=2

ḟ
⁹Ḣ“hɠ»iµĿT

Попробуйте онлайн!

-3 спасибо Джонатану Аллану .

— Эрик Аутгольфер
источник
Сохраните три байта , используя словарное слово «диота» - обратите внимание, что ссылка 0 понимает это правильно, но вы можете изменить порядок еще раз и использовать «противоядие» или другое такое слово, и ваш тестовый жгут снова заработает.
— Джонатан Аллан
@JonathanAllan Я думал, что ссылка 0была самой нижней ссылкой, но, видимо, это Çнемного странно, спасибо! (также я только что выучил новое слово: p)
— Эрик Outgolfer
1

Шелуха , 27 байт

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

Попробуйте онлайн!

-9 спасибо H.PWiz .

Я очень горжусь этим ответом.

— Эрик Аутгольфер
источник
Гольф в основном с использованием ΘẊ>и ΘẊ<и`fN
— H.PWiz
@ H.PWiz, как я не видел их честно
— Эрик Outgolfer
-1 байт . Индексированный список 0является последним элементом.
— H.PWiz
@ H.PWiz Ооо Я думал, что ¨₆Żσa¨вместо этого будет сжатая строка , поэтому я не использовал эту функцию, спасибо. И теперь я могу сказать, что это связывает Желе .
— Эрик Outgolfer
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+",");}}

Попробуйте онлайн!

— Роберто Грэм
источник
Если вы определяете , yкак charвы можете испытанию гольф равенства нравится y.equals("a")в y=='a', y==97или даже y<98.
— Джонатан Фрех
@JonathanFrech просто менял это :)
— Роберто Грэхем
По крайней мере, 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+",");}}
— Невай,
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

Expanded:

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
источник
1

J, 73 байта

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

Было бы любопытно увидеть, как это может быть значительно сокращено - я верю, что это возможно (10 символов только для всех этих пунктов повестки дня!)

  • g- глагол-помощник для увеличения и уменьшения, что равносильно сравнению значений инфиксных \прогонов размера 2
  • Остальные просто берут первый символ из «команды» и выполняют соответствующий случай, используя Agenda. @.

Попробуйте онлайн!

— Ион
источник
Есть 1=]и 2=]не работает? Кроме того, что, если gвзять число в качестве левого аргумента и список в качестве правого аргумента и вернуть индексы, которые 2-/\ применяются к списку, равняются левому аргументу. Таким образом, вы можете пропустить это _1или 1найти уменьшение и увеличение вместо использования наречий.
— Коул
@cole Хорошие комментарии. Я внес изменения, и результат стал намного чище, хотя 73 все еще кажется большим количеством байтов. Я имею в виду, J связывает JS здесь ... позор!
— Иона
0

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

Этот строковый подход закончился дольше, чем я ожидал. Но даже подумав, что я остался в стороне от другого ответа на 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
— Кевин Круйссен
источник
0

Perl 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
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.