Một tập lệnh Stack Exchange xác định năm bình luận về câu hỏi hoặc câu trả lời ban đầu được nhìn thấy trên trang chính của các trang web thông qua số lượng upvote trên chúng; năm bình luận có số phiếu bầu cao nhất được hiển thị. Nhiệm vụ của bạn là tái tạo hành vi này.

Viết chương trình hoặc hàm đầy đủ lấy đầu vào thông qua STDIN, đối số dòng lệnh hoặc đối số hàm và in hoặc trả về năm điểm nhận xét hàng đầu. Đầu vào sẽ là một mảng các số nguyên biểu thị số lượng upvote trên các bình luận của một số bài đăng. Chẳng hạn, một đầu vào của

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

có nghĩa là bình luận đầu tiên không có phiếu bầu, bình luận thứ hai có hai phiếu, bình luận thứ ba có năm, bình luận thứ tư có bốn, v.v ... Thứ tự của điểm bình luận nên giữ nguyên trong đầu ra.

Nếu đầu vào chứa năm hoặc ít hơn điểm nhận xét, thì đầu ra sẽ không chứa gì nhiều hơn điểm số được đưa ra. Nếu hai hoặc nhiều điểm nhận xét giống nhau, điểm số đầu tiên sẽ được hiển thị. Bạn có thể giả định rằng mảng đầu vào sẽ chứa ít nhất một điểm nhận xét.

Các số trong đầu ra phải được phân biệt dễ dàng (vì vậy 02541 cho trường hợp 1 không hợp lệ). Mặt khác, không có hạn chế về định dạng đầu ra; các số có thể được phân tách bằng dấu cách hoặc dòng mới hoặc chúng có thể ở định dạng danh sách, v.v.

Các trường hợp thử nghiệm:

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

Ví dụ cuối cùng được lấy từ câu hỏi Stack Overflow này .

Nếu có thể, vui lòng cung cấp một liên kết trong bài đăng của bạn, nơi bài nộp của bạn có thể được chạy trực tuyến.

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng. Chúc may mắn!

Thạch , 6 byte

NỤḣ5Ṣị

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc .

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

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 byte

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

Kiểm tra nó trên Ideone .

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

list.removexóa lần xuất hiện đầu tiên nếu đối số của nó khỏi danh sách đã chỉ định. Bằng cách đảo ngược danh sách x , về cơ bản chúng tôi đạt được rằng nó sẽ loại bỏ sự xuất hiện cuối cùng .

Do đó, việc tiếp tục xóa bình luận với số lượng upvote tối thiểu cho đến khi đạt được danh sách không quá năm bình luận. Sau đó, chúng tôi đảo ngược danh sách một lần nữa để khôi phục lại thứ tự ban đầu.

Bình thường, 11 byte

_.-_Q<SQ_5

Chúng tôi tính toán giao điểm nhiều mặt của đầu vào ( Q) với năm phần tử lớn nhất theo Q(theo thứ tự chúng xuất hiện Q), sau đó lấy năm đầu tiên trong số đó.

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

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

MATL , 16 byte

tn4>?t_FT#S5:)S)

Điều này sử dụng bản phát hành hiện tại (10.2.1) , sớm hơn thử thách này.

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

Giải trình

          % 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 byte

Tắt 3 byte cảm ơn @ user81655. Tắt 1 byte cảm ơn @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>')

Trăn 3, 76

Đã lưu 9 byte nhờ Kevin nhắc nhở tôi rằng tôi có thể lạm dụng nếu các câu lệnh trong danh sách comp.

Đã lưu 5 byte nhờ DSM.

Giải pháp khá đơn giản ngay bây giờ. Lấy 5 điểm số cao nhất và sau đó phân tích thông qua danh sách thêm chúng vào kết quả khi chúng ta tìm thấy chúng.

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

Dưới đây là các trường hợp thử nghiệm của tôi nếu bất cứ ai muốn chúng:

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 byte

Mã số:

E[Dg6‹#Rß\R

Giải trình:

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

Sử dụng mã hóa CP-1252.

CJam, 16 byte

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

Một khối không tên (hàm) nhận một mảng và trả về một mảng.

Bộ thử nghiệm.

Giải trình

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.

Tiện ích Bash + GNU, 36

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

I / O được định dạng dưới dạng danh sách được phân tách bằng dòng mới thông qua STDIN / STDOUT.

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

Python, 68 byte

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

Ví dụ chạy.

Một cục tích hợp. Tôi nghĩ cách tốt nhất để giải thích là chạy qua một ví dụ.

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

enumeratebiến danh sách thành các cặp chỉ số / giá trị (về mặt kỹ thuật là một enumerateđối tượng).

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

Các cặp được sắp xếp theo giá trị lớn nhất trước tiên, giữ thứ tự hiện tại của chỉ số cho các mối quan hệ. Điều này đặt ở phía trước các bình luận có điểm cao nhất, được chia sẻ bởi bài viết trước đó. Sau đó, 5 ý kiến ​​tốt nhất như vậy được thực hiện.

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

Đặt năm bình luận hàng đầu trở lại theo thứ tự đăng, và sau đó loại bỏ các chỉ số, chỉ giữ lại điểm số.

PowerShell v4, 120 97 byte

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

Thử nghiệm xung quanh, tôi tìm thấy một cách tiếp cận thay thế đánh vào một số byte bổ sung. Tuy nhiên, dường như nó dành riêng cho PowerShell v4 và cách phiên bản đó xử lý việc sắp xếp một hashtable - theo mặc định, trong v4, nếu nhiều Giá trị có cùng một giá trị, thì nó sẽ lấy một khóa có Khóa "thấp hơn", nhưng bạn không được đảm bảo rằng trong v3 hoặc sớm hơn, ngay cả khi sử dụng từ khóa được đặt hàng trong v3. Tôi chưa hoàn toàn xem xét điều này với PowerShell v5 để nói nếu hành vi đó tiếp tục.

Phiên bản chỉ có v4 này nhận đầu vào là $a, sau đó tạo một hashtable trống mới $b. Chúng tôi lặp qua tất cả các yếu tố của đầu vào $a|%{...}và mỗi lần lặp thêm một cặp khóa / giá trị vào $b(được thực hiện bằng cách tăng trước một biến của trình trợ giúp $dlàm khóa cho mỗi lần lặp). Sau đó, chúng tôi sort $bdựa vào Value, sau đó selectlà -last 5, sau đó sortbằng Name(tức là khóa) và cuối cùng chỉ xuất ra .Values của hàm băm kết quả.

Nếu nhập ít hơn 5 phần tử, nó sẽ chỉ sắp xếp theo giá trị, chọn năm phần tử cuối cùng (nghĩa là tất cả chúng), sắp xếp lại trên khóa và đầu ra.

Cũ hơn, 120 byte, hoạt động trong các phiên bản trước

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

Thuật toán tương tự như câu trả lời của Morgan Thrapp , rõ ràng là một dấu hiệu cho thấy những bộ óc vĩ đại nghĩ giống nhau. :)

Lấy đầu vào, kiểm tra xem số lượng vật phẩm ít hơn hoặc bằng 5 và nếu đầu ra đầu vào và thoát. Mặt khác, chúng ta tạo một ArrayList $b(với [System.Collections.ArrayList]dàn diễn viên có chiều dài cắt cổ ) của năm yếu tố hàng đầu của $a. Sau đó, chúng tôi lặp đi lặp lại $avà cho từng phần tử nếu $bchúng tôi xuất nó và sau đó xóa nó khỏi $b(và đây là lý do tại sao chúng tôi cần sử dụng ArrayList, vì loại bỏ các phần tử khỏi Mảng không phải là một tính năng được hỗ trợ trong PowerShell, vì chúng đã được sửa chữa về mặt kỹ thuật kích thước).

Yêu cầu v3 hoặc lớn hơn cho -intoán tử. Để có câu trả lời hoạt động trong các phiên bản trước, hãy trao đổi $_-in$bvới $b-contains$_tổng số 126 byte .

Haskell, 62 byte

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

Ví dụ sử dụng: 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].

Cách thức hoạt động: tăng từng phần tử với chỉ mục của nó, sắp xếp giảm dần, lấy 5 phần tử đầu tiên, sắp xếp theo chỉ mục và xóa chỉ mục.

PHP 5, 107 102

Đã lưu 5 byte nhờ @WashingtonGuedes

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

Ung dung

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

Thử nó.

Ruby, 82 87 89 byte

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

để gọi: ruby test.rb [1,2,2,3,4,5]

gửi ban đầu - 56 byte nhưng không thành công trong các trường hợp thử nghiệm nhất định & không hỗ trợ $ stdin và $ stdout

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

Giải trình

$><<               # 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 byte

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

Mã xác nhận & mã thử nghiệm:

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

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

Đầu ra:

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

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

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

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

Nhận xét c ₁ có quyền ưu tiên cao hơn nhận xét c ₂ iff một trong những điều sau đây là đúng:

• c ₁ có nhiều upvote hơn c ₂ .
• c ₁ và c ₂ có cùng số lượng upvote, nhưng c ₁ đã được đăng trước đó.

Điều này xác định tổng thứ tự của các bình luận, và nhiệm vụ trong tay là tìm ra năm bình luận có độ ưu tiên cao nhất.

Thay vì sắp xếp các bình luận theo mức độ ưu tiên (sẽ thay đổi thứ tự của chúng, đối với mỗi bình luận c , chúng tôi đếm các bình luận có mức độ ưu tiên lớn hơn hoặc bằng nhau. Chúng tôi giữ c nếu và chỉ khi số này là 5 hoặc ít hơn.

Để sắp xếp một phần các ý kiến ​​theo số lượng upvote, chúng tôi làm như sau. Đặt x là vectơ cột chứa tổng số phiếu. Sau đó x'transposes x - do đó tạo ra một vector hàng - và x.<x'tạo ra một ma trận Boolean so sánh từng phần tử của x với mỗi phần tử của x ^T .

Với x = [0, 2, 5, 4, 0, 1, 0] , điều này mang lại

<     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

Bằng cách tính tổng các hàng (thông qua sum(...,2)), chúng tôi đếm số lượng bình luận có nhiều lượt nâng cấp hơn so với nhận xét tại chỉ mục đó.

Đối với vectơ ví dụ, điều này mang lại

4
2
0
1
4
3
4

Tiếp theo, chúng tôi đếm số lượng bình luận với số lượng upvote bằng nhau đã được đăng sớm hơn bình luận đó. Chúng tôi đạt được điều này như sau.

Đầu tiên chúng ta xây dựng một bảng bình đẳng với x.==x', mà compraes các yếu tố của x với các phần tử của x ^T . Đối với vector ví dụ của chúng tôi, điều này mang lại:

=     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

Tiếp theo, chúng tôi sử dụng cumsumđể tính tổng tích lũy của từng cột của ma trận.

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

Đường chéo ( diag) chứa số lượng bình luận có số lượng upvote bằng nhau và xảy ra không muộn hơn bình luận tương ứng.

1
1
1
1
2
1
3

Bằng cách thêm hai vectơ hàng chúng tôi tạo ra, chúng tôi có được mức độ ưu tiên ( 1 là cao nhất) của các nhận xét.

5
3
1
2
6
4
7

Nhận xét có mức độ ưu tiên từ 1 đến 5 nên được hiển thị, vì vậy chúng tôi xác định các chỉ số của họ với find(....<6)và truy xuất các nhận xét tương ứng với x[...].

Python 3.5, 68 byte

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

Không phù hợp với câu trả lời Python 2 của tôi , nhưng chỉ dài hơn ba byte so với cổng của nó với Python 3 và tôi nghĩ nó đủ khác biệt để trở nên thú vị.

I / O ở dạng tuples. Thử nghiệm nó trên repl.it .