Dans ce golf de code, vous devez obtenir le numéro le plus proche d'un autre dans une liste.

La sortie peut être le nombre le plus proche de l'entrée.

Exemple:

value: (Input) 5 --- [1,2,3] --- 3

Et, le programme peut fonctionner avec des nombres négatifs.

Exemple:

value: (Input) 0 --- [-1,3,5] --- -1


value: (Input) 2 --- [1, 5, 3] --- 1 (Because it gives priority to lower numbers)

RÈGLES:

Comme mentionné précédemment, il doit fonctionner avec des nombres négatifs.

S'il y a deux réponses (exemple: 0 - [5, -5]), le programme donne la priorité au numéro le plus bas. (-5)

C'est le golf de code, donc le code le plus court gagne!

Pyth, 6 octets

haDQSE

Suite de tests

Saisie sous la forme suivante sur STDIN:

num
array

Explication:

haDQSE
          Implicit: Q = eval(input()) (num)
     E    Evaluate input (array)
    S     Sort (smaller values to the front)
 aDQ      Sort by absolute difference with Q.
h         Take the first element of the sorted list, the min.
          Print implicitly.

Rubis, 34 octets

->n,a{a.sort.min_by{|x|(n-x).abs}}

a.sort       min_by tiebreaks by position in array, so put smaller numbers 1st
.min_by{|x|  select the element which returns the smallest val for predicate...
(n-x).abs}   (absolute) difference between input num and element

Mathematica, 12 octets

Min@*Nearest

FTW intégré! Explication de Buettner: "Mathematica a une fonction intégrée Nearestpour cela, mais il renvoie une liste de tous les nombres liés. Par conséquent, nous devons le composer avec Minpour rompre le lien."

Pyth, 8 octets

hS.mabQE

Explication

         - autoassign Q = eval(input())
  .m   E -   min_values([V for b in eval(input())])
    abQ  -    abs(b-Q)
 S       -  sorted(^)
h        - ^[0]

Essayez-le en ligne!

JavaScript ES6, 64 56 54 octets

(i,a)=>a.sort((a,b)=>s(i-a)-s(i-b)||a-b,s=Math.abs)[0]

Essayez-le en ligne

Merci à @Niel d' avoir économisé deux octets

Extrait de test:

f=(i,a)=>a.sort((a,b)=>s(i-a)-s(i-b)||a-b,s=Math.abs)[0];

[
  [5, [1, 2, 3]],
  [2, [3, 5, 1]],
  [2, [1, 3, 5]],
  [0, [-1, 2, 3]],
  [5, [1, 2, 3]]
].map(v=>O.textContent+=JSON.stringify(v)+": "+f.apply(null,v)+"\n")

<pre id=O></pre>

Gelée, 7 6 octets

ạżṛỤḢị

Essayez-le en ligne!

Comment ça fonctionne

ạżṛỤḢị Main link. Left input: n (number). Right input: A (list)

ạ      Take the asbolute difference of n and the items of A.
  ṛ    Yield the right argument, A.
 ż     Zip the left result with the right one.
       This pairing causes ties in absolute value to be broken by initial value.
   Ụ   Grade up; sort the indices of the resulting list by their associated values.
    Ḣ  Retrieve the first index, which corresponds to the smallest value.
     ị Retrieve the item of A at that index.

MATL , 10 octets

Sti-|4#X<)

Essayez-le en ligne!

S       % implicitly input array, and sort. This ensures smaller numbers have priority
t       % duplicate
i       % input number
-|      % compute array of absolute differences
4#X<    % arg min. If there are several minimizers, the position of the first is returned
)       % index into original array. Implicitly display

Python 2, 56 octets

a=input()
print sorted(input(),key=lambda x:abs(a-x))[0]

Obtient le numéro cible en premier a=input()- il doit être stocké dans une variable.

Il trie ensuite l'entrée avec la fonction lambda x:abs(a-x)appliquée (pensez map(lambda x:abs(a-x), input()))

Il prend ensuite la valeur minimale en cas de valeurs en double

TeaScript, 10 octets

T#(y-l)a)░

TeaScript ne prend pas en charge l'entrée de tableau, donc lors de l'exécution de la console: TeaScript("T#y-la)░", [[1, 2, 3], 1], {}, TEASCRIPT_PROPS) to runthis.

Explication

T#  // Sort input by...
  (y-l)a // absolute difference with input
)░  // First item in array

R, 42 octets

x=sort(scan());x[which.min(abs(x-scan()))]

Haskell, 38 octets

e#l=snd$minimum$(zip=<<map(abs.(e-)))l

Exemple d'utilisation: 2 # [1,5,3]->1 .

Pour chaque élément de la liste d'entrée, lfaites une paire de la différence absolue de l'élément avec le numéro d'entrée eet l'élément lui-même, par exemple e=2, l=[1,5,3]-> [(1,1),(3,5),(1,3)]. Trouvez le minimum et jetez la différence.

zsh, 75 73 71 70 67 octets

for n in ${@:2};{echo "$[$1-n]    $n"}|tr -d -|sort -n|head -1|cut -f2

Attend l'entrée comme arguments de ligne de commande.

Notez que les quatre espaces dans le echosont censés être des tabulations, mais Stack Exchange convertit les tabulations en espaces dans toutes les publications.

Non compatible Bash en raison de la for syntaxe.

for n in ${@:2};      for each argument except the first...
{echo "$[$1-n]\t$n"}  output the difference from the first argument
                        and then the original number
|tr -d -              poor man's abs()
|sort -n              sort by first num (difference), tiebreaking by second num
                        (original value)
|head -1              take the thing that sorted first
|cut -f2              print field 2 (aka discard the difference)

Merci à dev-null pour 2 octets!

Perl 6 , 31 octets

{@^b.sort.sort((*-$^a).abs)[0]}

Usage:

my &code = {@^b.sort.sort((*-$^a).abs)[0]}

say code 5, [1,2,3];   # 3
say code 0, [-1,3,5];  # -1
say code 2, [1, 5, 3]; # 1
say code 0, [5,-5];    # -5