작업

작업은 매우 간단합니다. 정수 와 문자열 만 포함하는 배열이 주어지면 가장 큰 수와 가장 작은 수를 출력하십시오.

테스트 사례

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보다 큼)
• 출력 순서는 중요하지 않습니다.
• 이것은 code-golf 이므로 바이트 수가 가장 적은 제출이 승리합니다!
• 문자열은 인쇄 가능한 모든 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)

자바 스크립트 (ES6), 54 56

thx @Neil으로 저장된 2 바이트 편집

참고 : 숫자 인 x===+x경우에만 해당 x됩니다.

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아이디 함수일뿐입니다.

파이썬 2, 42 바이트

Python 2에서 정수는 비교하는 동안 항상 문자열보다 작으므로 간단한 min(s)것은 가장 작은 정수를 찾습니다. 그러나 최대 값을 찾을 때는 먼저 문자열을 필터링해야합니다. anonymous 함수는 시퀀스를 받아들이고 최소값과 최대 값을 가진 튜플을 반환합니다.

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"]자체를 비트 단위로 OR하면

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

하스켈, 41 39 바이트

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

Haskell에서 목록의 모든 요소는 동일한 유형이어야하므로 Integerand을 혼합 할 수 없습니다 String. 그러나 Either두 가지 유형을 단일 유형으로 결합 하는 유형이 있습니다. 따라서 입력 목록은 Either Integer String¹ 유형 입니다. f상기 정수를 필터링하는 제거 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, "Hello", 5, 5]
• [ "1", "2", "3", "4", 5]

수학, 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))

이것은 배열을 받아들이고 정수의 튜플을 반환하는 람다 함수입니다. 호출하려면 변수에 지정하십시오.

Julia에는 extrema배열의 최소 및 최대 요소를 튜플로 가져 오는 내장 함수 가 있습니다. 그러나 배열에도 문자열이있을 수 있으므로 먼저 필터링해야합니다. 를 사용하여 각 요소가 정수인지 테스트하여 그렇게 할 수 있습니다 isa.

apt, 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

Thanks to @manatwork to shave off a few bytes

PowerShell, 53 36 bytes

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

_{Saved 17 bytes thanks to @goric}

OOOF ... PowerShell usually plays pretty fast and loose with casting, which is normally a good thing for golfing, but hurts it here.

Takes our input $args[0] and pipes it into a Where-Object statement (the ?) that will only select integers and passes them along the pipeline, discarding anything else. Since dynamic re-casting happens on-the-fly in the background for you (e.g., 1+"5" returning 6 is perfectly valid PowerShell), we need to use the -is operator in order to differentiate between the data types.

From there, we pipe that collection into Sort-Object, which will sort the integers from smallest to largest. The outer () is necessary so we can reference the first and last elements with [0,-1] (i.e., the smallest and the largest), but note we also need the outer @ to force casting the output of sort as an array if there's only one object (as the result of the ?, or only one object was input).

MATL, 23 bytes

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

Try it online!

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

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

Usage: a([1,2,3,'4'])

Just trying :)

"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 bytes

hJSf!>TkQeJ

Explanation:

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

Try it here!

Perl 6, 25 bytes

The obvious answer would be this WhateverCode lambda

*.grep(Int).minmax.bounds

If it has to be a full program

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

The input to this full program is a space separated list of values

Usage

# 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 chars / 20 bytes

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

Try it here (Firefox only).

Not bad, not bad...

Explanation

This outputs an array containing both the maximum and minimum. (ï⇔⒡≔=+$⸩, basically filters out all strings in the input, МƲ gets the maximum in the input, and МƵ gets the minimum.

Just a note: this is the first challenge where I get to use ⇔, which basically turns ï⇔ into ï=ï.

Python 3, 56 bytes

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

Try it online on Ideone.

APL (Dyalog), 13 bytes

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

Try it online!

∊ enlist (flatten – this makes all the strings into characters in the big list)

⎕AV~⍨ remove all characters in the Atomic Vector (the character set – leaves numbers)

(…) apply the following tacit function:

 ⌊/ the minimum across

 , appended to

 ⌈/ the maximus across

Java (OpenJDK 8), 124 bytes

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

Try it online!

Java 8 lambda function, takes array as input and gives out array {min, max}. Non competing, because the input has to be an integer array.

Fixed and -1 byte thanks to Kevin Cruijssen

Jolf, 20 bytes

I can probably golf this... I need to implement type-checking shorter solutions.

γ 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