L'entrée est un tableau (au moins 3, maximum 20) différents entiers. Chaque entier est supérieur à -1000 et inférieur à 1000.

Votre tâche consiste à réduire les nombres en les «mappant linéairement» de 0.0à 1.0. Cela signifie que le plus petit nombre du tableau sera mappé à 0,0, le plus grand à 1,0.

Vous obtenez le tableau en tant que paramètre (à l'intérieur d'une fonction) ou arguments stdin / programme (vous pouvez choisir). Imprimez le résultat au format double1;double2;double3;.... La sortie doit avoir le même ordre que l'entrée .

Si vous le souhaitez, vous pouvez arrondir la sortie à 2 chiffres après la virgule décimale. Il doit y avoir au moins 1 chiffre après le point décimal.

L' utilisation de fonctions intégrées (fonctions qui réduisent les nombres pour vous, telles que les mathématiques Rescale) est interdite .

Exemples:

Input              Output
[5,-20,30]         0.5;0.0;1.0
[1,2,3,4,5]        0.0;0.25;0.5;0.75;1.0
[0,5,100,400]      0.0;0.01;0.25;1.0

(La dernière sortie est arrondie, sinon ce serait 0.0;0.0125;0.25;1.0)

CJam, 18 octets

q~_$0=f-_$W=df/';*

Notez que l' interpréteur en ligne représente à tort 0dau 0lieu de 0.0.

Exemple d'exécution

$ cjam shrink.cjam <<< '[5 -20 30]'; echo
0.5;0.0;1.0
$ cjam shrink.cjam <<< '[1 2 3 4 5]'; echo
0.0;0.25;0.5;0.75;1.0
$ cjam shrink.cjam <<< '[0 5 100 400]'; echo
0.0;0.0125;0.25;1.0

Comment ça fonctionne

q~                    " P := eval(input())         ";
  _$0=                " S := sorted(P)[0]          ";
      f-              " Q := { X - S : X ∊ P }     ";
        _$W=d         " D := double(sorted(Q)[-1]) ";
             f/       " R := { X / D : X ∊ Q }     ";
               ';*    " print(join(R, ';'))        ";

JavaScript, ES6, 81 octets

Merci à @ edc65 pour l' toFixedastuce

F=a=>a.map(v=>((v-n)/d).toFixed(2),n=Math.min(...a),d=Math.max(...a)-n).join(';')

Exécutez-le dans la dernière console Firefox.

Cela crée une fonction fque vous pouvez invoquer comme

F([5,-20,30])

Python 2, 72 68 63 56 55

Évidemment pas aussi concis que les autres réponses, mais de toute façon:

x=input()
m=min(x)
print[(i*1.-m)/(max(x)-m)for i in x]

Exemple d'exécution:

[1,100,25,8,0]                  #input
[0.01, 1.0, 0.25, 0.08, 0.0]    #output

Ancien (68 caractères, écrit en Python 3):

x=eval(input())
y=sorted(x)
print([(i-y[0])/(y[-1]-y[0])for i in x])

CJam, 24 23 octets

l~_$)\(:M\;-\Mf-\df/';*

L'entrée doit être comme:

[5 -20 30]

Essayez-le en ligne ici. Notez que le compilateur en ligne s'imprime Double 0comme 0uniquement. Exécutez l'interpréteur java qui s'imprime correctement.

Comment ça fonctionne:

l~                      "Evaluate input and convert each element to double";
  _$                    "Copy the array and sort the copied array";
    )                   "Pop the last element out of the array. This is Max";
     \                  "Swap last two stack elements, bring sorted array on top";
      (:M               "Pop the first element of array and store it in M. This is Min";
         \;             "Bring the remaining of sorted array on top and remove it from stack";
           -\           "Subtract Max and Min and bring the original array to top of stack"
             Mf-        "Push min to stack and subtract it from each array element";
                \df/    "Bring (Double)(Max-Min) to top and divide each array element by it";
                   ';*  "Push the character ; to stack and join the array with it";

C # 92

Fonctionnement à l'intérieur de LinqPad

void F(int[]a)
{
   double n=a.Min(),d=a.Max()-n;
   a.Select(x=>((x-n)/d).ToString("0.00")).Dump();
}

Test dans LinqPad

void Main()
{
    F(new int[]{5,-20,30});
}
void F(int[]a){double n=a.Min(),d=a.Max()-n;a.Select(x=> ((x-n)/d).ToString("0.00")).Dump();}

Production

IEnumerable<String> (3 items)
0,50 
0,00 
1,00 

APL (15)

(2⍕+÷⌈/)(+-⌊/)⎕

(ou, sans trains, également 15 caractères :)

2⍕V÷⌈/V←V-⌊/V←⎕

Cela lit l'argument du clavier et imprime le résultat à l'écran.

Explication:

• ⎕: lire une ligne du clavier et l'évaluer
• +-⌊/: soustraire l'élément le plus bas du tableau de tous les éléments du tableau
• +÷⌈/: divise chaque élément du tableau par l'élément le plus élevé du tableau
• 2⍕: format avec deux décimales

Tester:

      (2⍕+÷⌈/)(+-⌊/)⎕
⎕:
     5 ¯20 30
 0.50 0.00 1.00
      (2⍕+÷⌈/)(+-⌊/)⎕
⎕:
      1 2 3 4 5
 0.00 0.25 0.50 0.75 1.00
      (2⍕+÷⌈/)(+-⌊/)⎕
⎕:
      0 5 100 400
 0.00 0.01 0.25 1.00

Pyth , 18

Maintenant avec un formatage correct!

j\;mc-dhSQ-eSQhSQQ

Tester:

$ pyth -c 'j\;mc-dhSQ-eSQhSQQ' <<< '[0,5,100,400]'
0.0;0.0125;0.25;1.0

Explication:

(implicit)              Q = eval(input())
j\;                     ';'.join(
   m                             map(lambda d:
    c                                         float_div(
     -dhSQ                                              d-sorted(Q)[0],
     -eSQhSQ                                            sorted(Q)[-1]-sorted(Q)[0]),
    Q                                         Q))

Octave 25

b=min(l);(l-b)/(max(l)-b)

Suppose que l'entrée est ldedans et puisqu'il s'agit d'un shell interactif, le résultat est imprimé automatiquement (est-ce autorisé?)

APL, 31 caractères / 55 octets

{b←⌊/⍵⋄c←(⌈/⍵)-b⋄{2⍕(⍵-b)÷c}¨⍵}

Ancien code sans chiffres après le point décimal:

{b←⌊/⍵⋄c←(⌈/⍵)-b⋄{(⍵-b)÷c}¨⍵}

Prendre le minimum du vecteur, prendre la différence entre le maximum et le minimum du vecteur, soustraire le minimum de chaque élément et diviser par la différence entre le min et le max.

Code édité pour imprimer deux chiffres après la virgule décimale:

CJam, 30 29 octets

l~:d_{e>}*\_{e<}*:Mf-\M-f/';*

Attend l'entrée sur STDIN comme [5 -20 30].

Testez-le ici. (Cela affichera un entier 0et 1sans point décimal, mais l'interpréteur Java imprimera 0.0et 1.0.)

En raison d' un bug , je ne peux pas réduire {e>}*à :e>bien cela devrait être possible selon les spécifications (qui sauverait 4 octets lorsqu'il est appliqué à la fois min et max).

Explication légèrement dépassée: (sera modifiée ultérieurement)

l~:d_{e<}*_@_{e>}*@-\@f-\f/';* "Read and eval the input leaving an array of strings on the stack";
l~                             "Read and eval the input leaving an array of strings on the stack";
  :d                           "Convert all elements to double";
    _                          "Duplicate the array";
     {e<}*                     "Wrap the MIN function in a black and fold it onto the array";
          _                    "Duplicate the minimum";
           @                   "Rotate the stack, pulling the array to the top";
            _                  "Duplicate the array";
             {e>}*             "Same as before, now with MAX";
                  @            "Rotate the stack, pulling the minimum to the top";
                   -           "Subtract to give the total range";
                    \          "Swap range and array";
                     @         "Rotate the stack, pulling the other minimum to the top";
                      f-       "Subtract the minimum from each element in the array";
                        \      "Swap range and array";
                         f/    "Divide each element in the array by the range";
                           ';  "Push a semicolon character";
                             * "Riffle the semicolon into the array";

À la fin du programme, le contenu de la pile est imprimé par défaut.

Je suis sûr qu'il existe un moyen d'économiser la moitié du remaniement de la pile, mais je ne suis pas encore à l'aise avec CJam.

Xojo, 179 octets

dim x,n as double,k,z as int16,s() as string
n=1e3
x=-n
for each k in a
x=max(x,k)
n=min(n,k)
next
for k=0 to ubound(a)
s.append str((a(k)-n)/(x-n),"0.0#")
next
msgbox join(s,";")

R, 60 octets

m=min(x<-scan());cat(sprintf("%f",(x-m)/(max(x)-m)),sep=";")    

Le formatage consomme beaucoup d'octets en raison de 0et 1par défaut sont découpés pour n'afficher rien au-delà de la partie entière.

Clojure 63

(fn[v](let[l(apply min v)](map #(/(- % l)(-(apply max v)l))v))) 

Ne suit pas tout à fait les règles, car il renvoie des fractions au lieu de doubles. Si ce n'est pas acceptable, ajoutez 7 octets

Non golfé:

(fn [values]
    (let [low (apply min values)]
         (map #(/ (- % low)
                  (- (apply max values) low))
              values)))

Appelable comme ceci:

((fn[v](let[l(apply min v)](map #(/(- % l)(-(apply max v)l))v))) [5 -20 30])

Production: (1/2 0 1)

Rubis, 49

f=->a{$><<a.map{|x|(x-l=a.min).fdiv(a.max-l)}*?;}

Explication:

f=->a{}     # Define a lambda that takes one argument a
$><<        # Print the following to STDOUT
a.map{|x|}  # For each element x
(x-l=a.min) # Find the lowest element of a, assign it to l, and subtract it from x
.fdiv       # Float division (/ truncates)
(a.max - l) # Divide by the maximum minus the minimum
*?;         # Convert the resulting array into a string joined by the ';' character

05AB1E , 13 octets (non concurrent)

ZsWD1.S*+s/Z/

Essayez-le en ligne!

Q (31) FORMAT DE SORTIE INCORRECT

{(%/)(x;max x)-min x}(.:)(0::)0

contribution

1 2 3

production

0 .5 1

Perl - 60

my@a=sort@ARGV;print map{($_-$a[0])/($a[-1]-$a[0])." "}@ARGV

Java 7, 149 octets

float[]c(int[]x){int b=1<<31,a=b-1,j=0,l=x.length;for(int i:x){a=i<a?i:a;b=i>b?i:b;}float[]r=new float[l];for(;j<l;r[j]=x[j++]-a)*1f/(b-a);return r;}

Code non testé et testé:

Essayez-le ici.

import java.util.Arrays;
class M{
  static float[] c(int[] x){
    int b = Integer.MIN_VALUE,
        a = b-1, // In Java, Integer.MIN_VALUE - 1 = Integer.MAX_VALUE (and vice-versa)
        j = 0,
        l = x.length;
    for(int i : x){
      a = i < a ? i : a; // Determine min value of array
      b = i > b ? i : b; // Determine max value of array
    }
    float[] r = new float[l];
    for(; j < l; r[j] = (x[j++] - a) * 1f / (b-a));
    return r;
  }

  public static void main(String[] a){
    System.out.println(Arrays.toString(c(new int[]{ 5, -20, 30 })));
    System.out.println(Arrays.toString(c(new int[]{ 1, 2, 3, 4, 5 })));
    System.out.println(Arrays.toString(c(new int[]{ 0, 5, 100, 400 })));
  }
}

Production:

[0.5, 0.0, 1.0]
[0.0, 0.25, 0.5, 0.75, 1.0]
[0.0, 0.0125, 0.25, 1.0]