स्टॉक टाइम मशीन

Question

स्टॉक टाइम मशीन

आपने एक डेटासेट तक पहुंच प्राप्त कर ली है tomorrowStocks, जिसमें NASDAQ पर आपके पसंदीदा व्यवसाय से स्टॉक की कीमतें शामिल हैं। यह डेटासेट एक कंटेनर है जिसे पिछले खुलने के मिनटों तक अनुक्रमित किया जाता है। प्रत्येक सूचकांक में उस समय स्टॉक की कीमत शामिल होती है।

// Assume the stock market opens at 9:30AM EDT
// tomorrowStocks[] contains the prices of your target stock.
// If the stock is $22 @ 10:30AM EDT
tomorrowStocks[60] == 22

उत्पादन

आपका काम का सबसे अच्छा संभव परिणाम निर्धारित करने के लिए है 1 purchaseऔर 1 saleके 1 stockदिए गए डाटासेट से।

gotchas

• आपको ठीक 1 स्टॉक खरीदना और बेचना होगा।
• आप एक ही टाइम स्लॉट में खरीद और बेच नहीं सकते हैं ।
• आपको बेचने से पहले खरीदना होगा ।

परीक्षण डेटा

[1,2,3,4,5]    # 4
[1,99,2,105]   # 104
[99,1,99,100]  # 99
[99,1,1,2,1,3] # 2
[5,4,3,3,1]    # 0
[5,4,3,1]      # -1
[5,2,1]        # -1
[5,4,1]        # -1
[55,45,20,1]   # -10
[5,1]          # -4
[10,7,5,1]     # -2
[7]            # Invalid input -- assume size >= 2

यह एक कोड-गोल्फ है ; अपनी पसंदीदा भाषा में सबसे छोटा उत्तर सबमिट करें!

Comments

PPCG में आपका स्वागत है, अच्छा पहला सवाल! :)

— FryAmTheEggman

क्या हम मान सकते हैं कि उत्पादन नियतात्मक है (यानी हमेशा एक समाधान है जो निश्चित रूप से सबसे अच्छा है, और कोई संबंध नहीं है)

— MayorMonty

किसी भाषा के लिए दुभाषिया बहुत खराब है जो अभी तक समाप्त नहीं हुआ है, क्योंकि इसे 4 बाइट्स में हल करने में सक्षम होना चाहिए ... मुझे यह समाप्त करने की आवश्यकता है कि मैं इतने अच्छे सवालों को याद नहीं कर सकता!

— स्टीवन एच।

@SpeedyNinja यह वास्तव में परीक्षण के मामलों में है। परीक्षण के मामले में [5,4,3,1]आप या तो के लिए 5और बेचने 4या बेचने या खरीदने 4और बेचने के लिए 3इष्टतम परिणाम प्राप्त कर सकते हैं -1।

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

@Fawful आप बाद में गैर-प्रतिस्पर्धी के रूप में अपना जवाब जोड़ सकते हैं। मैं निश्चित रूप से इसे देखने में दिलचस्पी

— लेगा

Answer 1

05AB1E , 4 बाइट्स

FryAmTheEggman के दृष्टिकोण का उपयोग करना । कोड:

¥ŒOà

स्पष्टीकरण:

¥     # Calculate the increments of the array.
 Π   # Get all substring of the array.
  O   # Sum the arrays in the array.
   à  # Get the largest sum and implicitly print that.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

Comments

डेमिट्टी मैंने 4 गोल्फिंग भाषाओं की कोशिश की और 05AB1E के बारे में भूल गया। वह मुझे अगली बार

— सीखेगा

Answer 2

पायथन 2, 46 बाइट्स

f=lambda x:-min(x.pop(0)-max(x),x[1:]and-f(x))

Ideone पर इसका परीक्षण करें ।

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

यह एक पुनरावर्ती दृष्टिकोण है जो पायथन 2 की खूबसूरती से विकृत मिश्रित प्रकार की तुलनाओं का लाभ उठाता है।

सबसे अच्छा संभावित परिणाम या तो सूची का अधिकतम अंतर है जिसका पहला तत्व हटा दिया गया है और वह पहला तत्व, या दूसरा अंतर जिसमें पहला तत्व शामिल नहीं है।

पहले तत्व को निकालने के बाद x.pop(0)(जो स्थायी रूप से इसे x से हटाता है ), हम गणना करते हैं x.pop(0)-max(x)। ध्यान दें कि इस अंतर में "गलत" संकेत है।

यदि अद्यतन सूची x में अभी भी कम से कम दो तत्व हैं, x[1:]तो एक गैर-रिक्त सूची प्राप्त करता है, और andइसे पुनरावर्ती कॉल के नकारात्मक के साथ बदल देता है, जैसा कि गणना की जाती है -f(x)। एक बार जारी रखने के लिए बहुत कम तत्व हैं, x[1:]and-f(x)एक खाली सूची का मूल्यांकन करता है।

अधिकतम परिणाम का चयन करने के लिए, हम अंतर के न्यूनतम और पुनरावर्ती कॉल (या []) के नकारात्मक को लेते हैं । चूंकि सभी पूर्णांकों की तुलना में कड़ाई से कम हैं [], इसलिए minयदि सही है तो बस अपने बाएं तर्क को वापस कर देगा []।

अंत में, अनुपस्थित माइनस -गणना किए गए परिणाम के संकेत को सही करता है।

Comments

यह अजीब रूप से सुंदर है।

— मृदुक

Answer 3

MATL , 7 बाइट्स

2XN!dX>

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

2XN  % Take input implicitly. Two-column 2D array with all combinations of 2 elements.
     % Each combination is a row. Elements in each row are in increasing order
!    % Transpose
d    % Difference of the two numbers in each column
X>   % Maximum value. Display implicitly

Comments

पता चला, यह डेनिस के जवाब के

— लुइस मेंडो

ओ ... मुझे मारो!

— DJMcMayhem

Answer 4

जेली , 5 बाइट्स

Œcḅ-Ṁ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

Œcḅ-Ṁ  Main link. Argument: A (integer array)

Œc     Generate all combinations of two elements of A, in order.
  ḅ-   Convert each pair from base -1 to integer.
       This maps [a, b] to b - a.
    Ṁ  Take the maximum of all computed differences.

Comments

IŒṡS€Ṁलगभग एक ही लंबाई, Ṁकभी-कभी योग करने से पहले उपयोग करना बहुत बुरा होता है गलत उत्तर देता है ...

— FryAmTheEggman

Answer 5

अजगर, ९

eSsM.:-Vt

इसे यहां आज़माएं या टेस्ट सूट चलाएं ।

प्रत्येक तत्व के बीच लगातार अंतर पाता है, फिर उस सरणी के प्रत्येक विकल्प को ढूँढता है। अंत में, तत्वों को योग करें और अधिकतम एक लौटाएं।

स्पष्टीकरण:

eSsM.:-Vt
eSsM.:-VtQQ   ## Auto-fill variables
      -VtQQ   ## Splat subtraction on each element of zip(Q[1:], Q)
    .:        ## Get all substrings
  sM          ## Sum each list
eS            ## Take the largest number

यह मेरे लिए उल्लेख किया गया था कि यह एल्गोरिथ्म काम करता है पूरी तरह से सहज नहीं है। उम्मीद है कि यह उदाहरण बताएगा कि यह एल्गोरिथ्म क्यों काम करता है:

[a, b, c, d]
difference between each element (reversed because of how Pyth does this)
[b-a, c-b, d-c]
"substrings" or each continuous slice
[b-a], [c-b], [d-c], [b-a, c-b], [c-b, d-c], [b-a, c-b, d-c]
sum each
[b-a], [c-b], [d-c], [b-a+c-b], [c-b+d-c], [b-a+c-b+d-c]
simplify
[b-a], [c-b], [d-c], [c-a], [d-b], [d-a]

Answer 6

अजगर, ९

_hS-M.cQ2

याय पफंस!

_hS-M.cQ2

     .cQ2 # generate all 2-elements combinations of Q (argument)
   -M     # map-splat with -: for each combination, substract the elements together
  S       # tort
 h        # take the first
_         # absolute value

Comments

मेरा मानना _hS-M.cQ2है कि यह समकक्ष है।

— फ्राईमईएग्गमैन

@FryAmTheEggman आह, धन्यवाद। अब यह सोचने की कोशिश कर रहा हूं कि मैं किस तरह से -तर्क के आदेश को उलट सकता हूं ... क्योंकि मुझे उपयोग करना है _hSऔर उपयोग नहीं कर सकता हैeS

— वेन

Answer 7

PowerShell v2 +, 58 बाइट्स

param($n)($n|%{($n[++$i..$n.count]|sort)[-1]-$_}|sort)[-1]

इनपुट लेता है $n, प्रत्येक तत्व को एक लूप में पाइप करता है |%{...}। प्रत्येक पुनरावृत्ति, हम इनपुट सरणी के अंत में $nपूर्व- वृद्ध के आधार पर स्लाइस ++$iकरते हैं, |sortकि, और अधिकतम लेते हैं [-1], फिर वर्तमान तत्व को घटाते हैं $_। हम फिर |sortउन सभी मतभेदों को, और फिर से अधिकतम लेते हैं [-1]।

एक क्रिया सरणी-इंडेक्स त्रुटि को टॉस करता है, क्योंकि हम सरणी के अंत में पिछले स्लाइस करने की कोशिश करते हैं। लेकिन, चूंकि STDERR को डिफ़ॉल्ट रूप से अनदेखा किया जाता है , हमें परवाह नहीं है।

Answer 8

जावास्क्रिप्ट (ईएस 6), 57 54 बाइट्स

a=>(m=Math.max)(...a.map((x,i)=>m(...a.slice(i+1))-x))

जावास्क्रिप्ट में, शेष के अधिकतम को लेना और वर्तमान तत्व को घटाना आसान है। (अंतिम तत्व के मामले में परिणाम अभी भी -Infinity होगा।) संपादित करें: 3 बाइट्स @CharlieWynn के लिए धन्यवाद।

Comments

मुझे लगता है (M = Math.max) और M का उपयोग करने से बाद में आपको 3 बाइट्स बचेंगे

— चार्ली व्यान

@CharlieWynn धन्यवाद, मैंने केवल कोशिश की थी with(जो इस मामले में मदद नहीं करता है)।

— नील

Answer 9

जे, 21 बाइट्स

[:>./@;i.@#<@{."_1-/~

मानों की एक सरणी को एक तर्क के रूप में लेता है और परिणाम देता है।

व्याख्या

[:>./@;i.@#<@{."_1-/~  Input: p
                  -/~  Make a table of all differences between every pair
          #            Get the count of values in p
       i.@             Create a range [0, 1, ..., len(p)-1]
             {."_1     Take that many values from each row of the table
           <@          Box each row of selected values
[:    ;                Unbox and concatenate them
  >./@                 Reduce it by the max and return

Answer 10

जावा, 141 बाइट्स

a->java.util.stream.IntStream.range(0,a.size()-1).map(i->a.subList(i+1,a.size()).stream().reduce(Math::max).get()-a.get(i)).max().getAsInt();

लैम्ब्डा एक ArrayList स्वीकार करता है और एक पूर्णांक लौटाता है।

परीक्षण मामलों के साथ अ-कोडित कोड:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.Function;
import java.util.stream.IntStream;

class Test {

    public static void main(String[] args) {
        Function<ArrayList<Integer>, Integer> f = a -> IntStream
            .range(0, a.size()-1)
            .map(i -> a.subList(i+1, a.size()).stream().reduce(Math::max).get() - a.get(i))
            .max()
            .getAsInt();

        System.out.println(f.apply(new ArrayList<>(Arrays.asList(1,2,3,4,5))));
        System.out.println(f.apply(new ArrayList<>(Arrays.asList(1,99,2,105))));
        System.out.println(f.apply(new ArrayList<>(Arrays.asList(99,1,99,100))));
        System.out.println(f.apply(new ArrayList<>(Arrays.asList(99,1,1,2,1,3))));
        System.out.println(f.apply(new ArrayList<>(Arrays.asList(5,4,3,3,1))));
        System.out.println(f.apply(new ArrayList<>(Arrays.asList(5,4,3,1))));
        System.out.println(f.apply(new ArrayList<>(Arrays.asList(5,2,1))));
        System.out.println(f.apply(new ArrayList<>(Arrays.asList(5,4,1))));
        System.out.println(f.apply(new ArrayList<>(Arrays.asList(55,45,20,1))));
        System.out.println(f.apply(new ArrayList<>(Arrays.asList(5,1))));
        System.out.println(f.apply(new ArrayList<>(Arrays.asList(10,7,5,1))));
    }
}

जहाँ तक मुझे पता है, जावा में स्ट्रीम में आगे देखने का कोई तरीका नहीं है, और जिस पद्धति से स्ट्रीम उत्पन्न होती है, उसमें हेरफेर करना अजीब परिणाम पैदा करता है। इसलिए कर रहे हैंa.remove(0) एक नक्शे के अंदर करने से धारा टूट जाती है।

Answer 11

VBA, 154

A1 में शुरू होने वाले कॉलम A में इनपुट लेता है, C1 में आउटपुट करता है। A चयनित में अंतिम सेल के साथ चलना चाहिए। ध्यान दें कि एक्सेल VBA में शर्तों के बीच रिक्त स्थान को ऑटो-जोड़ता है, अन्यथा यह आगे गोल्फ हो सकता है।

Sub s
i = Selection.Row
r = "B1:B" + i-1
Range(r).FormulaArray = "MAX(A2:A$" + i + "-A1)"
Range(r).FillDown
Range("C1").Formula = "MAX(" + r + ")"
End Sub

Answer 12

जावा, ११६

एक और जावा समाधान, मैंने यह साबित करने के लिए एक का उपयोग किया कि, धाराएँ अच्छी लग सकती हैं, लेकिन हमेशा गोल्फ के लिए उपयोगी नहीं हैं।

int a(int[]a){int t,d=a[1]-a[0],i,j,l=a.length;for(i=0;i<l;i++)for(j=i+1;j<l;j++){t=a[j]-a[i];d=d<t?t:d;}return d;}

इस समाधान में सुधार के लिए बहुत जगह है

Answer 13

क्लोजर, 99 बाइट्स

(fn[x](apply max(map #(-(apply max(% 1))(apply min(% 0)))(map #(split-at % x)(range 1(count x))))))

पहली सूची में इनपुट सूची को विभाजित करता है, फिर दूसरा और इसी तरह, इसलिए हमें एक सूची मिलती है जो इस तरह दिखाई देती है:

[[[n1][n2 ... nk]][[n1 n2][n3 ... nk]]...[[n1...n(k-1)][nk]]]फिर प्रत्येक जोड़ी के लिए दूसरे तत्व के अधिकतम से पहले तत्वों में से न्यूनतम घटाते हैं और फिर उनसे अधिकतम पाते हैं। अगर min maxतर्कों की किसी भी संख्या के बजाय क्लोजर सीक्वेंस ले रहे थे तो यह कम होगा ।

इसे ऑनलाइन देखें: https://ideone.com/b2nllT

Answer 14

माणिक, 52 बाइट्स

->a{b=[];(x=a.pop;b+=a.map{|v|x-v})while a[0];b.max}

संभावित बिक्री मूल्य और पिछले सभी के लाभ को देखने के लिए देखें। तब अधिकतम लाभ मिलता है।

Answer 15

सी, 101 99 बाइट्स

int i,j,m,h;int f(int*a){m=1<<31;for(;a[i];i++){for(j=i+1;a[j];h=a[j++]-a[i],m=h<m?m:h);}return m;}

इनपुट: शून्य समाप्त सरणी। उदाहरण के लिए {1,2,3,4,5,0}
आउटपुट: सबसे अच्छा परिणाम देता है

आप 8 बाइट्स ( 93 91 कुल) बचा सकते हैं अगर आप कभी पैसा नहीं खोना चाहते हैं:

int i,j,m,h;int f(int*a){for(;a[i];i++){for(j=i+1;a[j];h=a[j++]-a[i],m=h<m?m:h);}return m;}

Answer 16

आर, 58 44 बाइट्स

max(unlist(sapply(seq(y<-scan()),diff,x=y)))

ungolfed

y=scan()                #input
s=1:length(y)           #sequence of same length from 1
l = sapply(s,diff,x=y)  #applies the function diff to each 'lag' in sequence s
                        #and differencing on y
max(unlist(l))          #reforms as vector and finds maximum

संपादित करें: बदल समारोह। नीचे मूल।

f=function(x)max(max(x[-1]-x[1]),if(length(x)-2)f(x[-1]))

या, यदि आप चेतावनी संदेशों के एक समूह के साथ रखने के लिए तैयार हैं, तो लंबाई के बाद -2 से छुटकारा पाएं, 56 बाइट्स के लिए।

f=function(x)max(max(x[-1]-x[1]),if(length(x))f(x[-1]))

और अगर आपको लगता है कि ट्रेडिंग नहीं हो रही है और पैसे कम हो रहे हैं तो यही संभावना है कि आप 52 तक नीचे जा सकते हैं

f=function(x)max(max(x-x[1]),if(length(x))f(x[-1]))

Comments

f=जरूरत नहीं है।

— NoOneIsHere 21

@NoOneIsHere पुनरावृत्ति इसके बिना काम नहीं करेगा। मैं रिकॉल का उपयोग कर सकता था, लेकिन यह मेरे खोए हुए की तुलना में अधिक अक्षर उठाता है।

— user5957401

मुझे माफ करें। मुझे हमेशा याद आती है।

— NoOneIsHere