Stok zaman makinesi

tomorrowStocksNASDAQ'daki en sevdiğiniz işletmeden hisse senedi fiyatlarını içeren bir veri kümesine erişim elde ettiniz . Bu veri kümesi açılıştan birkaç dakika sonra endekslenmiş bir konteynerdir. Her endeks o dönemde hisse senedinin fiyatını içerir.

// 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

Çıktı

Göreviniz mümkün olan en iyi sonucu belirlemektir 1 purchaseve 1 saleiçinde 1 stockverilen veri kümesinden.

Sorunlar

• Tam olarak 1 hisse senedi alıp satmalısınız.
• Sen satın olmayabilir ve aynı zaman diliminde satmak.
• Satmadan önce almalısın .

Test verisi

[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

Bu bir kod golfü ; En kısa cevabı en sevdiğin dile gönder!

05AB1E , 4 bayt

FryAmTheEggman'ın yaklaşımını kullanarak . Kod:

¥ŒOà

Açıklama:

¥     # 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 kodlamasını kullanır . Çevrimiçi deneyin! .

Python 2,46 bayt

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

İdeone üzerinde test et .

Nasıl çalışır

Bu Python 2'nin güzel sapık karışık tip karşılaştırmalarından yararlanan özyinelemeli bir yaklaşımdır.

Mümkün olan en iyi sonuç, listenin maksimum değerinin ilk elemanı kaldırılmış ve ilk eleman ya da birinci elemanı içermeyen başka bir farktır.

İlk öğeyi x.pop(0)(onu x'ten kalıcı olarak kaldıran) ile çıkardıktan sonra hesaplıyoruz x.pop(0)-max(x). Bu farkın "yanlış" işaretine sahip olduğuna dikkat edin.

Güncellenen x listesi hala en az iki öğe içeriyorsa, x[1:]boş olmayan bir liste oluşturur ve andbunu olarak hesaplanan özyinelemeli bir çağrının negatifiyle değiştirir -f(x). Devam etmek için çok az öğe olduğunda, x[1:]and-f(x)boş bir listeye değerlendirilir.

Maksimum sonucu seçmek için , özyinelemeli aramanın (veya ) farkının minimumunu ve negatifini alırız []. Tüm tamsayılar kesinlikle olduğundan daha az olduğu için [], mineğer doğru olan varsa, basitçe sol argümanını döndürecektir [].

Son olarak, unary eksi -hesaplanan sonucun işaretini düzeltir.

MATL , 7 bayt

2XN!dX>

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

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

Jöle , 5 bayt

Œcḅ-Ṁ

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

Œ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.

Pyth, 9

eSsM.:-Vt

Burada deneyin veya bir Test Suite çalıştırın .

Her eleman arasındaki ardışık farkları bulur, daha sonra bu dizinin her alt dizesini bulur. Son olarak, elemanları toplayın ve maksimal olanı döndürün.

Açıklama:

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

Bu algoritmanın işe yaradığı konusunda tamamen sezgisel olmadığı söylendi. Umarım bu örnek, bu algoritmanın neden çalıştığını gösterecektir:

[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]

Pyth, 9

_hS-M.cQ2

Yay pfns!

_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

PowerShell v2 +, 58 bayt

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

Girdi alır $n, her elemanı bir döngüye sokar |%{...}. Her yinelemede, giriş dizisinin sonuna kadar $nönceden arttırılmış ++$işekilde dilimleniriz , |sortbu, maksimali alır ve [-1]sonra geçerli öğeyi çıkarır $_. Daha sonra |sorttüm bu farkları ve tekrar maksimalleri alıyoruz [-1].

Ayrıntılı bir dizi dizini hatası atıyor, çünkü dizinin sonunu geçmeye çalışıyoruz. Ancak, STDERR varsayılan olarak göz ardı edildiğinden , umursamıyoruz.

JavaScript (ES6), 57 54 bayt

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

JavaScript'te dizinin kalanının maksimuma çıkarılması ve geçerli öğenin çıkarılması daha kolaydır. (Son eleman durumunda sonuç hala -Infinity olacaktır.) Düzenleme: @CharlieWynn sayesinde 3 bayt kaydedildi.

J, 21 bayt

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

Bir değer dizisini argüman olarak alır ve sonucu döndürür.

açıklama

[:>./@;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

Java, 141 bayt

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

Lambda bir ArrayList'i kabul eder ve bir Tamsayı döndürür.

Test durumlarıyla birlikte kodlanmamış kod:

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

Bildiğim kadarıyla, Java'nın bir akışta dört gözle beklemenin bir yolu yok ve akışın üretildiği yöntemi işlemek garip sonuçlar veriyor. Böylece a.remove(0)bir haritanın içinde yapmak korkunç bir şekilde akışı keser.

VBA, 154

A1'den başlayarak sütun A'daki girdiyi alır, C1 ile çıkar. Seçilen A hücresindeki son hücre ile çalıştırılmalıdır. Excel'in VBA'daki terimler arasındaki boşlukları otomatik olarak eklediğini, aksi takdirde daha fazla golf oynayabileceğini unutmayın.

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

Java, 116

Başka bir java çözümü, bunu, akışların güzel görünebileceğini ancak golf oynamak için her zaman yararlı olmayacağını kanıtlamak için kullandım.

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

Bu çözümde iyileştirmeler için çok fazla alan var

Clojure, 99 bayt

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

Giriş listesini ilk sıraya, sonra ikinci sıraya böler ve böylelikle şöyle bir liste alırız:

[[[n1][n2 ... nk]][[n1 n2][n3 ... nk]]...[[n1...n(k-1)][nk]]]daha sonra her bir çift için, birinci elementin minimumunu, ikinci elementin maksimumundan çıkartır ve sonra onlardan maksimumunu bulur. Clojure's min maxherhangi bir sayıda argümandan ziyade sekans alıyorsa daha kısa olurdu .

Çevrimiçi görün: https://ideone.com/b2nllT

yakut, 52 bayt

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

olası satış fiyatlarını gösterir ve önceki karı bulmak için önceki bölümlere bakar. Sonra maksimum kar alır.

C, 101 99 Bayt

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

Giriş: boş sonlandırılmış dizi. Örneğin, {1,2,3,4,5,0}
Çıktı: en iyi sonucu döndürür

Hiç para kaybetmek istemiyorsanız 8 bayt ( toplam 93 91) tasarruf edebilirsiniz:

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

R, 58 44 bayt

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

EDIT: değiştirilen işlev. aşağıda orijinal.

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

veya bir sürü uyarı mesajı vermeye istekli iseniz, 56 bayt boyunca uzunluktan sonra -2'den kurtulun.

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

Tek ihtimal bu olduğunda işlem yapmak ve para kaybetmek istemiyorsanız, 52'ye düşebilirsiniz.

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