Bir Yığın Değişimi betiği, sorular veya cevaplar hakkında hangi beş yorumun başlangıçta sitelerin ana sayfasında göründüğünü, bunlara verilen oy sayısıyla belirler; en çok oy alan beş yorum görüntülenir. Görevin bu davranışı yeniden yaratmak.

STDIN, komut satırı argümanları veya fonksiyon argümanları üzerinden girdi alarak tam bir program veya işlev yazın ve ilk beş yorum puanını yazdırır veya döndürür. Giriş, bazı gönderilerin yorumlarını içeren oy sayısını gösteren bir tam sayı dizisi olacaktır. Örneğin, bir giriş

0, 2, 5, 4, 0, 1, 0

ilk yorumun hiçbir oyu olmadığı, ikincinin iki oyu, üçüncüsü beş, dördüncüsü dört, vb. anlamına gelir. Yorum puanlarının sırası çıktıda aynı kalmalıdır.

Girdi beş veya daha az yorum puanı içeriyorsa, çıktı verilenlerden daha fazla bir şey içermemelidir. İki veya daha fazla yorum puanı aynıysa, ilk puan (lar) gösterilmelidir. Giriş dizisinin en az bir yorum puanı içereceğini varsayabilirsiniz.

Çıktıdaki sayılar kolayca ayırt edilmelidir (öyleyse 1 durumu için 02541 geçersiz). Aksi takdirde çıktı biçiminde herhangi bir kısıtlama yoktur; sayılar boşluk veya yeni satırla ayrılabilir veya liste biçiminde olabilir.

Test durumları:

[0, 2, 5, 4, 0, 1, 0] -> [0, 2, 5, 4, 1]
[2, 1, 1, 5, 3, 6] -> [2, 1, 5, 3, 6]
[0, 4, 5] -> [0, 4, 5]
[1, 1, 5, 1, 1, 5] -> [1, 1, 5, 1, 5]
[0, 2, 0, 0, 0, 0, 0, 0] -> [0, 2, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 0] -> [0, 0, 0, 0, 1]
[5, 4, 2, 1, 0, 8, 7, 4, 6, 1, 0, 7] -> [5, 8, 7, 6, 7]
[6, 3, 2, 0, 69, 22, 0, 37, 0, 2, 1, 0, 0, 0, 5, 0, 1, 2, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 2] -> [6, 69, 22, 37, 5]

Son örnek bu Yığın Taşması sorusundan alınmıştır .

Mümkünse, lütfen gönderiminizde çevrimiçi gönderim yapabileceğiniz bir bağlantı sağlayın.

Bu kod golf, yani bayt cinsinden en kısa kod kazanır. İyi şanslar!

Jöle , 6 bayt

NỤḣ5Ṣị

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

Nasıl çalışır

NỤḣ5Ṣị    Main link. Input: A (list)

N         Negate (multiply by -1) all elements of A.
 Ụ        Grade the result up.
          This consists in sorting the indices of A by their negated values.
          The first n indices will correspond to the n highest vote counts,
          tie-broken by order of appearance.
  ḣ5      Discard all but the first five items.
    Ṣ     Sort those indices.
          This is to preserve the comments' natural order.
     ị    Retrieve the elements of A at those indices.

Python 2, 58 bayt

x=input()[::-1]
while x[5:]:x.remove(min(x))
print x[::-1]

İdeone üzerinde test et .

Nasıl çalışır

list.removeBelirtilen listeden argümanı varsa ilk oluşumu kaldırır. X listesini tersine çevirerek, esasen bunun yerine son oluşumu sildiğini görüyoruz .

Bu nedenle, en fazla beş oyla bir listeye ulaşılıncaya kadar yorumu en az oy ile kaldırmaya devam etmek yeterlidir. Ardından, orijinal siparişi geri yüklemek için listeyi bir kez daha tersine çeviririz.

Pyth, 11 bayt

_.-_Q<SQ_5

Girişin ( Q) çoklu kesişimini Q(içinde göründükleri sırayla Q) en büyük beş öğeyle hesaplar , ardından ilk beşini alırız.

_ .-           Reverse of multiset difference
     _ Q       of reversed Q
     <         with all but last 5 elements of sorted Q
       S Q                   
       _ 5

Burada dene .

MATL , 16 bayt

tn4>?t_FT#S5:)S)

Bu, bu zorluktan daha önceki olan geçerli sürümü (10.2.1) kullanır .

Çevrimiçi deneyin!

açıklama

          % implicitly get input
t         % duplicate
n         % number of elements
4>?       % if greater than 4...
  t       % duplicate
  _       % unary minus (so that sorting will correspond to descending order)
  FT#S    % sort. Produce the indices of the sorting, not the sorted values
  5:)     % get first 5 indices
  S       % sort those indices, so that they correspond to original order in the input
  )       % index the input with those 5 indices
          % implicitly end if
          % implicitly display

JavaScript, 74 65 62 61 bayt

3 byte kapalı @ user81655. 1 bayt kapalı teşekkürler @ apsillers.

f=a=>5 in a?f(a.splice(a.lastIndexOf(Math.min(...a)),1)&&a):a

f=a=>5 in a?f(a.splice(a.lastIndexOf(Math.min(...a)),1)&&a):a

document.write('<pre>' +
  '[0, 2, 5, 4, 0, 1, 0] -> ' + f([0, 2, 5, 4, 0, 1, 0]) + '<br>' +
  '[2, 1, 1, 5, 3, 6] -> ' + f([2, 1, 1, 5, 3, 6]) + '<br>' +
  '[0, 4, 5] -> ' + f([0, 4, 5]) + '<br>' +
  '[1, 1, 5, 1, 1, 5] -> ' + f([1, 1, 5, 1, 1, 5]) + '<br>' +
  '[0, 2, 0, 0, 0, 0, 0, 0] -> ' + f([0, 2, 0, 0, 0, 0, 0, 0]) + '<br>' +
  '[0, 0, 0, 0, 1, 0, 0, 0, 0] -> ' + f([0, 0, 0, 0, 1, 0, 0, 0, 0]) + '<br>' +
  '[5, 4, 2, 1, 0, 8, 7, 4, 6, 1, 0, 7] -> ' + f([5, 4, 2, 1, 0, 8, 7, 4, 6, 1, 0, 7]) + '<br>' +
  '[6, 3, 2, 0, 69, 22, 0, 37, 0, 2, 1, 0, 0, 0, 5, 0, 1, 2, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 2] -> ' + f([6, 3, 2, 0, 69, 22, 0, 37, 0, 2, 1, 0, 0, 0, 5, 0, 1, 2, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 2]) + '<br>' +
'</pre>')

Python 3, 76

Kevin sayesinde 9 bayt kurtardı, hatırladığım kadarıyla kötüye kullanabileceğimi hatırlatan bir liste halinde.

DSM sayesinde 5 bayt kaydedildi.

Şu anda oldukça basit bir çözüm. İlk 5 puanı al ve daha sonra bulduğumuz sonuçlara ekleyerek listeden ayrıl.

def f(x):y=sorted(x)[-5:];return[z for z in x if z in y and not y.remove(z)]

Birisi onları isterse İşte benim test davaları:

assert f([0, 2, 5, 4, 0, 1, 0]) == [0, 2, 5, 4, 1]
assert f([2, 1, 1, 5, 3, 6]) == [2, 1, 5, 3, 6]
assert f([0, 4, 5]) == [0, 4, 5]
assert f([0, 2, 0, 0, 0, 0, 0, 0]) == [0, 2, 0, 0, 0]
assert f([0, 0, 0, 0, 1, 0, 0, 0, 0]) == [0, 0, 0, 0, 1]
assert f([5, 4, 2, 1, 0, 8, 7, 4, 6, 1, 0, 7]) == [5, 8, 7, 6, 7]
assert f([6, 3, 2, 0, 69, 22, 0, 37, 0, 2, 1, 0, 0, 0, 5, 0, 1, 2, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 2]) == [6, 69, 22, 37, 5]

05AB1E , 12 11 bayt

Kod:

E[Dg6‹#Rß\R

Açıklama:

E           # Evaluate input
 [          # Infinite loop
  D         # Duplicate top of the stack
   g        # Get the length
    6‹#     # If smaller than 6, break
       R    # Reverse top of the stack
        ß\  # Extract the smallest item and remove it
          R # Reverse top of the stack
            # Implicit, print the processed array

CP-1252 kodlamasını kullanır.

CJam, 16 bayt

{ee{1=~}$5<$1f=}

Bir dizi alan ve bir dizi döndüren adsız bir blok (işlev).

Test odası.

açıklama

ee   e# Enumerate the array, pairing each number with its index.
{    e# Sort by...
 1=  e#   The original value of each element.
 ~   e#   Bitwise NOT to sort from largest to smallest.
}$   e# This sort is stable, so the order tied elements is maintained.
5<   e# Discard all but the first five.
$    e# Sort again, this time by indices to recover original order.
1f=  e# Select the values, discarding the indices.

Bash + GNU yardımcı programları, 36

nl|sort -nrk2|sed 5q|sort -n|cut -f2

G / Ç, STDIN / STDOUT aracılığıyla yeni satırlarla ayrılmış listeler olarak biçimlendirildi.

Çevrimiçi deneyin.

Python, 68 bayt

lambda l,S=sorted:zip(*S(S(enumerate(l),key=lambda(i,x):-x)[:5]))[1]

Örnek çalışma

Yerleşik bir yığın. Açıklamanın en iyi yolu, bir örnek üzerinden geçmektir.

>> l
[5, 4, 2, 1, 0, 8, 7, 4, 6, 1, 0, 7]
>> enumerate(l)
[(0, 5), (1, 4), (2, 2), (3, 1), (4, 0), (5, 8), (6, 7), (7, 4), (8, 6), (9, 1), (10, 0), (11, 7)]

enumerateListeyi indeks / değer çiftlerine dönüştürür (teknik olarak bir enumeratenesne).

>> sorted(enumerate(l),key=lambda(i,x):-x)
[(5, 8), (6, 7), (11, 7), (8, 6), (0, 5), (1, 4), (7, 4), (2, 2), (3, 1), (9, 1), (4, 0), (10, 0)]
>> sorted(enumerate(l),key=lambda(i,x):-x)[:5]
[(5, 8), (6, 7), (11, 7), (8, 6), (0, 5)]

Çiftler ilk önce en büyük değere göre sıralanır ve bağlar için geçerli dizin sırasını korur. Bu, en yüksek puan alan yorumları öne koyar, önceki yazı tarafından tırtıklı. Ardından en iyi 5 yorum yapıldı.

>> sorted(_)
   [(0, 5), (5, 8), (6, 7), (8, 6), (11, 7)]
>> zip(*sorted(_))[1]
   (5, 8, 7, 6, 7)

İlk beş yorumu tekrar kayıt sırasına koyun ve ardından sadece puanları koruyarak endeksleri kaldırın.

PowerShell v4, 120 97 bayt

param($a)$b=@{};$a|%{$b.Add(++$d,$_)};($b.GetEnumerator()|sort Value|select -l 5|sort Name).Value

Etrafında denemeler yaparken, bazı ek baytları fırlatan alternatif bir yaklaşım buldum. Bununla birlikte, PowerShell v4'e ve bu sürümün bir karma tabloyu nasıl işlediğine özgü gibi görünüyor - varsayılan olarak, v4'te birden fazla Değer aynı değere sahipse, "düşük" Anahtarlı olanı alır, ancak v3'te sipariş edilen anahtar kelimeyi kullanırken bile, v3 veya önceki sürümlerde garanti edilmez . Davranışa devam edip etmediğini söylemek için bunu PowerShell v5'e karşı tam olarak incelemedim.

Bu sadece v4 sürümü şu şekilde girdi alır $a, sonra yeni bir boş karma tablo oluşturur $b. Girişin tüm öğelerinde döngü oluştururuz $a|%{...}ve her yineleme, bir anahtar / değer çifti ekler $b( $dher yinelemenin anahtarı olarak bir yardımcı değişken önceden arttırılarak yapılır ). Sonra sort $bgöre Value, daha sonra ast sonra, tarafından (diğer bir deyişle, tuş), ve son olarak yalnızca çıkış elde edilen karma s.select-l5sortName.Value

5'ten az eleman girilirse, sadece değere göre sıralanır, son beşi (yani hepsini) seçer, anahtarı tekrar sıralar ve çıktısını alır.

Daha eski, 120 bayt, önceki sürümlerde çalışır

param($a)if($a.Count-le5){$a;exit}[System.Collections.ArrayList]$b=($a|sort)[-5..-1];$a|%{if($_-in$b){$_;$b.Remove($_)}}

Morgan Thrapp en aynı algoritma cevap görünüşte harika beyinler aynı düşünmek olduğunun bir göstergesidir. :)

Girdiyi alır, madde sayısının 5'e eşit veya daha az olup olmadığını kontrol eder ve eğer öyleyse girdiyi çıkarır ve çıkar. Aksi takdirde, ilk beş öğenin bir ArrayList'ini $b(fena halde uzun [System.Collections.ArrayList]dökümüyle) yaratırız $a. Daha sonra çıktılarsak $ave her bir öğe için yineleniriz ve sonra çıkarırız (ve işten çıkarırız (ve işte ArrayList'i kullanmamız gerekir, çünkü Array öğelerini PowerShell'de desteklenen bir özellik değildir, çünkü teknik olarak sabitlenirler) boyut).$b$b

-inOperatör için v3 veya üstü gerekir . , Önceki sürümlerinde takas çalışan bir yanıt için $_-in$biçin $b-contains$_olmak üzere toplam 126 bayt .

Haskell, 62 bayt

import Data.List
map snd.sort.take 5.sortOn((0-).snd).zip[0..] 

Kullanım örneği: map snd.sort.take 5.sortOn((0-).snd).zip[0..] $ [5, 4, 2, 1, 0, 8, 7, 4, 6, 1, 0, 7]-> [5,8,7,6,7].

Nasıl çalışır: Her öğeyi dizini ile artırın, azalan sıralama, ilk 5 öğeyi alın, dizine göre sıralayın ve dizini kaldırın.

PHP 5, 107 102

@WashingtonGuedes sayesinde 5 bayt kaydedildi

function p($s){uasort($s,function($a,$b){return$a<=$b;});$t=array_slice($s,0,5,1);ksort($t);return$t;}

Ungolfed

function p($scores) {
    // sort the array from high to low,
    // keeping lower array keys on top of higher
    // array keys
    uasort($scores,function($a, $b){return $a <= $b;});
    // take the top 5
    $top_five = array_slice($scores,0,5,1);
    // sort by the keys
    ksort($top_five);
    return $top_five;
}

Dene.

Ruby, 82 87 89 bayt

$><<eval($*[0]).map.with_index{|x,i|[i,x]}.sort_by{|x|-x[1]}[0,5].sort.map(&:last)

aramak: ruby test.rb [1,2,2,3,4,5]

Orijinal başvuru - 56 bayt ancak belirli test durumlarında başarısız oluyor ve $ stdin ve $ stdout'u desteklemiyor

_.reduce([]){|a,x|a+=_.sort.reverse[0..4]&[x]if !a[4];a}

açıklama

$><<               # print to stdout
eval($*[0])        # evals the passed in array in stdin ex: [1,2,3,4]
.map.with_index    # returns an enumerator with indices
{|x,i|[i,x]}       # maps [index,value]
.sort_by{|x|-x[1]} # reverse sorts by the value
[0,5]              # selects the first 5 values
.sort              # sorts item by index (to find the place)
.map{|x|x[1]}      # returns just the values

Java 7, 155 bayt

import java.util.*;List c(int[]f){LinkedList c=new LinkedList();for(int i:f)c.add(i);while(c.size()>5)c.removeLastOccurrence(Collections.min(c));return c;}

Ungolfed ve test kodu:

Burada dene.

import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

class Main{
    static List c(int[] f){
        LinkedList c = new LinkedList();
        for (int i : f){
            c.add(i);
        }
        while(c.size() > 5){
            c.removeLastOccurrence(Collections.min(c));
        }
        return c;
    }

    public static void main(String[] a){
        System.out.println(Arrays.toString(c(new int[]{ 0, 2, 5, 4, 0, 1, 0 }).toArray()));
        System.out.println(Arrays.toString(c(new int[]{ 2, 1, 1, 5, 3, 6 }).toArray()));
        System.out.println(Arrays.toString(c(new int[]{ 0, 4, 5 }).toArray()));
        System.out.println(Arrays.toString(c(new int[]{ 1, 1, 5, 1, 1, 5 }).toArray()));
        System.out.println(Arrays.toString(c(new int[]{ 0, 2, 0, 0, 0, 0, 0, 0 }).toArray()));
        System.out.println(Arrays.toString(c(new int[]{ 0, 0, 0, 0, 1, 0, 0, 0, 0 }).toArray()));
        System.out.println(Arrays.toString(c(new int[]{ 6, 3, 2, 0, 69, 22, 0, 37, 0, 2, 1, 0, 0, 0, 5, 0, 1, 2, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 2 }).toArray()));
    }
}

Çıktı:

[0, 2, 5, 4, 1]
[2, 1, 5, 3, 6]
[0, 4, 5]
[1, 1, 5, 1, 5]
[0, 2, 0, 0, 0]
[0, 0, 0, 0, 1]
[6, 69, 22, 37, 5]

Julia, 48 bayt

!x=x[find(sum(x.<x',2)+diag(cumsum(x.==x')).<6)]

Çevrimiçi deneyin!

Nasıl çalışır

Yorum c ₁ açıklama daha yüksek önceliğe sahiptir C ₂ şu geçerlidir birine böylece:

• c ₁ , c ₂ den daha fazla oy hakkına sahiptir .
• c ₁ ve c ₂ aynı miktarda oy hakkına sahiptir, ancak c ₁ daha önce yayınlanmıştır.

Bu, yorumların toplam sıralamasını tanımlar ve eldeki görev, en yüksek önceliğe sahip beş yorumu bulmaktır.

Yorumları öncelik sırasına göre sıralamak yerine (sırasını değiştirir, her yorum için c , daha büyük veya eşit önceliğe sahip olan yorumları sayarız. C ancak bu sayı 5 veya daha az ise c tutarız .

Yorumları kısmen oy sayısına göre sıralamak için aşağıdakileri yaparız. X oy sayısını içeren sütun vektörü olsun . Sonra x'ix' transpoze eder - böylece bir satır vektörü yaratır ve x'in her bir öğesini x ^T'nin her bir elemanı ile karşılaştıran bir Boolean matrisi oluşturur .x.<x'

İçin , x = [0, 2, 5, 4, 0, 1, 0] , bu verir

<     0      2      5      4      0      1      0
0 false   true   true   true  false   true  false
2 false  false   true   true  false  false  false
5 false  false  false  false  false  false  false
4 false  false   true  false  false  false  false
0 false   true   true   true  false   true  false
1 false   true   true   true  false  false  false
0 false   true   true   true  false   true  false

Satırlar arasında (yoluyla sum(...,2)) toplayarak , bu dizindeki yorumdan kesinlikle daha fazla oy alan yorumların sayısını sayarız.

Örnek vektör için bu

4
2
0
1
4
3
4

Daha sonra, bu yorumdan daha önce gönderilen eşit oy sayısına sahip yorumların sayısını sayarız. Bunu şu şekilde başardık.

Öncelikle x.==x', x öğelerini x ^T öğeleriyle karşılaştıran bir eşitlik tablosu oluşturuyoruz . Örnek vektörümüz için bu şunları verir:

=     0      2      5      4      0      1      0
0  true  false  false  false   true  false   true
2 false   true  false  false  false  false  false
5 false  false   true  false  false  false  false
4 false  false  false   true  false  false  false
0  true  false  false  false   true  false   true
1 false  false  false  false  false   true  false
0  true  false  false  false   true  false   true

Daha cumsumsonra, matrisin her bir sütununun kümülatif toplamlarını hesaplamak için kullanıyoruz .

1  0  0  0  1  0  1
1  1  0  0  1  0  1
1  1  1  0  1  0  1
1  1  1  1  1  0  1
2  1  1  1  2  0  2
2  1  1  1  2  1  2
3  1  1  1  3  1  3

( diag) Köşegen ( ) eşit miktarda oy sayısına sahip olan ve karşılık gelen yorumdan en geç olmayan yorumların sayısını tutar.

1
1
1
1
2
1
3

Ürettiğimiz iki satır vektörünü ekleyerek, yorumların önceliklerini ( 1 en yüksektir) alırız .

5
3
1
2
6
4
7

Öncelikleri 1 ile 5 arasında olan yorumlar görüntülenmelidir, bu nedenle indekslerini ile belirler find(....<6)ve ilgili yorumları alırız x[...].

Python 3.5, 68 bayt

f=lambda x,*h:x and x[:sum(t>x[0]for t in x+h)<5]+f(x[1:],*h,x[0]+1)

Hiçbir için maç benim Python 2 cevap , ancak daha uzun Python 3 için liman daha sadece üç byte ve onun 'için farklı yeterince ilginç düşünüyorum.

G / Ç, tüller şeklindedir. Repl.it üzerinde test edin .