एक एसई पोस्ट पर शीर्ष पांच टिप्पणी स्कोर दिखाएं

Question

एक स्टैक एक्सचेंज स्क्रिप्ट यह निर्धारित करती है कि प्रश्नों या उत्तरों पर पाँच टिप्पणियाँ शुरू में साइटों के मुख्य पृष्ठ पर देखी जा सकती हैं; सबसे अधिक वोट वाली पांच टिप्पणियाँ प्रदर्शित की जाती हैं। आपका कार्य इस व्यवहार को फिर से बनाना है।

एसटीडीआईएन, कमांड-लाइन आर्ग्स, या फ़ंक्शन तर्क और प्रिंट के माध्यम से इनपुट लेने के लिए एक पूर्ण कार्यक्रम या फ़ंक्शन लिखें और शीर्ष टिप्पणी स्कोर लौटाते हैं। इनपुट एक पूर्णांक का एक सरणी होगा जो कुछ पोस्ट की टिप्पणियों पर उत्थान की संख्या का प्रतिनिधित्व करता है। उदाहरण के लिए, इनपुट

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

इसका मतलब है कि पहली टिप्पणी में कोई वोट नहीं है, दूसरे में दो वोट हैं, तीसरे में पांच हैं, चौथे में चार थे, आदि टिप्पणी स्कोर का क्रम आउटपुट में समान रहना चाहिए।

यदि इनपुट में पांच या कम टिप्पणी स्कोर हैं, तो आउटपुट में दिए गए से अधिक कुछ नहीं होना चाहिए। यदि दो या अधिक टिप्पणी स्कोर समान हैं, तो पहला स्कोर प्रदर्शित होना चाहिए। आप मान सकते हैं कि इनपुट सरणी में कम से कम एक टिप्पणी स्कोर होगा।

आउटपुट में संख्याओं को आसानी से प्रतिष्ठित किया जाना चाहिए (इसलिए केस 1 के लिए 02541 अमान्य है)। अन्यथा आउटपुट प्रारूप पर कोई प्रतिबंध नहीं हैं; स्थान या न्यूलाइन द्वारा संख्याओं को अलग किया जा सकता है, या वे सूची प्रारूप आदि में हो सकते हैं।

परीक्षण के मामलों:

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

आखिरी उदाहरण इस स्टैक ओवरफ्लो प्रश्न से लिया गया था ।

यदि संभव हो, तो कृपया अपनी पोस्ट में एक लिंक प्रदान करें जहां आपका सबमिशन ऑनलाइन चलाया जा सके।

यह कोड गोल्फ है, इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है। सौभाग्य!

Comments

क्या हमें आदेश बरकरार रखना चाहिए?

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ हां। जिस क्रम में पूर्णांक दिखाई देते हैं, उसे बदलना नहीं चाहिए।

— टीएनटी

Answer 1

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

NỤḣ5Ṣị

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

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

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.

Answer 2

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

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

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

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

list.removeनिर्दिष्ट सूची से इसका तर्क होने पर पहली घटना को हटा देता है। सूची x को उल्टा करके , हम अनिवार्य रूप से प्राप्त करते हैं कि यह अंतिम घटना को हटा देता है ।

इस प्रकार, यह टिप्पणी को हटाने के लिए पर्याप्त मात्रा में उठाव के साथ रखने के लिए पर्याप्त है जब तक कि पांच से अधिक टिप्पणियों की सूची न पहुंच जाए। बाद में, हम मूल क्रम को पुनर्स्थापित करने के लिए सूची को एक बार फिर से रिवर्स करते हैं।

Answer 3

अजगर, 11 बाइट्स

_.-_Q<SQ_5

हम इनपुट के मल्टीसेट चौराहे की गणना करते हैं ( Q) पांच सबसे बड़े तत्वों के साथ Q(जिस क्रम में वे दिखाई देते हैं Q), फिर उनमें से पहले पांच को लें।

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

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

Comments

<5SQके बराबर है <SQ_5, जो 1 बाइट बचाता है।

— पुरकाकूदरी

नहीं ।

— --१६

दिलचस्प। मुझे आश्चर्य है कि इसे क्यों लागू नहीं किया गया है b[:-a]... मुझे लगता है कि यह किसी बिंदु पर भी हो सकता है।

— पुरकाकूदरी

Answer 4

MATL , 16 बाइट्स

tn4>?t_FT#S5:)S)

यह वर्तमान रिलीज़ (10.2.1) का उपयोग करता है , जो इस चुनौती से पहले है।

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

व्याख्या

          % 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

Answer 5

जावास्क्रिप्ट, 74 65 62 61 बाइट्स

3 बाइट्स धन्यवाद @ user81655 1 बाइट थैंक्स ऑफ @ थिसलर्स।

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

Answer 6

पायथन 3, 76

सहेजे गए 9 बाइट्स केविन के लिए धन्यवाद मुझे याद दिलाता है कि अगर मैं एक सूची COMP में बयानों का दुरुपयोग कर सकता हूं।

सहेजे गए 5 बाइट्स DSM की बदौलत।

अभी बहुत सरल समाधान है। शीर्ष 5 स्कोर को पकड़ो और फिर सूची के माध्यम से पार्स करके उन्हें परिणाम में जोड़ दें जैसा कि हम उन्हें पाते हैं।

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

यहाँ मेरे परीक्षण के मामले हैं अगर कोई उन्हें चाहता है:

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]

Answer 7

05AB1E , 12 11 बाइट्स

कोड:

E[Dg6‹#Rß\R

स्पष्टीकरण:

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 एन्कोडिंग का उपयोग करता है।

Answer 8

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

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

एक अनाम ब्लॉक (फ़ंक्शन) जो एक सरणी लेता है और एक सरणी देता है।

परीक्षण सूट।

व्याख्या

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.

Answer 9

बैश + जीएनयू उपयोगिताओं, 36

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

I / O ने STDIN / STDOUT के माध्यम से नई-अलग-अलग सूचियों के रूप में स्वरूपित किया।

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

Answer 10

पायथन, 68 बाइट्स

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

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

बिल्ट-इन की एक गांठ। मुझे लगता है कि समझाने का सबसे अच्छा तरीका एक उदाहरण के माध्यम से चलना है।

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

enumerateसूची को सूचकांक / मूल्य जोड़े (तकनीकी रूप से एक enumerateवस्तु) में बदल देता है।

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

संबंधों के लिए सूचकांक के वर्तमान क्रम को ध्यान में रखते हुए, जोड़े को पहले सबसे बड़े मूल्य के आधार पर क्रमबद्ध किया जाता है। यह पहले से पोस्ट की गई टाईब्रेक के सामने सबसे ज्यादा रन बनाने वाली टिप्पणियों को सामने रखता है। फिर, ऐसी 5 सर्वश्रेष्ठ टिप्पणियाँ ली जाती हैं।

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

शीर्ष पांच टिप्पणियों को पोस्टिंग क्रम में वापस रखें, और फिर केवल अंक रखते हुए सूचकांकों को हटा दें।

Answer 11

PowerShell v4, 120 97 बाइट्स

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

चारों ओर प्रयोग करते हुए, मुझे एक वैकल्पिक दृष्टिकोण मिला जो कुछ अतिरिक्त बाइट्स को बंद कर देता है। हालाँकि, यह PowerShell v4 के लिए विशिष्ट प्रतीत होता है और कैसे यह संस्करण हैशटेबल की छँटाई को संभालता है - ऐसा लगता है, डिफ़ॉल्ट रूप से, कि v4 में यदि एकाधिक मानों का समान मान है, तो यह "कम" कुंजी के साथ लेता है, लेकिन आदेश का उपयोग करते समय आप v3 या उससे पहले की गारंटी नहीं देते हैं कीवर्ड । यदि व्यवहार जारी रहता है, तो मैंने PowerShell v5 के खिलाफ इसे पूरी तरह से रद्द नहीं किया है।

यह v4- केवल संस्करण इनपुट के रूप में लेता है $a, फिर एक नया खाली हैशटेबल बनाता है $b। हम इनपुट के सभी तत्वों के माध्यम से लूप करते हैं $a|%{...}और प्रत्येक पुनरावृत्ति एक कुंजी / मान युग्म को जोड़ते हैं $b( $dप्रत्येक पुनरावृत्ति के लिए कुंजी के रूप में एक सहायक चर को बढ़ाकर )। फिर हम sort $bके आधार पर Valueतो, ast , तो द्वारा (यानी, कुंजी), और अंत उत्पादन केवल परिणामी हैश के रों।select-l5sortName.Value

यदि 5 से कम तत्वों को दर्ज किया जाता है, तो यह केवल मूल्य पर छंटनी करेगा, अंतिम पांच (यानी, उनमें से सभी) का चयन करें, कुंजी पर फिर से छांटें, और आउटपुट।

---

पुराने 120 बाइट्स, पुराने संस्करणों में काम करते हैं

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

मॉर्गन थ्रप के जवाब के रूप में एक ही एल्गोरिदम , जो स्पष्ट रूप से एक संकेत है कि महान दिमाग एक जैसा सोचते हैं। :)

इनपुट लेता है, जाँचता है कि क्या वस्तुओं की संख्या कम-से-या-बराबर-से-5 है, और यदि ऐसा है तो इनपुट इनपुट और बाहर निकलता है। अन्यथा, हम शीर्ष पांच तत्वों में से एक ArrayList $b(अत्यधिक लम्बी [System.Collections.ArrayList]कास्ट के साथ) बनाते हैं $a। फिर हम $aप्रत्येक तत्व के लिए इटर्सेट करते हैं, अगर $bहम इसमें आउटपुट करते हैं और फिर इसे हटाते हैं $b(और यहां से हमें ArrayList का उपयोग करने की आवश्यकता है, क्योंकि Array से तत्वों को निकालना PowerShell में एक समर्थित सुविधा नहीं है, क्योंकि वे तकनीकी रूप से ठीक हैं आकार)।

-inऑपरेटर के लिए v3 या उससे अधिक की आवश्यकता होती है । एक जवाब है कि पिछले संस्करणों में काम करता है, स्वैप के लिए $_-in$bके लिए $b-contains$_के लिए कुल 126 बाइट्स ।

Answer 12

हास्केल, 62 बाइट्स

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

प्रयोग उदाहरण: 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]।

यह कैसे काम करता है: प्रत्येक तत्व को सूचकांक के साथ बढ़ाता है, अवरोही क्रमबद्ध करता है, पहले 5 तत्वों को लेता है, सूचकांक द्वारा क्रमबद्ध करता है और सूचकांक को हटाता है।

Answer 13

PHP 5, 107 102

@WashingtonGuedes के लिए 5 बाइट्स को सहेजा गया

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

कोशिश करो।

Comments

इसके लिए 1 1 5 1 1 5, आपका सबमिशन 1 5 1 1 5सही के बजाय आउटपुट उत्पन्न करता है 1 1 5 1 5।

— TNT

यह PHP 7.X के लिए अलग तरह से व्यवहार करता है, PHP संस्करण को 5.6 या उससे नीचे पर स्विच करें।

— संस्

समझे, संस्करण संख्या पर ध्यान नहीं दिया। :)

— टीएनटी

मैं या तो पहले नहीं था। मुझे यकीन नहीं है कि कोड के साथ-साथ किस संस्करण का उपयोग क्यों नहीं बचा है। मुझे भी यकीन नहीं है कि यह 7.X पर सही ढंग से काम क्यों नहीं करता है।

— संस्। त

@AshingtonGuedes रिक्त स्थान हटाने से मुझे 5 बाइट्स बचाए गए, लेकिन मैं कोई अनावश्यक अर्धविराम नहीं देख रहा हूं जो कोई त्रुटि नहीं करेगा?

— संस्। वंच

Answer 14

रूबी, 82 87 89 बाइट्स

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

बुलाना: ruby test.rb [1,2,2,3,4,5]

मूल प्रस्तुतिकरण - 56 बाइट्स लेकिन कुछ परीक्षण मामलों में विफल रहता है और $ स्टडिन और $ स्टडआउट का समर्थन नहीं करता है

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

व्याख्या

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

Comments

अच्छा कार्यक्रम है। हालांकि आपको ओपी से इसके बारे में पूछना पड़ सकता है। मुझे यकीन नहीं है कि इनपुट प्रारूप ठीक है।

— 21

@RikerW वास्तव में विफल रहता है जब अंतिम डुप्लिकेट में एक डुप्लिकेट टॉप # होता है, मैं इसे अब संशोधित कर रहा हूं

— जॉन

@RikerW अभी तय है, और यह स्टड का समर्थन करता है और स्टडआउट को लिखता है।

— जॉन

ठीक है। मुझे इनपुट विधि पसंद है। मैं इसके बारे में @TNT से पूछने के लिए कह रहा था।

— R

Answer 15

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

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 और परीक्षण-कोड:

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

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

आउटपुट:

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

Answer 16

जूलिया, 48 बाइट्स

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

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

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

टिप्पणी सी ₁ की टिप्पणी की तुलना में उच्च पूर्वता है सी ₂ यदि निम्नलिखित में से एक सच है:

• c ₁ में c ₂ से अधिक upvotes है ।
• c ₁ और c ₂ में एक ही राशि का अपवोट है, लेकिन c ₁ को पहले पोस्ट किया गया था।

यह टिप्पणियों के कुल क्रम को परिभाषित करता है, और हाथ में कार्य उन पांच टिप्पणियों को ढूंढना है, जिनमें सबसे अधिक मिसालें हैं।

पूर्वता द्वारा टिप्पणियों (जो उनके आदेश को बदल देगा, प्रत्येक टिप्पणी के लिए छँटाई करने के बजाय ग , हम टिप्पणी नहीं एक अधिक या बराबर पूर्वता है कि गिनती। हम रखने ग यदि और केवल यदि इस गणना है 5 या उससे कम।

टिप्पणियों की संख्या को आंशिक रूप से क्रमबद्ध करने के लिए, हम निम्नलिखित करते हैं। बता दें कि x वोटर वेक्टर होता है जिसमें वोट काउंट होता है। तब x'transposes एक्स - इस प्रकार एक पंक्ति वेक्टर बनाने - और x.<x'एक बूलियन मैट्रिक्स कि के प्रत्येक तत्व तुलना बनाता एक्स के प्रत्येक तत्व के साथ एक्स ^टी ।

के लिए एक्स = [0, 2, 5, 4, 0, 1, 0] , इस देता है

<     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

पंक्तियों के माध्यम से संक्षेप में (के माध्यम से sum(...,2)), हम उस सूचकांक पर टिप्पणी की तुलना में कड़ाई से अधिक upvotes है कि टिप्पणियों की संख्या की गणना करते हैं ।

उदाहरण के लिए वेक्टर, यह देता है

4
2
0
1
4
3
4

इसके बाद, हम उन टिप्पणियों की संख्या की गणना करते हैं, जो उस टिप्पणी की तुलना में पहले के बराबर मात्रा में पोस्ट की गई हैं। हम इसे इस प्रकार प्राप्त करते हैं।

पहले हम एक समानता तालिका x.==x'बनाते हैं, जो x ^T के तत्वों के साथ x के तत्वों की गणना करती है । हमारे उदाहरण वेक्टर के लिए, यह देता है:

=     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

अगला, हम cumsumमैट्रिक्स के प्रत्येक कॉलम के संचयी योगों की गणना करने के लिए उपयोग करते हैं।

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) उन टिप्पणियों की गिनती रखता है जिनमें समान मात्रा में अपवोट्स होते हैं और बाद में संबंधित टिप्पणी की तुलना में नहीं होते हैं।

1
1
1
1
2
1
3

हमारे द्वारा निर्मित दो पंक्ति वैक्टरों को जोड़कर, हम टिप्पणियों की प्राथमिकताओं ( 1 उच्चतम है) को प्राप्त करते हैं।

5
3
1
2
6
4
7

1 से 5 तक की प्राथमिकताओं वाली टिप्पणियों को प्रदर्शित किया जाना चाहिए, इसलिए हम उनके सूचकांकों को निर्धारित करते हैं find(....<6)और संबंधित टिप्पणियों को पुनः प्राप्त करते हैं x[...]।

Answer 17

पायथन 3.5, 68 बाइट्स

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

मेरे पायथन 2 के उत्तर के लिए कोई मेल नहीं है , लेकिन पायथन 3 के बंदरगाह से केवल तीन बाइट्स लंबा है, और मुझे लगता है कि यह दिलचस्प होना काफी अलग है।

I / O टुपल्स के रूप में है। यह repl.it पर परीक्षण करें ।