L'input è un array di (almeno 3, massimo 20) numeri interi diversi. Ogni numero intero è maggiore di -1000 e minore di 1000.

Il tuo compito è ridurre i numeri "mappandoli linearmente" da 0.0a 1.0. Ciò significa che il numero più piccolo nell'array verrà mappato su 0,0, il più grande su 1,0.

Ottieni l'array come parametro (all'interno di una funzione) o argomenti stdin / program (puoi scegliere). Stampa il risultato nel formato double1;double2;double3;.... L'output deve avere lo stesso ordine dell'input .

Se lo si desidera, è possibile arrotondare l'output a 2 cifre dopo il punto decimale. Ci deve essere almeno 1 cifra dopo il punto decimale.

L' uso di funzioni integrate (funzioni che riducono i numeri per te, come i matematici Rescale) non è consentito .

Esempi:

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

(L'ultimo output è arrotondato, altrimenti sarebbe 0.0;0.0125;0.25;1.0)

CJam, 18 byte

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

Si noti che l' interprete online rappresenta erroneamente 0dcome 0invece di 0.0.

Esempio di esecuzione

$ 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

Come funziona

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 byte

Grazie a @ edc65 per il toFixedtrucco

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

Eseguilo nell'ultima console di Firefox.

Questo crea una funzione fche puoi invocare come

F([5,-20,30])

Python 2, 72 68 63 56 55

Ovviamente non così conciso come le altre risposte, ma comunque:

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

Esecuzione di esempio:

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

Vecchio (68 caratteri, scritto in Python 3):

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

CJam, 24 23 byte

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

L'input è come:

[5 -20 30]

Provalo online qui Nota che il compilatore online stampa solo Double 0come 0. Esegui nell'interprete Java che stampa correttamente.

Come funziona:

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

In esecuzione all'interno di LinqPad

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

Test in 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();}

Produzione

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

APL (15)

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

(o, senza treni, anche 15 caratteri :)

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

Questo legge l'argomento dalla tastiera e stampa il risultato sullo schermo.

Spiegazione:

• ⎕: leggi una riga dalla tastiera e valutala
• +-⌊/: sottrae l'elemento più basso nella matrice da tutti gli elementi nella matrice
• +÷⌈/: divide ogni elemento nella matrice per l'elemento più alto della matrice
• 2⍕: formato con due cifre decimali

Test:

      (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 anni

Ora con una formattazione corretta!

j\;mc-dhSQ-eSQhSQQ

Test:

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

Spiegazione:

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

Ottava 25

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

Presuppone che l'input sia presente le poiché si tratta di una shell interattiva, il risultato viene stampato automaticamente (è consentito?)

APL, 31 caratteri / 55 byte

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

Vecchio codice senza cifre dopo il punto decimale:

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

Prendi il minimo del vettore, prendi la differenza tra il massimo e il minimo del vettore, sottrai il minimo da ciascun elemento e dividi per la differenza tra min e max.

Codice modificato per stampare due cifre dopo il punto decimale:

CJam, 30 29 byte

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

Si aspetta l'input su STDIN come [5 -20 30].

Provalo qui.(Verrà stampato un numero intero 0e 1senza virgola decimale, ma l'interprete Java stampa 0.0e 1.0.)

A causa di un bug che non posso accorciare {e>}*a:e> anche se questo dovrebbe essere possibile secondo le specifiche (che permetterebbe di risparmiare 4 byte se applicato a entrambi min e max).

Spiegazione leggermente obsoleta: (verrà modificata in seguito)

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

Alla fine del programma, il contenuto dello stack viene stampato per impostazione predefinita.

Sono sicuro che c'è un modo per salvare il rimpasto della metà dello stack, ma non sono ancora a mio agio con CJam.

Xojo, 179 byte

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 byte

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

La formattazione consuma molti byte a causa 0e 1per impostazione predefinita vengono tagliati per non visualizzare nulla oltre la parte intera.

Clojure 63

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

Non segue abbastanza le regole, poiché restituisce frazioni anziché doppie. Se ciò non è accettabile, aggiungere 7 byte

Ungolfed:

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

Callable in questo modo:

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

Produzione: (1/2 0 1)

Ruby, 49

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

Spiegazione:

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 byte (non concorrenti)

ZsWD1.S*+s/Z/

Provalo online!

Q (31) FORMATO DI USCITA IMPROPRIO

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

ingresso

1 2 3

produzione

0 .5 1

Perl - 60

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

Java 7, 149 byte

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

Codice non testato e test:

Provalo qui.

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

Produzione:

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