Nhiệm vụ

Nhiệm vụ rất đơn giản. Cho một mảng chỉ chứa các số nguyên và chuỗi , xuất ra số lớn nhất và số nhỏ nhất.

Các trường hợp thử nghiệm

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

Các số trong chuỗi không được coi là số nguyên:

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

Nếu chỉ có một số nguyên, nó là cả số nguyên lớn nhất và nhỏ nhất:

Input: [1]
Output: 1, 1

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

Quy tắc

• Bạn có thể giả sử rằng một mảng sẽ luôn chứa ít nhất một số nguyên.
• Tất cả các số nguyên đều dương (lớn hơn 0)
• Thứ tự của đầu ra không quan trọng.
• Đây là môn đánh gôn , vì vậy bài nộp có số byte ít nhất sẽ thắng!
• Chuỗi có thể chứa tất cả các ký tự ASCII có thể in ( 32 - 126) và không trống.

Nghiêm túc, 9 6 byte

,ì;M@m

Dùng thử trực tuyến

Làm thế nào nó hoạt động

,                              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

Chỉnh sửa 2 byte đã lưu thx @Neil

Lưu ý: x===+xđúng khi và chỉ khi xlà số

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

Bình thường, 14 11 10 byte

hM_BS^I#1Q

Hãy thử trực tuyến. Bộ thử nghiệm.

Giải trình

• Q: đánh giá đầu vào
• #: bộ lọc trên:
  • I: giá trị giống nhau sau:
    • ^…1 nâng nó lên sức mạnh 1
• S: sắp xếp nó
• _B: tạo mảng [previous, reversed(previous)]
• hM: lấy mục đầu tiên của mỗi mục đó

Phần khó nhất là chơi golf loại bỏ các chuỗi, hiện mất 4 byte. Cách tiếp cận hiện tại hoạt động do ^<str>1lấy sức mạnh Cartesian đầu tiên của chuỗi (về cơ bản, danh sách các ký tự của chuỗi), nhưng ^<int>1chỉ là hàm nhận dạng.

Python 2, 42 byte

Trong Python 2, các số nguyên luôn nhỏ hơn các chuỗi trong khi so sánh, vì vậy một đơn giản min(s)sẽ tìm thấy số nguyên nhỏ nhất. Khi tìm mức tối đa, chúng ta phải lọc ra chuỗi trước. Hàm ẩn danh chấp nhận một chuỗi và trả về một tuple với mức tối thiểu và tối đa.

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

Thí dụ:

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

Thạch, 8 byte

|f¹Ṣ0,1ị

Hãy thử trực tuyến!

Lý lịch

Trong một thế giới hoàn hảo, nó sẽ đủ để giao cắt danh sách với một phiên bản phẳng của chính nó. Chuỗi chỉ đơn giản là danh sách các ký tự trong Jelly, vì vậy trong khi danh sách ban đầu sẽ chứa các số nguyên và chuỗi, phiên bản dẹt sẽ chứa các số nguyên và ký tự, chỉ để lại các số nguyên trong giao điểm.

Trong thế giới thực, cả hai trình phân tích cú pháp của cả hai chuỗi ký tự đầu vào và chuỗi đều mang lại các ký tự thay vì các chuỗi có độ dài 1. Cách duy nhất để chuyển một chuỗi đơn thành một hàm sẽ là mã hóa "thủ công" như, ví dụ [”a], đó là một nhân vật được bọc trong một mảng.

Điều này sẽ tiết kiệm một byte, với tổng số 7 byte ( Hãy thử trực tuyến! ).

fFṢ0,1ị

Vì điều đó có thể không được chấp nhận, chúng tôi cũng cần một cách để phân biệt các ký tự với số nguyên.

Nguyên tử Bitwise Jelly của tuyệt vọng cố gắng để chuyển đổi đối số của họ để số nguyên. Họ bắt đầu bằng cách vector hóa cho đến khi họ gặp các loại độ sâu 0 (số hoặc ký tự), sau đó cố gắng chuyển đổi chúng thành số nguyên. Đối với một ký tự đại diện cho một số nguyên, điều này sẽ thành công. Đối với những người khác, một nguyên tử bitadic, đơn giản sẽ bỏ cuộc và trả về 0 .

Ví dụ: bitwise ORing danh sách [1, "2", "34", "-5", "a", "bc"]với chính nó sẽ mang lại

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

Bằng cách xen kẽ kết quả với danh sách ban đầu, chúng tôi loại bỏ các mảng và số nguyên không có trong danh sách ban đầu.

Làm thế nào nó hoạt động

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

Toán học, 20 byte

MinMax@*Select[#>0&]

Các trường hợp thử nghiệm

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

Ruby, 57 36 29 byte

Newbie ở đây, vì vậy tôi không biết nếu có bất kỳ nơi / cách tiêu chuẩn nào được chấp nhận để tính toán byte được sử dụng, bất kỳ trợ giúp nào đều được đánh giá cao!

Được chỉnh sửa theo nhận xét của Manatwork & Doorknob!

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

Kiểm tra

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 byte

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

Một khối không tên (hàm) dự kiến ​​mảng đầu vào trên ngăn xếp và để mảng đầu ra ở vị trí của nó.

Chạy tất cả các trường hợp thử nghiệm.

Giải trình

_     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 byte

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

Trong Haskell, tất cả các thành phần của danh sách phải cùng loại, vì vậy tôi không thể trộn Integervà String. Tuy nhiên, có Eitherloại kết hợp hai loại thành một loại duy nhất. Do đó, danh sách đầu vào là loại Either Integer String¹ . flọc các số nguyên, loại bỏ Eithertrình bao bọc, đặt danh sách làm thành phần đơn trong danh sách mới (ví dụ:[[1,2,3]] ), để <*>có thể áp dụng các hàm được đưa ra trong đối số đầu tiên cho nó.

Ví dụ sử dụng: f [Left 1, Left 3, Right "Hello", Left 2]-> [1,3].

Chỉnh sửa: @xnor đưa <*>vào chơi và lưu 2 byte. Cảm ơn!

¹ thực sự nó hoàn toàn đa hình trong loại thứ hai vì Stringtài sản không bao giờ được sử dụng.

jq, 21 ký tự

[.[]|numbers]|min,max

Chạy mẫu:

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

Bài kiểm tra trực tuyến:

• [7, 8, 10, "Xin chào", 5, 5]
• ["1", "2", "3", "4", 5]

Toán học, 28 byte

MinMax[#/._String->Nothing]&

PHP, 50 48 byte

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

Võng mạc , 71

Cảm ơn (như mọi khi) đến @ MartinBüttner vì sự giúp đỡ chơi gôn.

Không cạnh tranh golf, nhưng thật thú vị khi thực hiện sắp xếp bong bóng nguyên trong Retina.

Giả sử tất cả các chuỗi trong đầu vào được "trích dẫn kép và không chứa bất kỳ dấu ngoặc kép thoát nào \".

A`"
¶

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

(a)+
$#1

Đầu vào được phân tách dòng mới.

Hãy thử trực tuyến.

Toán học , 14

#&@@@MinMax@#&

Thí dụ:

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

Giải trình:

Khi MinMaxnhận được đầu vào không phải là số, nó sẽ giảm vấn đề hết mức có thể, sau đó để các thuật ngữ được bọc trong Minvà Max:

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

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

Do thứ tự tự động diễn ra các chuỗi theo số nguyên.

Applyở levelspec {1}, tốc ký @@@, sau đó được sử dụng để lấy đối số đầu tiên của các phần tử phi nguyên tử. Lưu ý rằng 5không bị ảnh hưởng ở đây:

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

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

Oracle SQL 11.2, 189 byte

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;

Không chơi gôn

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;

Truy vấn phụ phân tích mảng và phân tách nó để tạo ra một khung nhìn với một thành phần trên mỗi hàng. Sau đó, các phần tử không số được lọc ra.

Tôi ước tôi có thể tìm ra cách để làm điều đó với LỚN và TUYỆT VỜI nhất, nhưng không may mắn với cách xử lý mảng như một tham số.

vimscript, 25 byte

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

Đúng, đúng vậy, vimscript.

Mong đợi đầu vào trong mẫu

1
2
3
4
"5"

Và đầu ra dưới dạng

1
4

Giải trình:

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)

Dòng đầu tiên cần được nhân đôi hai lần để xử lý trường hợp cạnh của đầu vào của một số. Điều này là do lệnh cuối cùng sẽ khiếu nại nếu chỉ có hai dòng khi đạt được, vì cuối cùng nó 2,1dlà một phạm vi ngược.

Perl 44 39 + 3 = 41 byte

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

Đòi hỏi -pa cờ:

$ 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

Cảm ơn @manatwork đã cạo một vài byte

Julia, 35 byte

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

Đây là một hàm lambda chấp nhận một mảng và trả về một bộ số nguyên. Để gọi nó, gán nó cho một biến.

Julia có một hàm tích extremahợp để lấy các phần tử tối thiểu và tối đa của một mảng dưới dạng một tuple. Tuy nhiên, vì mảng cũng có thể có các chuỗi trong đó, trước tiên chúng ta phải lọc chúng ra. Chúng ta có thể làm điều đó bằng cách kiểm tra xem mỗi phần tử có phải là số nguyên hay không isa.

Japt, 23 byte

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

Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

[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 byte

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

Yêu cầu một danh sách tách dòng:

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

Nhờ @manatwork để tắt một vài byte

PowerShell, 53 36 byte

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

_{Đã lưu 17 byte nhờ @goric}

OOOF ... PowerShell thường chơi khá nhanh và lỏng lẻo khi đúc, điều này thường là một điều tốt cho việc chơi golf, nhưng làm tổn thương nó ở đây.

Đưa đầu vào của chúng ta $args[0]và đưa nó vào một Where-Objectcâu lệnh (the ?) sẽ chỉ chọn các số nguyên và chuyển chúng dọc theo đường ống, loại bỏ bất cứ thứ gì khác. Vì tính năng truyền lại động diễn ra nhanh chóng trong nền cho bạn (ví dụ: 1+"5"trả lại 6là PowerShell hoàn toàn hợp lệ), chúng tôi cần sử dụng -istoán tử để phân biệt giữa các loại dữ liệu.

Từ đó, chúng tôi đưa bộ sưu tập đó vào Sort-Object, sẽ sắp xếp các số nguyên từ nhỏ nhất đến lớn nhất. Bên ngoài ()là cần thiết để chúng ta có thể tham chiếu các phần tử đầu tiên và cuối cùng với [0,-1](nghĩa là nhỏ nhất và lớn nhất), nhưng lưu ý chúng ta cũng cần bên ngoài @để ép đầu ra sortthành một mảng nếu chỉ có một đối tượng (là kết quả của các ?, hoặc chỉ có một đối tượng là đầu vào).

MATL , 23 byte

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

Hãy thử trực tuyến!

"       % 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 byte

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

Sử dụng: a([1,2,3,'4'])

Chỉ cần cố gắng :)

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

Bình thường, 11 byte

hJSf!>TkQeJ

Giải trình:

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

Hãy thử nó ở đây!

Perl 6 , 25 byte

Câu trả lời rõ ràng sẽ là AnyCode lambda

*.grep(Int).minmax.bounds

Nếu nó phải là một chương trình đầy đủ

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

Đầu vào của chương trình đầy đủ này là một danh sách các giá trị được phân tách bằng dấu cách

Sử dụng

# 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 ký tự / 20 byte

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

Try it here (Firefox only).

Không tệ không tệ...

Giải trình

Điều này xuất ra một mảng chứa cả tối đa và tối thiểu. (ï⇔⒡≔=+$⸩,về cơ bản lọc ra tất cả các chuỗi trong đầu vào, МƲlấy tối đa trong đầu vào và МƵlấy tối thiểu.

Chỉ cần một lưu ý: đây là thử thách đầu tiên mà tôi có thể sử dụng ⇔, về cơ bản biến ï⇔thành ï=ï.

Python 3, 56 byte

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

Hãy thử trực tuyến trên Ideone .

APL (Dyalog) , 13 byte

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

Hãy thử trực tuyến!

∊ enlist (flatten - điều này làm cho tất cả các chuỗi thành các ký tự trong danh sách lớn)

⎕AV~⍨ xóa tất cả các ký tự trong A tomic V ector (bộ ký tự - để lại số)

(... ) áp dụng các chức năng ngầm như sau:

 ⌊/ tối thiểu trên

 , gắn vào

 ⌈/ câu châm ngôn trên

Java (OpenJDK 8) , 124 byte

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

Hãy thử trực tuyến!

Hàm lambda Java 8, lấy mảng làm đầu vào và đưa ra mảng {min, max} . Không cạnh tranh, bởi vì đầu vào phải là một mảng số nguyên.

Đã sửa lỗi và 1 byte nhờ Kevin Cruijssen

Jolf, 20 byte

Tôi có thể chơi golf này ... Tôi cần thực hiện các giải pháp kiểm tra kiểu ngắn hơn.

γ 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