Giriş, (en az 3, maksimum 20) farklı tamsayılardan oluşan bir dizidir. Her tamsayı -1000'den büyük ve 1000'den küçüktür.

Göreviniz gelen "doğrusal haritalama" onlar tarafından numaralarını küçültmek etmektir 0.0için 1.0. Bu, dizideki en küçük sayının 0,0 ile, en büyüğü 1,0 ile eşleştirileceği anlamına gelir.

Diziyi bir parametre (bir işlev içinde) veya stdin / program bağımsız değişkenleri (seçebilirsiniz) olarak alırsınız. Sonucu formatta yazdırın double1;double2;double3;.... Çıktı , girdi ile aynı sıraya sahip olmalıdır .

İsterseniz, çıkışı ondalık noktadan sonra 2 basamağa yuvarlayabilirsiniz. Ondalık noktadan sonra en az 1 basamak olmalıdır.

Yerleşik fonksiyonların kullanımı (örneğin Mathematica olarak hangi ölçek sizin için numaralar aşağı fonksiyonlar, Rescale) izin verilmiyor .

Örnekler:

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

(Son çıktı yuvarlanır, aksi takdirde olur 0.0;0.0125;0.25;1.0)

CJam, 18 bayt

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

O Not çevrimiçi tercüman haksız yere temsil 0dolarak 0yerine 0.0.

Örnek çalışma

$ 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

Nasıl çalışır

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 bayt

İçin @ edc65 sayesinde toFixedhile

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

En son Firefox Konsolunda çalıştırın.

Bu, faşağıdaki gibi çağırabileceğiniz bir işlev oluşturur

F([5,-20,30])

Python 2, 72 68 63 56 55

Açıkçası diğer cevaplar kadar özlü değil, ama yine de:

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

Örnek çalışma:

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

Eski (Python 3 ile yazılmış 68 karakter):

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

CJam, 24 23 bayt

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

Girdi şöyle:

[5 -20 30]

Burada çevrimiçi Deneyin bu çevrimiçi derleyici baskılar Not Double 0olarak 0sadece. Doğru yazdırılan java yorumlayıcıda çalıştırın.

Nasıl çalışır:

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

LinqPad içinde koşu

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

LinqPad'de test

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

Çıktı

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

APL (15)

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

(veya tren olmadan da 15 karakter :)

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

Bu, argümanı klavyeden okur ve sonucu ekrana yazdırır.

Açıklama:

• ⎕: klavyeden bir satır oku ve değerlendir
• +-⌊/: dizideki tüm öğelerden dizideki en düşük öğeyi çıkarır
• +÷⌈/: dizideki her öğeyi dizinin en yüksek öğesine böl
• 2⍕: iki ondalık basamaklı biçim

Ölçek:

      (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

Şimdi doğru biçimlendirme ile!

j\;mc-dhSQ-eSQhSQQ

Ölçek:

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

Açıklama:

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

Oktav 25

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

Girdinin içinde olduğunu varsayar lve etkileşimli bir kabuk olduğu için sonuç otomatik olarak yazdırılır (buna izin verilir mi?)

APL, 31 karakter / 55 bayt

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

Ondalık noktadan sonra basamaksız eski kod:

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

Minimum vektörü alın, maksimum ve minimum vektör arasındaki farkı alın, her elemandan minimum değeri çıkarın ve min ve maks arasındaki farka bölün.

Ondalık noktadan sonra iki basamak basmak için Düzenlenmiş Kod:

CJam, 30 29 bayt

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

STDIN üzerindeki girişi bekler [5 -20 30].

Burada test edin. (Bu, tamsayı 0ve 1ondalık nokta olmadan yazdırır , ancak Java yorumlayıcısı yazdırır 0.0ve 1.0.)

Bir hata nedeniyle kısaltmak {e>}*mümkün :e>olmasına rağmen bu mümkün olmalıdır (hem min hem de max uygulandığında 4 bayt tasarruf).

Biraz eskimiş açıklama: (daha sonra değiştirilecek)

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

Programın sonunda, yığın içeriği varsayılan olarak yazdırılır.

Eminim yığın değiştirme yarısını kurtarmak için bir yol var, ama henüz CJam ile o kadar rahat değilim.

Xojo, 179 bayt

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 bayt

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

Biçimlendirme nedeniyle bayt çok yiyor 01 , tamsayı kısmının ötesinde hiçbir şey göstermeyecek şekilde kesilmiş ve varsayılan olarak tüketir.

Clojure 63

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

Kurallara tam olarak uymaz, çünkü çiftler yerine kesirler döndürür. Bu kabul edilebilir değilse, 7 bayt ekleyin

Ungolfed:

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

Bu şekilde çağrılabilir:

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

Çıktı: (1/2 0 1)

Yakut, 49

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

Açıklama:

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 bayt (Rakip değil)

ZsWD1.S*+s/Z/

Çevrimiçi deneyin!

Q (31) İYİLEŞTİRME ÇIKIŞ FORMATI

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

giriş

1 2 3

çıktı

0 .5 1

Perl - 60

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

Java 7, 149 bayt

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

Test edilmemiş ve test kodu:

Burada deneyin.

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

Çıktı:

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