任务

任务很简单。给定仅包含整数和字符串的数组，则输出最大数和最小数。

测试用例

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个字节thx @Neil

注意：x===+x当且仅当x是数字时为true

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

Pyth，14 11 10字节

hM_BS^I#1Q

在线尝试。 测试套件。

说明

• Q：评估输入
• #：对以下内容进行过滤：
  • 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} *)

Ruby，57 36 29字节

这里是新手，所以我不知道是否有任何标准或普遍接受的位置/方式来计算使用的字节，将不胜感激！

根据操作和门把手的评论进行编辑！

->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过滤Integer，移除Either包装器，将列表作为单个元素放入新列表（例如[[1,2,3]]），以便<*>可以将第一个参数中给出的功能应用于该列表。

用法示例：f [Left 1, Left 3, Right "Hello", Left 2]-> [1,3]。

编辑：@xnor <*>发挥作用并保存了2个字节。谢谢！

¹实际上，它在第二种类型中是完全多态的，因为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然后在levelspec {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;

未打高尔夫球

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

这是一个lambda函数，它接受一个数组并返回一个整数元组。要调用它，请将其分配给变量。

Julia具有一个内置函数，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.

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

_{@goric节省了17个字节}

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

尝试一下 ：）

“无高尔夫球”：

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个字节

显而易见的答案是这个WhateverCode lambda

*.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~⍨∊

在线尝试！

∊ 登记（展平–这会使所有字符串变成大列表中的字符）

⎕AV~⍨ 删除的所有字符一个托米奇V埃克特（字符集-叶数）

(… ) 应用以下默认功能：

 ⌊/ 最小跨度

 , 附加到

 ⌈/ 跨越的最大值

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 lambda函数，将array作为输入并给出array {min, max}。非竞争性，因为输入必须是整数数组。

固定和-1字节感谢凯文·克鲁伊森

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