A tarefa

A tarefa é muito simples. Dada uma matriz que contém apenas números inteiros e seqüências de caracteres , produza o maior número e o menor número.

Casos de teste

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

Números em strings não são considerados números inteiros:

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

Se houver apenas um número inteiro, ele será o número inteiro maior e menor:

Input: [1]
Output: 1, 1

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

Regras

• Você pode assumir que uma matriz sempre contém pelo menos um número inteiro.
• Todos os números inteiros são positivos (maiores que 0)
• A ordem da saída não importa.
• Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!
• As strings podem conter todos os caracteres ASCII imprimíveis ( 32 - 126) e não estão vazias.

Sério, 9 6 bytes

,ì;M@m

Experimente Online

Como 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 salvos thx @Neil

Nota: x===+xé verdadeiro se e somente se xfor um número

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

Pitão, 14 11 10 bytes

hM_BS^I#1Q

Experimente online. Suíte de teste.

Explicação

• Q: entrada avaliada
• #: filtre isso em:
  • I: o valor é o mesmo depois de:
    • ^…1 elevando-o ao poder 1
• S: classifique isso
• _B: criar matriz [previous, reversed(previous)]
• hM: pegue o primeiro item de cada item daquele

A parte mais difícil é jogar golfe na remoção de strings, que atualmente leva 4 bytes. A abordagem atual funciona devido ao ^<str>1uso do primeiro poder cartesiano da sequência (basicamente, a lista dos caracteres da string), mas ^<int>1é apenas a função de identidade.

Python 2, 42 bytes

No Python 2, números inteiros são sempre menores que strings durante as comparações; portanto, um simples min(s)encontrará o menor número inteiro. Ao encontrar o máximo, precisamos primeiro filtrar as strings. A função anônima aceita uma sequência e retorna uma tupla com o mínimo e o máximo.

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

Exemplo:

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

Gelatina, 8 bytes

|f¹Ṣ0,1ị

Experimente online!

fundo

Em um mundo perfeito, seria suficiente cruzar a lista com uma versão achatada de si mesma. Strings são simplesmente listas de caracteres no Jelly, portanto, enquanto a lista original contenha números inteiros e strings, a versão achatada conteria números inteiros e caracteres, deixando apenas os inteiros na interseção.

No mundo real, ambos os analisadores de ambos os literais de entrada e de cadeia produzir caracteres em vez de cordas de comprimento 1. A única maneira de passar uma cadeia Singleton para uma função seria para codificar o "manualmente", como, por exemplo, [”a]que é um caractere envolvido em uma matriz.

Isso salvaria um byte, com um total de 7 bytes ( Experimente online! ).

fFṢ0,1ị

Como isso provavelmente não é aceitável, também precisamos de uma maneira de diferenciar caracteres de números inteiros.

Os átomos bit a bit de Jelly tentam desesperadamente converter seus argumentos em números inteiros. Eles começam vetorizando até encontrar tipos de profundidade 0 (números ou caracteres) e tentam convertê-los em números inteiros. Para um caractere que representa um número inteiro, isso será bem-sucedido. Para outros, um átomo diádico bit a bit simplesmente desiste e retorna 0 .

Por exemplo, OR bit a bit a lista [1, "2", "34", "-5", "a", "bc"]consigo produzirá

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

Ao cruzar o resultado com a lista original, nos livramos das matrizes e dos números inteiros que não estavam presentes na lista original.

Como 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 teste

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

Ruby, 57 36 29 bytes

Novato aqui, então eu não sei se existe algum lugar / maneira padrão ou universalmente aceito para calcular os bytes usados, qualquer ajuda seria muito apreciada!

Editado de acordo com o manatwork e o comentário da maçaneta da porta!

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

Teste

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*_,(%}

Um bloco sem nome (função) que espera a matriz de entrada na pilha e deixa a matriz de saída em seu lugar.

Execute todos os casos de teste.

Explicação

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

No Haskell, todos os elementos de uma lista devem ser do mesmo tipo, portanto não posso misturar Integere String. No entanto, existe o Eithertipo de combinação de dois tipos em um único. A lista de entrada é, portanto, do tipo Either Integer String¹ . ffiltra os números inteiros, remove o Eitherwrapper, coloca a lista como elemento único em uma nova lista (por exemplo [[1,2,3]]), para que <*>possa aplicar as funções fornecidas no primeiro argumento a ele.

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

Edit: @xnor entrou <*>em jogo e salvou 2 bytes. Obrigado!

¹ na verdade, é totalmente polimórfico no segundo tipo que a Stringpropriedade nunca é utilizado.

jq, 21 caracteres

[.[]|numbers]|min,max

Exemplo de execução:

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

Teste on-line:

• [7, 8, 10, "Olá", 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

Obrigado (como sempre) a @ MartinBüttner pela ajuda no golfe.

Não é competitivo em termos de golfe, mas é interessante implementar a classificação de bolhas inteiras na Retina.

Assume que todas as seqüências de caracteres na entrada são "aspas duplas e não contêm aspas duplas de escape \".

A`"
¶

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

(a)+
$#1

A entrada é separada por nova linha.

Experimente online.

Mathematica , 14

#&@@@MinMax@#&

Exemplo:

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

Explicação:

Quando MinMaxrecebe entrada não numérica, reduz o problema o máximo que pode e deixa os termos agrupados Mine Max:

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

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

Devido à ordem automática que ocorre, as seqüências seguem números inteiros.

Applyat levelspec {1}, abreviação @@@, é então usado para puxar o primeiro argumento de elementos não atômicos. Observe que não 5é tocado aqui:

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;

Sem golfe

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;

A subconsulta analisa a matriz e a divide para preencher uma visualização com um elemento por linha. Em seguida, os elementos não numéricos são filtrados.

Eu gostaria de ter encontrado uma maneira de fazê-lo com MENOS e MAIORES, mas sem sorte em como lidar com a matriz como um parâmetro.

vimscript, 25 bytes

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

Sim, isso mesmo, vimscript.

Espera entrada no formulário

1
2
3
4
"5"

E saídas na forma

1
4

Explicação:

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)

A primeira linha precisa ser duplicada duas vezes para lidar com o caso de extremidade de uma entrada de um único número. Isso ocorre porque o último comando irá reclamar se houver apenas duas linhas quando for atingido, uma vez que acaba sendo 2,1dum intervalo para trás.

Perl 44 39 + 3 = 41 bytes

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

Requer -pasinalizadores:

$ 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

Graças a @manatwork por remover alguns bytes

Julia, 35 bytes

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

Esta é uma função lambda que aceita uma matriz e retorna uma tupla de números inteiros. Para chamá-lo, atribua-o a uma variável.

Julia possui uma função extremainterna para obter os elementos mínimo e máximo de uma matriz como uma tupla. No entanto, como o array também pode ter cadeias, primeiro precisamos filtrá-las. Podemos fazer isso testando se cada elemento é um número inteiro usando isa.

Japonês, 23 bytes

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

Teste online!

Como 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'

Requer uma lista separada por linhas:

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

Graças a @manatwork para eliminar alguns bytes

PowerShell, 53 36 bytes

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

_{Guardado 17 bytes graças a @goric}

OOOF ... O PowerShell geralmente joga muito rápido e com folga na fundição, o que normalmente é uma coisa boa para o golfe, mas prejudica aqui.

Pega nossa entrada $args[0]e a coloca em uma Where-Objectdeclaração (the ?) que seleciona apenas números inteiros e os passa pelo pipeline, descartando qualquer outra coisa. Como a re-conversão dinâmica ocorre em segundo plano para você (por exemplo, 1+"5"retornar o 6PowerShell perfeitamente válido), precisamos usar o -isoperador para diferenciar os tipos de dados.

A partir daí, canalizamos essa coleção Sort-Object, que classificará os números inteiros do menor para o maior. O externo ()é necessário para que possamos referenciar o primeiro e o último elemento com [0,-1](ou seja, o menor e o maior), mas observe que também precisamos do exterior @para forçar o lançamento da saída sortcomo uma matriz se houver apenas um objeto (como resultado de o ?, ou apenas um objeto foi inserido).

MATL , 23 bytes

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

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

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

Apenas tentando :)

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

Pitão, 11 bytes

hJSf!>TkQeJ

Explicação:

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

Experimente aqui!

Perl 6 , 25 bytes

A resposta óbvia seria essa lambda WhateverCode

*.grep(Int).minmax.bounds

Se tiver que ser um programa completo

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

A entrada para este programa completo é uma lista de valores separados por espaço

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

Nada mal nada mal...

Explicação

Isso gera uma matriz contendo o máximo e o mínimo. (ï⇔⒡≔=+$⸩,basicamente filtra todas as strings da entrada, МƲobtém o máximo na entrada e МƵobtém o mínimo.

Apenas uma observação: este é o primeiro desafio em que uso ⇔, que basicamente se ï⇔transforma ï=ï.

Python 3, 56 bytes

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

Experimente online no Ideone .

APL (Dyalog) , 13 bytes

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

Experimente online!

∊ alistar (achatar - isso transforma todas as seqüências de caracteres em caracteres na grande lista)

⎕AV~⍨ remover todos os caracteres na Uma Tomic V ector (o conjunto de caracteres - números de folhas)

(… ) Aplique a seguinte função tácita:

 ⌊/ o mínimo através

 , anexado a

 ⌈/ o máximo atravé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;}

Experimente online!

A função Java 8 lambda, recebe o array como entrada e fornece o array {min, max}. Não concorrente, porque a entrada deve ser uma matriz inteira.

Fixo e -1 byte graças a Kevin Cruijssen

Jolf, 20 bytes

Provavelmente posso jogar isso ... Preciso implementar soluções mais curtas de verificação 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