सिकुड़ती संख्या

Question

इनपुट एक सरणी है (कम से कम 3, अधिकतम 20) विभिन्न पूर्णांक। प्रत्येक पूर्णांक -1000 से अधिक और 1000 से छोटा है।

आपका काम उन्हें "रैखिक रूप से मानचित्रण" करके संख्याओं को सिकोड़ना 0.0है 1.0। इसका अर्थ है कि सरणी में सबसे छोटी संख्या 0.0 से मैप की जाएगी, जो 1.0 से सबसे बड़ी है।

आपको सरणी एक पैरामीटर के रूप में मिलती है (एक फ़ंक्शन के अंदर) या स्टडिन / प्रोग्राम तर्क (आप चुन सकते हैं)। फॉर्मेट में रिजल्ट का प्रिंट आउट ले लें double1;double2;double3;...। आउटपुट में इनपुट के समान क्रम होना चाहिए ।

यदि आप चाहते हैं, तो आप दशमलव बिंदु के बाद आउटपुट को 2 अंकों में गोल कर सकते हैं। दशमलव बिंदु के बाद कम से कम 1 अंक होना चाहिए।

बिल्ट-इन फ़ंक्शंस का उपयोग (फ़ंक्शंस जो आपके लिए संख्याओं को मापता है , जैसे कि गणितज्ञ Rescale) को अस्वीकृत कर दिया जाता है ।

उदाहरण:

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

(अंतिम आउटपुट गोल है, अन्यथा यह होगा 0.0;0.0125;0.25;1.0 )

Comments

तो यहां तक ​​कि हम एक फ़ंक्शन लिखते हैं परिणाम को मुद्रित करना पड़ता है? (डबल्स की इसी सरणी को वापस करने के विरोध में।)

— मार्टिन एंडर

@ मार्टिनबटनर हां, उन्हें मुद्रित करना होगा। अंतर्निहित कार्य अस्वीकृत हैं।

— कॉमनग्यू

"अंतर्निहित कार्यों का उपयोग (जैसे कि गणितज्ञ रेस्केल) को अस्वीकृत कर दिया गया है।" - यह बहुत अस्पष्ट है। क्या कार्य अस्वीकृत हैं? केवल वे जो पूरी समस्या को हल करते हैं (जो एक मानक खामियाजा होगा) हैं?

— जॉन ड्वोरक

रुको, तो, इनपुट एक फ़ंक्शन तर्क हो सकता है, लेकिन आउटपुट स्क्रीन पर होना चाहिए ???

— जॉन ड्वोरक

@ डेनिस प्रारूप में प्रश्न में दिखाए गए से मेल खाना है। इसका अर्थ यह है कि संख्याएँ अर्धविराम द्वारा अलग हो जाती हैं।

— कॉमनग्यू ऑक्ट

Answer 1

सीजेएम, 18 बाइट्स

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

ध्यान दें कि ऑनलाइन दुभाषिया गलत तरीके से प्रतिनिधित्व 0dकरता है0 इसके बजाय का है 0.0।

उदाहरण चलाते हैं

$ 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

यह काम किस प्रकार करता है

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, ';'))        ";

Comments

CJam स्रोत के रूप में इस पर मेरी प्रतिक्रिया: Wtf? स्पष्टीकरण की जरूरत है ...

— edc65

पॉपिंग के बजाय एरे इंडेक्स का उपयोग करके मिनट और अधिकतम प्राप्त करने का अच्छा तरीका और फिर चीजों को अदला-बदली करना

— ऑप्टिमाइज़र

यह शायद मेरा ठंडा बोलने का तरीका है, लेकिन आप दो बार क्यों छांटते हैं? यदि प्रत्येक तत्व से एक स्थिरांक घटाया जाता है, तो क्या एक सॉर्ट किए गए सरणी को सॉर्ट नहीं किया जाना चाहिए?

— इंगो बुर्क

@ IngoBürk सॉर्ट किया गया एरे ऐक्सेस ऐक्सेस से नहीं बचता, मुझे लगता है। जो समझ में आता है, क्योंकि अंतिम परिणाम को हल नहीं करना चाहिए।

— मार्टिन एंडर

@ मार्टिनबटनर डी'ओह। बेशक। हमें परिणाम के लिए आदेश बनाए रखने की आवश्यकता है। धन्यवाद!

— इंगो बुर्क

Answer 2

जावास्क्रिप्ट, ईएस 6, 81 बाइट्स

toFixedट्रिक के लिए @ edc65 को धन्यवाद

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

इसे नवीनतम फ़ायरफ़ॉक्स कंसोल में चलाएं।

यह एक फंक्शन बनाता है fजिसे आप पसंद कर सकते हैं

F([5,-20,30])

Comments

1) जब एक फ़ंक्शन की अनुमति दी गई है तो eval (संकेत) क्यों? 2) दशमलव बिंदु के बाद कम से कम 1 अंक होना चाहिए। 3) M को स्टोर करने की आवश्यकता नहीं है, बस d = Mm

— edc65

अपडेट किया गया। यद्यपि, दशमलव के बाद कम से कम 1 अंक प्राप्त करना कठिन है

— ऑप्टिमाइज़र

If you want, you can round the output to 2 digits after the decimal pointमुझे लगता है कि आसान तरीका है

— edc65

@ edc65 लेकिन वहाँ कोई रास्ता नहीं है परिवर्तित करने के लिए है 1करने के लिए 1.0मैं क्या किया के लिए छोड़कर।

— ऑप्टिमाइज़र

नहीं। क्या मैं इशारा कर सकता हूँ?

— edc65 13

Answer 3

अजगर 2, 72 68 63 56 55

स्पष्ट रूप से अन्य उत्तरों की तरह संक्षिप्त नहीं है, लेकिन फिर भी:

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

नमूना रन:

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

---

ओल्ड (68 अक्षर, पायथन 3 में लिखे गए):

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

Comments

आप परिभाषित करके एक और चार को बचा सकते हैं m=min(x)।

— FryAmTheEggman

Answer 4

सीजेएम, 24 23 बाइट्स

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

इनपुट इस तरह हो:

[5 -20 30]

इसे यहाँ ऑनलाइन आज़माएँ ध्यान दें कि ऑनलाइन कंपाइलर केवल प्रिंट Double 0करता है 0। जावा दुभाषिया में चलाएं जो सही ढंग से प्रिंट करता है।

यह काम किस प्रकार करता है:

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

Comments

आह, यह न्यूनतम और अधिकतम पाने के लिए एक बेहतर विचार है।

— मार्टिन एंडर

इसके 0;0.5;1बजाय प्रिंट करता है 0.0;0.5;1.0।

— कॉमनग्युय

@ मनु - हां, उसे ठीक करने की कोशिश कर रहा हूं। और लगभग सभी उत्तर केवल यही करते हैं।

— ऑप्टिमाइज़र

आप तय की जरूरत नहीं है। जावा दुभाषिया दोहरे 0 का प्रतिनिधित्व करता है 0.0।

— डेनिस

Answer 5

C # 92

LinqPad के अंदर चल रहा है

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

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

उत्पादन

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

Answer 6

एपीएल (15)

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

(या, ट्रेनों के बिना भी, 15 वर्ण :)

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

यह कीबोर्ड से तर्क पढ़ता है और परिणाम को स्क्रीन पर प्रिंट करता है।

स्पष्टीकरण:

• ⎕: कीबोर्ड से एक लाइन पढ़ें और उसका मूल्यांकन करें
• +-⌊/: सरणी में सभी आइटमों में से सबसे कम आइटम को घटाएं
• +÷⌈/: सरणी के प्रत्येक आइटम को सरणी के उच्चतम आइटम द्वारा विभाजित करें
• 2⍕: दो दशमलव स्थानों के साथ प्रारूप

परीक्षा:

      (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

Comments

बाइट काउंट को जोड़ना चाहिए ...

— ऑप्टिमाइज़र

जो केवल 24 बाइट्स है।

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र: जब तक प्रश्न नहीं कहा जाता है, तब तक, हर उत्तर को एन्कोडिंग का उपयोग करके स्कोर किया जाता है, जो सबसे छोटी बाइट गणना करता है। एक एपीएल कोडपेज है जो प्रत्येक एपीएल चरित्र को एक बाइट का प्रतिनिधित्व करता है।

— डेनिस

अगर मैं यहां कुछ गलत कर रहा हूं, तो मुझे सुधारें, लेकिन डिफ़ॉल्ट रूप से, कोड-गोल्फ को बाइट्स और mothereff.in/byte-counter#%282%E2%8D%95+%C3%B7%B2%8C%88/ में गिना जाता है। … पेज अपने 24 बाइट्स कहता है। क्या मैं कुछ भुल गया ?

— ऑप्टिमाइज़र

आउटपुट को अर्धविराम द्वारा अलग करना पड़ता है, न कि रिक्त स्थान।

— कॉमनग्यू

Answer 7

अजगर , १,

अब सही स्वरूपण के साथ!

j\;mc-dhSQ-eSQhSQQ

परीक्षा:

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

स्पष्टीकरण:

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

Comments

आउटपुट को सही ढंग से स्वरूपित नहीं किया गया है।

— कॉमनग्यू

@Manu इसके बारे में क्षमा करें, मैंने इसे ठीक कर दिया है।

— इसहाक

अपनी भाषा नहीं बनाता है, जिसे आप समय के साथ बदलते हैं, नियमों को थोड़ा सा बढ़ाते हैं? आप कार्यक्रम को छोटा बनाने के लिए स्पष्ट रूप से एक नई सुविधा जोड़ सकते हैं?

— क्रिस जेफरसन

@ChrisJefferson मैं हमेशा उस भाषा के नवीनतम संस्करण का उपयोग करता हूं जो समस्या पूछे जाने से पहले सामने आई थी। चूँकि यह सब गिथब को धकेल दिया गया है, इसलिए यह सत्यापित किया जा सकता है कि समस्या पोस्ट होने के बाद मैं कुछ नहीं जोड़ रहा हूँ। यह मानक CG.SE नियम है - भाषा प्रश्न से पुरानी होनी चाहिए, और मैं इसका पालन करता हूं।

— isaacg

Answer 8

25 अक्टूबर

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

इनपुट मानता है lऔर चूंकि यह एक इंटरैक्टिव शेल है परिणाम स्वचालित रूप से मुद्रित होता है (क्या इसकी अनुमति है?)

Comments

ऑक्टेव / मैटलैब को inputहालांकि उपयोगकर्ता इनपुट और एसटीडीआईएन की नकल करने के लिए करना पड़ता है । आप एक फ़ंक्शन भी लिख सकते हैं। इसके अलावा, क्या यह परिणाम को सही प्रारूप में प्रिंट करता है?

— मार्टिन एंडर

और नहीं, सिर्फ लौटकर और खोल के प्रिंट होने से आम तौर पर इसकी गिनती नहीं होती है। गोल्फस्क्रिप्ट और जैसे अलग हैं क्योंकि भाषा निर्दिष्ट करती है कि स्टैक अंत में मुद्रित किया गया है। लेकिन यह उदाहरण के लिए, जावास्क्रिप्ट नहीं है। और मैं मतलूब / सप्तक के लिए भी नहीं सोचता।

— इंगो बुर्क

Answer 9

एपीएल, 31 अक्षर / 55 बाइट्स

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

दशमलव बिंदु के बाद अंकों के बिना पुराना कोड:

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

वेक्टर का न्यूनतम ले लो, वेक्टर के अधिकतम और न्यूनतम के बीच अंतर करें, प्रत्येक तत्व से न्यूनतम घटाएं और न्यूनतम और अधिकतम के बीच अंतर से विभाजित करें।

दशमलव बिंदु के बाद दो अंकों को मुद्रित करने के लिए संपादित कोड:

Answer 10

सीजेएम, 30 29 बाइट्स

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

एसटीडीआईएन पर इनपुट की उम्मीद है [5 -20 30] ।

इसका परीक्षण यहां करें। (यह पूर्णांक 0और 1दशमलव बिंदु के बिना प्रिंट करेगा , लेकिन जावा दुभाषिया प्रिंट 0.0और प्रिंट करता है1.0 ।)

के कारण एक बग मैं छोटा नहीं कर सकते {e>}*करने के लिए:e> हालांकि कि कल्पना (जब दोनों न्यूनतम और अधिकतम करने के लिए लागू है, जिसमें 4 बाइट की बचत होगी) के अनुसार संभव हो जाना चाहिए।

थोड़ा पुराना विवरण: (बाद में संशोधन करेंगे)

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

कार्यक्रम के अंत में, स्टैक सामग्री डिफ़ॉल्ट रूप से मुद्रित होती है।

मुझे यकीन है कि स्टैक फेरबदल के आधे हिस्से को बचाने का एक तरीका है, लेकिन मैं सीजेएम के साथ अभी तक सहज नहीं हूं।

Comments

इसके 0;0.5;1बजाय प्रिंट करता है 0.0;0.5;1.0।

— कॉमनग्यू

@Manu ऑप्टिमाइज़र के जवाब पर डेनिस की टिप्पणी देखें। यह जावा दुभाषिया में ठीक काम करता है।

— मार्टिन एंडर

Answer 11

Xojo, 179 बाइट्स

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

Answer 12

आर, 60 बाइट्स

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

स्वरूपण बहुत सारे बाइट्स खाता है 0और 1डिफ़ॉल्ट रूप से पूर्णांक भाग के पिछले कुछ भी प्रदर्शित करने के लिए छंटनी की जाती है।

Answer 13

क्लोजर 63

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

नियमों का काफी पालन नहीं करता है, क्योंकि यह युगल के बजाय अंशों को लौटाता है। यदि यह स्वीकार्य नहीं है, तो 7 बाइट्स जोड़ें

Ungolfed:

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

इस तरह से कॉल करने योग्य:

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

आउटपुट: (1/2 0 1)

Answer 14

रूबी, ४ ९

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

स्पष्टीकरण:

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

Answer 15

05AB1E , 13 बाइट्स (गैर-प्रतिस्पर्धात्मक)

ZsWD1.S*+s/Z/

इसे ऑनलाइन आज़माएं!

Answer 16

Q (31) महत्वपूर्ण परिणाम प्रारूप

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

इनपुट

1 2 3

उत्पादन

0 .5 1

Answer 17

पर्ल - 60

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

Answer 18

जावा 7, 149 बाइट्स

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

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

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

आउटपुट:

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