La tarea

La tarea es muy simple. Dada una matriz que contiene solo enteros y cadenas , genera el número más grande y el número más pequeño.

Casos de prueba

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

Los números en cadenas no se consideran enteros:

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

Si solo hay un entero, es el entero más grande y el más pequeño:

Input: [1]
Output: 1, 1

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

Reglas

• Puede suponer que una matriz siempre contendrá al menos un número entero.
• Todos los enteros son positivos (mayor que 0)
• El orden de la salida no importa.
• Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.
• Las cadenas pueden contener todos los caracteres ASCII imprimibles ( 32 - 126) y no están vacías.

En serio, 9 6 bytes

,ì;M@m

Pruébalo en línea

Cómo funciona

,                              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

Editar 2 bytes guardados gracias a @Neil

Nota: x===+xes verdadero si y solo si xes un número

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

Pyth, 14 11 10 bytes

hM_BS^I#1Q

Pruébalo en línea. Banco de pruebas.

Explicación

• Q: entrada evaluada
• #: filtra eso en:
  • I: el valor es el mismo después de:
    • ^…1 elevándolo al poder 1
• S: ordenar eso
• _B: crear matriz [previous, reversed(previous)]
• hM: toma el primer elemento de cada elemento de ese

La parte más difícil es jugar al golf la eliminación de cadenas, que actualmente ocupa 4 bytes. El enfoque actual funciona debido a ^<str>1tomar el primer poder cartesiano de la secuencia (básicamente, la lista de los caracteres de la cadena), pero ^<int>1es solo la función de identidad.

Python 2, 42 bytes

En Python 2, los enteros son siempre menores que las cadenas durante las comparaciones, por lo que un simple min(s)encontrará el entero más pequeño. Sin embargo, al encontrar el máximo, primero debemos filtrar las cadenas. La función anónima acepta una secuencia y devuelve una tupla con el mínimo y el máximo.

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

Ejemplo:

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

Jalea, 8 bytes

|f¹Ṣ0,1ị

Pruébalo en línea!

Fondo

En un mundo perfecto, sería suficiente intersectar la lista con una versión aplanada de sí misma. Las cadenas son simplemente listas de caracteres en Jelly, por lo tanto, si bien la lista original contendría enteros y cadenas, la versión aplanada contendría enteros y caracteres, dejando solo los enteros en la intersección.

En el mundo real, los analizadores sintácticos de los literales de entrada y de cadena producen caracteres en lugar de cadenas de longitud 1. La única forma de pasar una cadena singleton a una función sería codificarla "manualmente" como, por ejemplo [”a], que es un personaje envuelto en una matriz.

Esto ahorraría un byte, para un total de 7 bytes (¡ Pruébelo en línea! ).

fFṢ0,1ị

Como probablemente eso no sea aceptable, también necesitamos una forma de diferenciar los caracteres de los enteros.

Los átomos bit a bit de Jelly intentan desesperadamente convertir sus argumentos en enteros. Comienzan vectorizando hasta que encuentran tipos de profundidad 0 (números o caracteres), luego intentan convertirlos en enteros. Para un personaje que representa un número entero, esto tendrá éxito. Para otros, un átomo diádico, bit a bit simplemente se rendirá y devolverá 0 .

Por ejemplo, OR bit a bit de la lista [1, "2", "34", "-5", "a", "bc"] consigo mismo dará

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

Al intersecar el resultado con la lista original, nos deshacemos de las matrices y los enteros que no estaban presentes en la lista original.

Cómo funciona

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

MinMax@*Select[#>0&]

Casos de prueba

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

Ruby, 57 36 29 bytes

Novato aquí, así que no sé si hay algún lugar / forma estándar o universalmente aceptado para calcular los bytes utilizados, ¡cualquier ayuda sería muy apreciada!

Editado según manatwork y el comentario de Doorknob!

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

Prueba

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 bytes

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

Un bloque (función) sin nombre que espera la matriz de entrada en la pila y deja la matriz de salida en su lugar.

Ejecute todos los casos de prueba.

Explicación

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

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

En Haskell, todos los elementos de una lista deben ser del mismo tipo, por lo que no puedo mezclar Integery String. Sin embargo, existe el Eithertipo para combinar dos tipos en uno solo. La lista de entrada es, por lo tanto, de tipo Either Integer String¹ . ffiltra los enteros, elimina el Eithercontenedor, coloca la lista como el elemento único en una nueva lista (por ejemplo [[1,2,3]]), para que <*>pueda aplicarle las funciones dadas en el primer argumento.

Ejemplo de uso: f [Left 1, Left 3, Right "Hello", Left 2]-> [1,3].

Editar: @xnor puso <*>en juego y guardó 2 bytes. ¡Gracias!

^{1 en} realidad es completamente polimórfico en el segundo tipo ya que la Stringpropiedad nunca se usa.

jq, 21 caracteres

[.[]|numbers]|min,max

Ejecución de muestra:

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

Prueba en línea:

• [7, 8, 10, "Hola", 5, 5]
• ["1", "2", "3", "4", 5]

Mathematica, 28 bytes

MinMax[#/._String->Nothing]&

PHP, 50 48 bytes

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

Retina , 71

Gracias (como siempre) a @ MartinBüttner por la ayuda en el golf.

No es competitivo en cuanto al golf, pero es interesante implementar la clasificación de burbujas enteras en Retina.

Asume que todas las cadenas en la entrada tienen "comillas dobles y no contienen comillas dobles escapadas \".

A`"
¶

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

(a)+
$#1

La entrada está separada por nueva línea.

Pruébalo en línea.

Mathematica , 14

#&@@@MinMax@#&

Ejemplo:

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

Explicación:

Cuando MinMaxobtiene una entrada no numérica, reduce el problema tanto como puede, luego deja los términos envueltos Miny Max:

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

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

Debido al ordenamiento automático que tiene lugar, las cadenas siguen enteros.

Applyen levelpec {1}, abreviatura @@@, se usa para extraer el primer argumento de elementos no atómicos. Tenga en cuenta que 5no se ha tocado aquí:

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

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

Oracle SQL 11.2, 189 bytes

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;

Sin golf

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;

La subconsulta analiza la matriz y la divide para completar una vista con un elemento por fila. Luego, los elementos no numéricos se filtran.

Desearía haber encontrado una manera de hacerlo con MENOS y MAYOR, pero no tuve suerte con cómo manejar la matriz como parámetro.

vimscript, 25 bytes

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

Sí, así es, vimscript.

Espera entrada en el formulario

1
2
3
4
"5"

Y salidas en forma

1
4

Explicación:

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)

La primera línea debe duplicarse dos veces para manejar el caso límite de una entrada de un solo número. Esto se debe a que el último comando se quejará si solo hay dos líneas cuando se alcanza, ya que termina siendo 2,1dun rango hacia atrás.

Perl 44 39 + 3 = 41 bytes

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

Requiere -pabanderas:

$ 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

Gracias a @manatwork por reducir algunos bytes

Julia, 35 bytes

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

Esta es una función lambda que acepta una matriz y devuelve una tupla de enteros. Para llamarlo, asígnelo a una variable.

Julia tiene una función extremaincorporada para obtener los elementos mínimos y máximos de una matriz como una tupla. Sin embargo, dado que la matriz también puede tener cadenas, primero tenemos que filtrarlas. Podemos hacerlo probando si cada elemento es un entero usando isa.

Japt, 23 bytes

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

¡Pruébelo en línea!

Cómo funciona

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

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

Requiere una lista separada por líneas:

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

Gracias a @manatwork por reducir algunos bytes

PowerShell, 53 36 bytes

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

_{Guardado 17 bytes gracias a @goric}

OOOF ... PowerShell generalmente juega bastante rápido y flojo con el lanzamiento, que normalmente es algo bueno para jugar al golf, pero aquí lo duele.

Toma nuestra entrada $args[0]y la canaliza en una Where-Objectdeclaración (the ?) que solo seleccionará números enteros y los pasará a lo largo de la tubería, descartando cualquier otra cosa. Dado que el reenvío dinámico se realiza sobre la marcha en segundo plano para usted (por ejemplo, el 1+"5"retorno 6es un PowerShell perfectamente válido), debemos utilizar el -isoperador para diferenciar entre los tipos de datos.

A partir de ahí, canalizamos esa colección Sort-Object, que clasificará los enteros de menor a mayor. El exterior ()es necesario para que podamos hacer referencia al primer y último elemento con [0,-1](es decir, el más pequeño y el más grande), pero tenga en cuenta que también necesitamos el exterior @para forzar el lanzamiento de la salida sortcomo una matriz si solo hay un objeto (como resultado de el ?, o solo un objeto fue ingresado).

MATL , 23 bytes

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

Pruébalo en línea!

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

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

Probando :)

"Sin golf":

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

Explicación:

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

Pruébalo aquí!

Perl 6 , 25 bytes

La respuesta obvia sería este Lambda WhateverCode

*.grep(Int).minmax.bounds

Si tiene que ser un programa completo

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

La entrada a este programa completo es una lista de valores separados por espacios

Uso

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

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

Try it here (Firefox only).

No esta mal, no está mal...

Explicación

Esto genera una matriz que contiene tanto el máximo como el mínimo. (ï⇔⒡≔=+$⸩,básicamente filtra todas las cadenas en la entrada, МƲobtiene el máximo en la entrada y МƵobtiene el mínimo.

Solo una nota: este es el primer desafío donde puedo usar ⇔, que básicamente se convierte ï⇔en ï=ï.

Python 3, 56 bytes

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

Pruébelo en línea en Ideone .

APL (Dyalog) , 13 bytes

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

Pruébalo en línea!

∊ enlist (aplanar - esto convierte todas las cadenas en caracteres en la lista grande)

⎕AV~⍨ eliminar todos los caracteres de la A Tomic V ector (el conjunto de caracteres - números hojas)

(... ) aplique la siguiente función tácita:

 ⌊/ el mínimo a través

 , anexado a

 ⌈/ el maximus a través

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

Pruébalo en línea!

Función lambda de Java 8, toma la matriz como entrada y entrega la matriz {min, max} . No compite, porque la entrada tiene que ser una matriz entera.

Corregido y -1 byte gracias a Kevin Cruijssen

Jolf, 20 bytes

Probablemente pueda jugar golf ... Necesito implementar soluciones más cortas de verificación de tipo.

γ 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