Задание

Задача очень простая. Учитывая массив, содержащий только целые числа и строки , выведите наибольшее число и наименьшее число.

Тестовые случаи

Input: [1, 2, 3, 4, 5, 6, 7, 8]
Output: 1, 8

Input: [5, 4, 2, 9, 1, 10, 5]
Output: 1, 10

Input: [7, 8, 10, "Hello", 5, 5]
Output: 5, 10

Числа в строках не считаются целыми числами:

Input: [1, 2, 3, 4, "5"]
Output: 1, 4

Если есть только одно целое число, оно является как наибольшим, так и наименьшим целым числом:

Input: [1]
Output: 1, 1

Input: ["1", "2", "3", "4", 5]
Output: 5, 5

правила

• Вы можете предположить, что массив всегда будет содержать хотя бы одно целое число.
• Все целые числа положительны (больше 0)
• Порядок вывода не имеет значения.
• Это код-гольф , поэтому выигрывает представление с наименьшим количеством байтов!
• Строки могут содержать все печатаемые символы ASCII ( 32 - 126) и не являются пустыми.

Серьезно, 9 6 байтов

,ì;M@m

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

Как это работает

,                              Read list input
 ì                             Remove everything but numbers from it
  ;                            Make a copy
   m                           Extract its min value
    @M                         Extract the other one's max value
                               Implicit output (max then min)

JavaScript (ES6), 54 56

Редактирование 2 байт сохраненного ТНХ @Neil

Примечание: x===+xверно, если и только если xчисло

a=>[Math.max(...a=a.filter(x=>x===+x)),Math.min(...a)]

Pyth, 14 11 10 байт

hM_BS^I#1Q

Попробуйте онлайн. Тестирование.

объяснение

• Q: оцененный вклад
• #: filter что on:
  • I: значение остается неизменным после:
    • ^…1 поднимая его к власти 1
• SСортировать это
• _B: создать массив [previous, reversed(previous)]
• hM: возьмите первый предмет каждого предмета этого

Самая сложная часть состоит в удалении струн из гольфа, которое в настоящее время занимает 4 байта. Текущий подход работает благодаря ^<str>1получению первой декартовой степени последовательности (в основном, списка символов строки), но ^<int>1является просто функцией тождества.

Python 2, 42 байта

В Python 2 целые числа всегда меньше строк во время сравнений, поэтому простой min(s)найдет наименьшее целое число. Однако при поиске максимума мы должны сначала отфильтровать строки. Анонимная функция принимает последовательность и возвращает кортеж с минимумом и максимумом.

lambda s:(min(s),max(x for x in s if''>x))

Пример:

[1,'77', 6, '', 4] -> (1, 6)

Желе, 8 байт

|f¹Ṣ0,1ị

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

Задний план

В идеальном мире достаточно было бы пересечь список со сглаженной версией самого себя. Строки - это просто списки символов в Jelly, поэтому, хотя исходный список будет содержать целые числа и строки, уплощенная версия будет содержать целые числа и символы, оставляя в пересечении только целые числа.

В реальном мире, как парсеры обоего входных и строковых литералов дают символы вместо строк длины 1. Единственным способом передать одноплодную строку в функцию будет кодировать его «вручную» , как, например, [”a], что является символ, завернутый в массив.

Это позволит сэкономить байт, в общей сложности 7 байтов ( попробуйте онлайн! ).

fFṢ0,1ị

Поскольку это, вероятно, не приемлемо, нам также нужен способ отличать символы от целых чисел.

Побитовые атомы желе отчаянно пытаются преобразовать свои аргументы в целые числа. Они начинают с векторизации, пока не сталкиваются с типами глубины 0 (числа или символы), а затем пытаются преобразовать их в целые числа. Для символа, представляющего целое число, это будет успешно. Для других диадический побитовый атом просто сдастся и вернет 0 .

Например, побитовое ИЛИ со списком [1, "2", "34", "-5", "a", "bc"]само по себе даст

[1, 2, [3, 4], [0, 5], 0, [0, 0]]

Пересекая результат с исходным списком, мы избавляемся от массивов и целых чисел, которых не было в исходном списке.

Как это работает

|f¹Ṣ0,1ị  Main link. Input: A (list)

|         Bitwise OR the list A with itself.
 f¹       Filter the result by presence in A.
   Ṣ      Sort the resulting list of integers.
    0,1ị  Retrieve the elements at those indexes.
          Indices are 1-based and modular in Jelly, so 0 is the last (maximum),
          and 1 is the first (minimum).

Mathematica, 20 байтов

MinMax@*Select[#>0&]

Контрольные примеры

MinMax@*Select[#>0&]@{1,2,3,4,"5"}
(* {1,4} *)

Рубин, 57 36 29 байт

Новичок здесь, так что я не знаю, существует ли какое-либо стандартное или общепринятое место / способ вычисления используемых байтов, любая помощь будет очень признательна!

Отредактировано в соответствии с manatwork и комментариями Doorknob!

->n{(n.map(&:to_i)&n).minmax}

Тест

2.3.0 :076 > f=->n{[(n.map(&:to_i) & n).min, (n.map(&:to_i) & n).max]}
 => #<Proc:0x007ff7650ee868@(irb):76 (lambda)>
2.3.0 :077 > f[[7, 8, 10, "Hello", 5, 5]]
 => [5, 10]

CJam, 15 13 байт

{_:z&$2*_,(%}

Безымянный блок (функция), который ожидает входной массив в стеке и оставляет выходной массив на своем месте.

Запустите все тестовые случаи.

объяснение

_     e# Duplicate.
:z    e# Map over list: a) take abs() of integer elements (a no-op) or b) wrap strings
      e# in an array.
&     e# Set intersection: only the integers will appear in both arrays.
$     e# Sort.
2*    e# Repeat array twice (to make the code work with single-integer input).
_,    e# Duplicate, get length N.
(%    e# Decrement, get every (N-1)th element, i.e. the first and the last.

Haskell, 41 39 байт

f x=[minimum,maximum]<*>[[i|Left i<-x]]

В Haskell все элементы списка должны быть одного типа, поэтому я не могу смешивать Integerи String. Однако есть Eitherтип для объединения двух типов в один. Таким образом, список ввода имеет тип Either Integer String¹ . fфильтрует целые числа, удаляет Eitherоболочку, помещает список как отдельный элемент в новый список (например [[1,2,3]]), чтобы <*>можно было применить к нему функции, указанные в первом аргументе.

Пример использования: f [Left 1, Left 3, Right "Hello", Left 2]-> [1,3].

Редактировать: @xnor введен <*>в игру и сохранил 2 байта. Благодарность!

^{1 на} самом деле он полностью полиморфен во втором типе, поскольку Stringсвойство никогда не используется.

JQ, 21 символов

[.[]|numbers]|min,max

Образец прогона:

bash-4.3$ bin/jq '[.[]|numbers]|min,max' <<< '[7, 8, 10, "Hello", 5, 5]'
5
10

Он-лайн тест:

• [7, 8, 10, «Привет», 5, 5]
• ["1", "2", "3", "4", 5]

Mathematica, 28 байт

MinMax[#/._String->Nothing]&

PHP, 50 48 байт

<?=min($a=array_filter($a,is_int)).', '.max($a);

Сетчатка , 71

Спасибо (как всегда) @ MartinBüttner за помощь в игре в гольф.

Не конкурентный гольф, но интересно реализовать целочисленную сортировку пузырьков в Retina.

Предполагается, что все строки во входных данных заключены в "двойные кавычки и не содержат экранированных двойных кавычек \".

A`"
¶

\d+
$&$*a $&$*a
+`\b(a+) +\1(a+)\b
$1$2 $1
 +[a ]+ +

(a)+
$#1

Ввод разделен новой строкой.

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

Математика , 14

#&@@@MinMax@#&

Пример:

tests = {
   {1, 2, 3, 4, 5, 6, 7, 8},
   {5, 4, 2, 9, 1, 10, 5},
   {7, 8, 10, "Hello", 5, 5},
   {1, 2, 3, 4, "5"},
   {1},
   {"1", "2", "3", "4", 5}
 };

# & @@@ MinMax@# & /@ tests

{{1, 8}, {1, 10}, {5, 10}, {1, 4}, {1, 1}, {5, 5}}

Объяснение:

Когда MinMaxполучает не числовой ввод, это уменьшает проблему настолько, насколько это возможно, затем оставляет термины включенными Minи Max:

MinMax @ {7, 8, 10, "Hello", 5, 5}

{Min[5, "Hello"], Max[10, "Hello"]}

Из-за автоматического упорядочения строки следуют за целыми числами.

Applyзатем на уровне уровней {1} сокращенно @@@используется первый аргумент неатомарных элементов. Обратите внимание, что 5здесь нетронутым:

foo @@@ {5, Max[10, "Hello"]}

{5, foo[10, "Hello"]}

Oracle SQL 11.2, 189 байт

SELECT MIN(TO_NUMBER(i)),MAX(TO_NUMBER(i))FROM(SELECT REGEXP_SUBSTR(:1,'[^,]+',1,LEVEL)i FROM DUAL CONNECT BY LEVEL<REGEXP_COUNT(:1,',')+2)WHERE TRIM(TRANSLATE(i,' 0123456789',' '))IS NULL;

Un-golfed

SELECT MIN(TO_NUMBER(i)),MAX(TO_NUMBER(i)) 
FROM  (
        SELECT REGEXP_SUBSTR(:1,'[^,]+',1,LEVEL)i 
        FROM   DUAL 
        CONNECT BY LEVEL<REGEXP_COUNT(:1,',')+2
      )
WHERE TRIM(TRANSLATE(i,' 0123456789',' '))IS NULL;

Подзапрос анализирует массив и разделяет его, чтобы заполнить представление одним элементом на строку. Затем нечисловые элементы отфильтровываются.

Я хотел бы найти способ сделать это с LEAST и GREATEST, но не повезло с обработкой массива в качестве параметра.

vimscript, 25 байт

g/"/d
sort n
t.
t.
2,$-1d

Да, это верно, vimscript.

Ожидает ввода в виде

1
2
3
4
"5"

И выводы в виде

1
4

Объяснение:

g/"/d    delete all lines that contain quotes
sort n   sort numerically
t.       duplicate the first line
t.       duplicate it again
2,$-1d   delete from line 2 to line (END-1)

Первая строка должна дублироваться дважды, чтобы обработать крайний случай ввода одного числа. Это связано с тем, что последняя команда будет жаловаться, если при ее достижении будет только две строки, так как она в конечном итоге 2,1dокажется в обратном диапазоне.

Perl 44 39 + 3 = 41 байт

@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"

Требуются -paфлаги:

$ perl -pae'@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"' <<< '1 2 3 5 4'
1 5
$ perl -pae'@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"' <<< '1 2 3 4 "5"'
1 4

Спасибо @manatwork за сбривание нескольких байтов

Юлия, 35 байт

x->extrema(filter(i->isa(i,Int),x))

Это лямбда-функция, которая принимает массив и возвращает кортеж целых чисел. Чтобы вызвать его, назначьте его переменной.

У Джулии есть встроенная функция extremaдля получения минимального и максимального элементов массива в виде кортежа. Однако, поскольку в массиве также могут быть строки, мы сначала должны отфильтровать их. Мы можем сделать это, проверив, является ли каждый элемент целочисленным isa.

Japt, 23 байта

[V=Uf_bZÃn@X-Y})g Vw g]

Проверьте это онлайн!

Как это работает

[V=Uf_  bZÃ n@  X-Y})g Vw g]
[V=UfZ{ZbZ} nXY{X-Y})g Vw g]

UfZ{ZbZ}   // Filter out the items Z in U where Z.b(Z) is falsy.
           // For numbers, this the original number, which is always non-0 (non-falsy).
           // For strings, this returns Z.indexOf(Z), which is always 0 (falsy).
nXY{X-Y}   // Sort by subtraction. Small items move to the front, large to the back.
V=         // Set variable V to the resulting array.
)g Vw g    // Take the first item in V, and the first in V.reverse().
[       ]  // Wrap them in an array so both are sent to output.

Баш, 40 31 30 байт

sort -n|sed /\"/d|sed '1p;$p;d'

Требуется разделенный строкой список:

$ echo $'5\n4\n2\n9\n1\n"10"\n5' | sort -n|sed /\"/d|sed '1p;$p;d'
1
9

Благодаря @manatwork сбрить несколько байтов

PowerShell, 53 36 байт

@($args[0]|?{$_-is[int]}|sort)[0,-1]

_{Сохранено 17 байт благодаря @goric}

OOOF ... PowerShell обычно играет довольно быстро и свободно с кастингом, который, как правило, полезен для игры в гольф, но вредит ему.

Принимает наш ввод $args[0]и передает его в Where-Objectоператор ( ?), который будет выбирать только целые числа и передавать их по конвейеру, отбрасывая все остальное. Поскольку динамическое повторное приведение происходит для вас на лету в фоновом режиме (например, 1+"5"возвращение 6является совершенно корректным PowerShell), нам нужно использовать -isоператор для того, чтобы различать типы данных.

Оттуда мы передадим эту коллекцию Sort-Object, которая будет сортировать целые числа от наименьшего к наибольшему. Внешнее ()необходимо, чтобы мы могли ссылаться на первый и последний элементы с помощью [0,-1](т. Е. Наименьшего и наибольшего), но учтите, что нам также нужно, чтобы внешний @вызывал приведение вывода sortв виде массива, если существует только один объект (как результат ?, или только один объект был вход).

MATL , 23 байта

"@Y:tX%1)2\?x]N$htX<wX>

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

"       % implicitly input cell array. For loop that iterates on each cell
  @     %   push each cell
  Y:    %   cell's contents (either a number or a string)
  tX%   %   duplicate and push class. This will produce 'char'  or 'double'
  1)    %   get first letter: either 'c' or 'd'
  2\    %   is its ASCII code odd?
  ?     %   if so...
    x   %     delete (it's a string)
  ]     %   end if
  N$h   %   concatenate all stack into an array. This array will contain up to
        %   three numbers: minimum up to now, maximum up to now, new value (if any)
  tX<   %   duplicate. Push minimum
  wX>   %   swap. Push maximum.
        % implicitly end for
        % implicitly display stack contents

JavaScript (ES5), 105 байт

function a(b){m=Math;b=b.filter(function(c){return c===+c});alert(m.min.apply(m,b)+','+m.max.apply(m,b))}

Использование: a([1,2,3,'4'])

Просто пытаюсь :)

"Ungolfed":

function a(b){
  m=Math;
  b=b.filter(function(c){
    return c===+c
  });
  alert(m.min.apply(m,b) + ',' + m.max.apply(m,b))
}

Pyth, 11 байт

hJSf!>TkQeJ

Объяснение:

   f    Q   - filter([V for T in >], Q)
    !>Tk    - not(T>"")
  S         - sorted(^)
hJ       eJ - print first and last element

Попробуй это здесь!

Perl 6 , 25 байт

Очевидным ответом будет эта лямбда-код Wh WhisCode

*.grep(Int).minmax.bounds

Если это должна быть полная программа

put get.words».&val.grep(Int).minmax.bounds

Входные данные для этой полной программы представляют собой список значений, разделенных пробелами

использование

# give it a lexical name
my &code = *.grep(Int).minmax.bounds;

say code [1, 2, 3, 4, 5, 6, 7, 8];  # (1 8)
say code [5, 4, 2, 9, 1, 10, 5];    # (1 10)
say code [7, 8, 10, "Hello", 5, 5]; # (5 10)
say code [1, 2, 3, 4, "5"];         # (1 4)
say code [1];                       # (1 1)
say code ["1", "2", "3", "4", 5];   # (5 5)

say code []; # (Inf -Inf)

𝔼𝕊𝕄𝕚𝕟, 16 символов / 20 байтов

[МƲ(ï⇔⒡≔=+$⸩,МƵï

Try it here (Firefox only).

Не плохо, не плохо ...

объяснение

Это выводит массив, содержащий как максимум, так и минимум. (ï⇔⒡≔=+$⸩,в основном отфильтровывает все строки на входе, МƲполучает максимум на входе и МƵполучает минимум.

Просто примечание: это первая задача, которую я использую ⇔, которая в основном превращается ï⇔в ï=ï.

Python 3, 56 байт

lambda x:[m(t for t in x if str(t)!=t)for m in(min,max)]

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

APL (Dyalog) , 13 байт

(⌊/,⌈/)⎕AV~⍨∊

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

∊ enlist (flatten - все строки превращаются в символы в большом списке)

⎕AV~⍨ удалить все символы в Tomic V Ector (набор символов - листья числа)

(… ) Применить следующую молчаливую функцию:

 ⌊/ минимум по

 , добавлен в

 ⌈/ максимальный поперек

Java (OpenJDK 8) , 124 байта

a->{int s[]={0,0},t;for(Object i:a)try{t=(int)i;s[0]=s[0]<1|t<s[0]?t:s[0];s[1]=s[1]<t?t:s[1];}catch(Exception e){}return s;}

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

Java 8 лямбда-функция, принимает массив в качестве входных данных и выдает массив {min, max} . Не конкурирует, потому что входные данные должны быть целочисленным массивом.

Исправлено и -1 байт благодаря Кевину Круйссену

Джольф, 20 байт

Я, наверное, могу сыграть в гольф ... Мне нужно реализовать более короткие решения для проверки типов.

γ fxd='nF~tH0ͺZkγZKγ
 _fx                 filter the input
    d='nF~tH0        checking for number type
γ                    call that "γ"
             ͺ       pair
              ZkγZKγ  the min and max of the array