La tâche

La tâche est très simple. Étant donné un tableau contenant uniquement des entiers et des chaînes , affichez le plus grand nombre et le plus petit nombre.

Cas de test

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

Les nombres dans les chaînes ne sont pas considérés comme des entiers:

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

S'il n'y a qu'un seul entier, c'est à la fois le plus grand et le plus petit entier:

Input: [1]
Output: 1, 1

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

Règles

• Vous pouvez supposer qu'un tableau contiendra toujours au moins un entier.
• Tous les entiers sont positifs (supérieurs à 0)
• L'ordre de sortie n'a pas d'importance.
• C'est du code-golf , donc la soumission avec le moins d'octets gagne!
• Les chaînes peuvent contenir tous les caractères ASCII imprimables ( 32 - 126) et ne sont pas vides.

Sérieusement, 9 6 octets

,ì;M@m

Essayez-le en ligne

Comment ça marche

,                              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

Modifier 2 octets enregistrés thx @Neil

Remarque: x===+xest vrai si et seulement si xest un nombre

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

Pyth, 14 11 10 octets

hM_BS^I#1Q

Essayez-le en ligne. Suite de tests.

Explication

• Q: entrée évaluée
• #: filtrer cela sur:
  • I: la valeur étant la même après:
    • ^…1 l'élever au pouvoir 1
• S: trier ça
• _B: créer un tableau [previous, reversed(previous)]
• hM: prendre le premier élément de chaque élément de cette

La partie la plus difficile est de jouer au golf avec la suppression des cordes, ce qui prend actuellement 4 octets. L'approche actuelle fonctionne en raison de la ^<str>1prise de la première puissance cartésienne de la séquence (essentiellement, la liste des caractères de la chaîne), mais ^<int>1n'est que la fonction d'identité.

Python 2, 42 octets

En Python 2, les entiers sont toujours inférieurs aux chaînes lors des comparaisons, donc un simple min(s)trouvera le plus petit entier. Cependant, lors de la recherche du maximum, nous devons d'abord filtrer les chaînes. La fonction anonyme accepte une séquence et renvoie un tuple avec le minimum et le maximum.

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

Exemple:

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

Gelée, 8 octets

|f¹Ṣ0,1ị

Essayez-le en ligne!

Contexte

Dans un monde parfait, il suffirait de recouper la liste avec une version aplatie d'elle-même. Les chaînes sont simplement des listes de caractères dans Jelly, donc alors que la liste d'origine contiendrait des entiers et des chaînes, la version aplatie contiendrait des entiers et des caractères, ne laissant que les entiers dans l'intersection.

Dans le monde réel, les analyseurs des littéraux d'entrée et de chaîne produisent des caractères au lieu de chaînes de longueur 1. La seule façon de passer une chaîne singleton à une fonction serait de la coder "manuellement" comme, par exemple [”a], qui est un caractère enveloppé dans un tableau.

Cela permettrait d'économiser un octet, pour un total de 7 octets ( essayez-le en ligne! ).

fFṢ0,1ị

Comme ce n'est probablement pas acceptable, nous avons également besoin d'un moyen de différencier les caractères des entiers.

Les atomes au niveau du bit de Jelly tentent désespérément de convertir leurs arguments en nombres entiers. Ils commencent par vectoriser jusqu'à rencontrer des types de profondeur 0 (nombres ou caractères), puis tentent de les convertir en entiers. Pour un caractère qui représente un entier, cela réussira. Pour d'autres, un atome dyadique au niveau du bit abandonnera simplement et retournera 0 .

Par exemple, OR au niveau du bit de la liste [1, "2", "34", "-5", "a", "bc"]avec lui-même produira

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

En coupant le résultat avec la liste d'origine, nous nous débarrassons des tableaux et des entiers qui n'étaient pas présents dans la liste d'origine.

Comment ça marche

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

MinMax@*Select[#>0&]

Cas de test

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

Rubis, 57 36 29 octets

Débutant ici, donc je ne sais pas s'il existe un endroit / moyen standard ou universellement accepté pour calculer les octets utilisés, toute aide serait très appréciée!

Modifié selon manatwork et commentaire de la poignée de porte!

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

Tester

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 octets

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

Un bloc sans nom (fonction) qui attend le tableau d'entrée sur la pile et laisse le tableau de sortie à sa place.

Exécutez tous les cas de test.

Explication

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

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

Dans Haskell, tous les éléments d'une liste doivent être du même type, donc je ne peux pas mélanger Integeret String. Cependant, il y a le Eithertype pour combiner deux types en un seul. La liste d'entrée est donc de type Either Integer String¹ . ffiltre les entiers, supprime le Eitherwrapper, place la liste en tant qu'élément unique dans une nouvelle liste (par exemple [[1,2,3]]), afin de <*>pouvoir lui appliquer les fonctions données dans le premier argument.

Exemple d'utilisation: f [Left 1, Left 3, Right "Hello", Left 2]-> [1,3].

Edit: @xnor mis <*>en jeu et enregistré 2 octets. Merci!

^{1 en} fait, il est entièrement polymorphe dans le second type car la Stringpropriété n'est jamais utilisée.

jq, 21 caractères

[.[]|numbers]|min,max

Exemple d'exécution:

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

Test en ligne:

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

Mathematica, 28 octets

MinMax[#/._String->Nothing]&

PHP, 50 48 octets

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

Rétine , 71

Merci (comme toujours) à @ MartinBüttner pour son aide au golf.

Pas compétitif au niveau du golf, mais il est intéressant d'implémenter le tri des bulles entières dans la rétine.

Suppose que toutes les chaînes de l'entrée sont entre "guillemets doubles et ne contiennent pas de guillemets doubles échappés \".

A`"
¶

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

(a)+
$#1

L'entrée est séparée par des sauts de ligne.

Essayez-le en ligne.

Mathematica , 14

#&@@@MinMax@#&

Exemple:

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

Explication:

Lorsque MinMaxreçoit une entrée non numérique, il réduit le problème autant que possible, puis laisse les termes enveloppés Minet Max:

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

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

En raison de l'ordre automatique qui a lieu, les chaînes suivent des entiers.

Applyà levelspec {1}, raccourci @@@, est ensuite utilisé pour extraire le premier argument des éléments non atomiques. Notez que 5c'est intact ici:

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

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

Oracle SQL 11.2, 189 octets

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;

Non 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 sous-requête analyse le tableau et le fractionne pour remplir une vue avec un élément par ligne. Ensuite, les éléments non numériques sont filtrés.

Je souhaite que j'aurais pu trouver un moyen de le faire avec LEAST et GREATEST, mais pas de chance avec la façon de gérer le tableau en tant que paramètre.

vimscript, 25 octets

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

Oui, c'est vrai, vimscript.

Attend la saisie dans le formulaire

1
2
3
4
"5"

Et les sorties sous la forme

1
4

Explication:

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 première ligne doit être dupliquée deux fois pour gérer le cas de bord d'une entrée d'un seul numéro. C'est parce que la dernière commande se plaindra s'il n'y a que deux lignes lorsqu'elle est atteinte, car elle finit par être 2,1dune plage arrière.

Perl 44 39 + 3 = 41 octets

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

Nécessite des -padrapeaux:

$ 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

Merci à @manatwork d' avoir rasé quelques octets

Julia, 35 octets

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

Il s'agit d'une fonction lambda qui accepte un tableau et renvoie un tuple d'entiers. Pour l'appeler, affectez-le à une variable.

Julia a une fonction intégrée extremapour obtenir les éléments minimum et maximum d'un tableau en tant que tuple. Cependant, comme le tableau peut également contenir des chaînes, nous devons d'abord les filtrer. Nous pouvons le faire en testant si chaque élément est un entier utilisant isa.

Japt, 23 octets

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

Testez-le en ligne!

Comment ça marche

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

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

Nécessite une liste séparée par ligne:

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

Merci à @manatwork de raser quelques octets

PowerShell, 53 36 octets

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

_{17 octets enregistrés grâce à @goric}

OOOF ... PowerShell joue généralement assez vite et en vrac avec le lancer, ce qui est normalement une bonne chose pour le golf, mais ça fait mal ici.

Prend notre entrée $args[0]et la canalise dans une Where-Objectinstruction (la ?) qui ne sélectionne que des entiers et les transmet le long du pipeline, en rejetant toute autre chose. Étant donné que la refonte dynamique se produit à la volée en arrière-plan pour vous (par exemple, le 1+"5"retour 6est PowerShell parfaitement valide), nous devons utiliser l' -isopérateur afin de différencier les types de données.

De là, nous dirigeons cette collection vers Sort-Object, qui triera les entiers du plus petit au plus grand. L'extérieur ()est nécessaire pour que nous puissions référencer le premier et le dernier élément avec [0,-1](c'est-à-dire le plus petit et le plus grand), mais notez que nous avons également besoin de l'extérieur @pour forcer le transtypage de la sortie d' sortun tableau s'il n'y a qu'un seul objet (comme résultat de le ?, ou un seul objet a été saisie).

MATL , 23 octets

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

Essayez-le en ligne!

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

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

J'essaye juste :)

"Non 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 octets

hJSf!>TkQeJ

Explication:

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

Essayez-le ici!

Perl 6 , 25 octets

La réponse évidente serait ce lambda WhatsCode

*.grep(Int).minmax.bounds

S'il doit s'agir d'un programme complet

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

L'entrée de ce programme complet est une liste de valeurs séparées par des espaces

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 caractères / 20 octets

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

Try it here (Firefox only).

Pas mal pas mal...

Explication

Cela génère un tableau contenant à la fois le maximum et le minimum. (ï⇔⒡≔=+$⸩,filtre essentiellement toutes les chaînes en entrée, МƲobtient le maximum en entrée et МƵobtient le minimum.

Juste une note: c'est le premier défi que j'utilise ⇔, qui se transforme ï⇔en gros ï=ï.

Python 3, 56 octets

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

Essayez-le en ligne sur Ideone .

APL (Dyalog) , 13 octets

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

Essayez-le en ligne!

∊ enlist (flatten - cela transforme toutes les chaînes en caractères dans la grande liste)

⎕AV~⍨ supprimer tous les caractères du A tomic V ecteur (le jeu de caractères - nombres de feuilles)

(… ) Appliquez la fonction tacite suivante:

 ⌊/ le minimum à travers

 , annexé à

 ⌈/ le maximus à travers

Java (OpenJDK 8) , 124 octets

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

Essayez-le en ligne!

Fonction lambda Java 8, prend le tableau en entrée et donne le tableau {min, max}. Pas de concurrence, car l'entrée doit être un tableau d'entiers.

Fixe et -1 octet grâce à Kevin Cruijssen

Jolf, 20 octets

Je peux probablement jouer au golf ... J'ai besoin de mettre en œuvre des solutions plus courtes de vérification de type.

γ 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