Đầu vào là một mảng gồm (ít nhất 3, tối đa 20) số nguyên khác nhau. Mỗi số nguyên lớn hơn -1000 và nhỏ hơn 1000.

Nhiệm vụ của bạn là thu nhỏ các số bằng cách "ánh xạ tuyến tính" chúng từ 0.0đến 1.0. Điều này có nghĩa là số nhỏ nhất trong mảng sẽ được ánh xạ thành 0,0, lớn nhất là 1,0.

Bạn nhận được mảng dưới dạng tham số (bên trong hàm) hoặc đối số stdin / chương trình (bạn có thể chọn). In ra kết quả ở định dạng double1;double2;double3;.... Đầu ra phải có cùng thứ tự với đầu vào .

Nếu bạn muốn, bạn có thể làm tròn đầu ra thành 2 chữ số sau dấu thập phân. Phải có ít nhất 1 chữ số sau dấu thập phân.

Việc sử dụng các hàm dựng sẵn (các hàm giảm số cho bạn, chẳng hạn như mathicalas Rescale) không được phép .

Ví dụ:

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

(Đầu ra cuối cùng được làm tròn, nếu không nó sẽ được 0.0;0.0125;0.25;1.0)

CJam, 18 byte

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

Lưu ý rằng các thông dịch viên trực tuyến vô cớ và đại diện 0dnhư 0thay vì 0.0.

Chạy ví dụ

$ 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

Làm thế nào nó hoạt động

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

Cảm ơn @ edc65 cho toFixedmánh khóe

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

Chạy nó trong Firefox Console mới nhất.

Điều này tạo ra một chức năng fmà bạn có thể gọi như

F([5,-20,30])

Trăn 2, 72 68 63 56 55

Rõ ràng không ngắn gọn như các câu trả lời khác, nhưng dù sao:

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

Chạy mẫu:

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

Cũ (68 ký tự, được viết bằng 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/';*

Đầu vào giống như:

[5 -20 30]

Dùng thử trực tuyến ở đây Lưu ý rằng bản in biên dịch trực tuyến Double 0như 0chỉ. Chạy trong trình thông dịch java in chính xác.

Làm thế nào nó hoạt động:

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

Chạy bên trong LinqPad

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

Kiểm tra trong 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();}

Đầu ra

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

APL (15)

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

(hoặc, không có tàu, cũng có 15 ký tự :)

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

Điều này đọc đối số từ bàn phím và in kết quả ra màn hình.

Giải trình:

• ⎕: đọc một dòng từ bàn phím và đánh giá nó
• +-⌊/: trừ mục thấp nhất trong mảng khỏi tất cả các mục trong mảng
• +÷⌈/: chia từng mục trong mảng cho mục cao nhất của mảng
• 2⍕: định dạng có hai chữ số thập phân

Kiểm tra:

      (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

Bình thường , 18

Bây giờ với định dạng chính xác!

j\;mc-dhSQ-eSQhSQQ

Kiểm tra:

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

Giải trình:

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

Ngày 25 tháng 10

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

Giả sử đầu vào nằm trong lvà vì nó là vỏ tương tác, kết quả được in tự động (điều này có được phép không?)

APL, 31 ký tự / 55 byte

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

Mã cũ không có chữ số sau dấu thập phân:

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

Lấy tối thiểu của vectơ, lấy chênh lệch giữa tối đa và tối thiểu của vectơ, trừ tối thiểu từ mỗi phần tử và chia cho chênh lệch giữa min và max.

Mã đã chỉnh sửa để in hai chữ số sau dấu thập phân:

CJam, 30 29 byte

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

Mong đợi đầu vào trên STDIN như thế nào [5 -20 30].

Kiểm tra nó ở đây. (Điều này sẽ in số nguyên 0và 1không có dấu thập phân, nhưng trình thông dịch Java có in 0.0và 1.0.)

Do một lỗi tôi không thể rút ngắn {e>}*tới :e>mặc dù đó ta có thể theo spec (mà sẽ tiết kiệm 4 byte khi áp dụng cho cả min và max).

Giải thích hơi lỗi thời: (sẽ sửa đổi sau)

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

Vào cuối chương trình, nội dung ngăn xếp được in theo mặc định.

Tôi chắc chắn có một cách để tiết kiệm một nửa số lần chia sẻ lại ngăn xếp, nhưng tôi vẫn chưa thấy thoải mái với 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=";")    

Định dạng ngốn rất nhiều byte do 0và 1theo mặc định được cắt bớt để hiển thị không có gì qua phần nguyên.

Clojure 63

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

Không hoàn toàn tuân theo các quy tắc, vì nó trả về phân số thay vì tăng gấp đôi. Nếu điều đó không được chấp nhận, hãy thêm 7 byte

Ung dung:

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

Có thể gọi như thế này:

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

Đầu ra: (1/2 0 1)

Ruby, 49

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

Giải trình:

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 (Không cạnh tranh)

ZsWD1.S*+s/Z/

Hãy thử trực tuyến!

Q (31) ĐỊNH DẠNG IMPROPER ĐẦU RA

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

đầu vào

1 2 3

đầu ra

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

Mã thử nghiệm & mã hóa:

Hãy thử nó ở đây.

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

Đầu ra:

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