यह मत नहीं है कि कौन वोट देता है; यह वोटों को गिनता है [बंद]

Question

परिदृश्य

आप उस देश में रहते हैं जहां राष्ट्रपति चुनाव हो रहा है। प्रत्येक मतदाता को एक मत प्राप्त होता है, और इसलिए दो-पक्षीय प्रणाली में मजबूती होती है। (तृतीय पक्ष मौजूद हैं, लेकिन शायद ही कोई वोट मिले)।

नवीनतम जनमत सर्वेक्षण में जानलेवा गर्मी में दौड़ को दिखाया गया है:

• 49%: अल्बर्टो अर्बुस्टो
• 49%: जॉर्ज संग्रे
• 2%: विभिन्न छोटे उम्मीदवार

कार्यक्रम की आवश्यकताएं

आपको सरकार ने वोट काउंटिंग सॉफ्टवेयर का हिस्सा लिखने के लिए काम पर रखा है। आपको मानक इनपुट पर, एक पूर्वकालिक मतों की एक अनियंत्रित सूची, प्रति पंक्ति, इस तरह दी जाएगी:

Alberto Arbusto
Jorge Sangre
Jorge Sangre
Alberto Arbusto
Jorge Sangre
Alberto Arbusto
Alberto Arbusto
Jorge Sangre
Juan Perez
Jorge Sangre
Alberto Arbusto
Alberto Arbusto
…

और, यह सभी वोटों को पढ़ने के बाद, प्रत्येक उम्मीदवार को कितने वोट मिले, इसका सारांश प्रस्तुत करता है, इस तरह से वोटों की संख्या से घटते क्रम में क्रमबद्ध होता है:

492 Jorge Sangre
484 Alberto Arbusto
 18 Juan Perez
  6 Mickey Mouse

नीचे का भाग

आप एक पक्षपातपूर्ण हैक हैं जो दो मुख्य उम्मीदवारों में से एक के लिए चुनाव चोरी करना चाहते हैं (आप चुन सकते हैं कि कौन सा)। इसलिए, आपके कार्यक्रम को आपके पसंदीदा उम्मीदवार के प्रति एक व्यवस्थित पूर्वाग्रह के साथ, जानबूझकर गलत वोटों की छपाई करनी चाहिए ।

बेशक, आपको ऐसा करना ही होगा, जो आपके कोड या इसके आउटपुट को देखने वाले व्यक्ति को गलत व्यवहार को पहचानने की संभावना नहीं होगी।

Comments

कार्यक्रम को चलाने वाले व्यक्ति को यह बताने के लिए कि वह किसके पक्षपात करना चाहता है? यह 1 : चुनौती को कम व्यापक बनाता है (एक अच्छी बात), 2 : जवाब को और अधिक रोचक बनाता है (IMO)

— जस्टिन

...you can choose which one...क्या मैं वह चुन सकता हूं जिसका नाम सबसे पहले है?

— user80551

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

बैश में एक लंबे कार्यक्रम को सही ठहराना मुश्किल हो सकता है, यह देखते हुए कि इस प्रारूप में वोटों को गिनने के लिए एक गैर-अंडरहेल्ड प्रोग्राम सचमुच शाब्दिक होगा sort|uniq -c...

@Alessandro: यह वास्तव में इनपुट में वास्तव में क्या है की तुलना में उसे (और / या अपने प्रतिद्वंद्वी के लिए कम संख्या में वोट के लिए) अधिक संख्या में आउटपुट की आवश्यकता है। चुनाव को काफी करीब से माना जाता है कि एक छोटी सी गलती इसे स्विंग कर सकती है।

— dan04

Answer 1

स्काला

लंबे समय तक अल्बर्टो अर्बुस्टो रहते हैं!

import scala.io.Source
import java.util.concurrent.atomic.LongAdder

object Votes extends App {
  val votes = Source.stdin.getLines.toIndexedSeq
  val registeredCandidates = Seq(
    "Alberto Arbusto",
    "Juan Perez",
    "Mickey Mouse",
    "Jorge Sangre"
  )

  val summaries = registeredCandidates map (Summary.apply(_, new LongAdder))

  var currentCandidate: String = _

  for (vote <- votes.par) {
    currentCandidate = vote
    summaries.find(s => s.candidate == currentCandidate).map(_.total.increment)
  }

  for (summary <- summaries.sortBy(-_.total.longValue)) {
    println(summary)
  }
}

case class Summary(candidate: String, total: LongAdder) {
  override def toString = s"${total.longValue} ${candidate}"
}

अल्बर्टो अर्बुस्टो लगभग हमेशा जॉर्ज सांग्रे से थोड़ा आगे निकल आएगा, बशर्ते कि पर्याप्त वोट डाले जाएं (~ 10,000)। वोटों के साथ छेड़छाड़ करने की कोई जरूरत नहीं है।

दौड़ की स्थिति है। और अल्बर्टो अर्बुस्टो को पहले ही सूची में डालकर, हम दौड़ जीतने के उनके अवसरों को बढ़ाते हैं।

साइड नोट: यह कोड एक "कस्टम" कनेक्शन पूल पर आधारित है जो मुझे एक परियोजना पर मिला था। यह पता लगाने में हमें हफ्तों का समय लगा कि क्यों आवेदन सदा के लिए कनेक्शन से बाहर था।

Comments

मुझे यह बहुत पसंद है क्योंकि यह प्रशंसनीय विकृतीकरण देता है।

— dan04

Answer 2

माणिक

vote_counts = $<.readlines.group_by{|s|s}.collect{ |name, votes| [votes.count, name] }

formatted_count_strings = vote_counts.map do |row,
  formatter = PrettyString.new|"%#{formatter[1][/[so]/]||'s'} %s"%
  [row,formatter]
end

sorted_count_strings = formatted_count_strings.sort_by(&:to_i).reverse

puts sorted_count_strings

जॉर्ज संग्रे को अपने वोट की गिनती में पर्याप्त वृद्धि मिलेगी (उदाहरण के लिए, 492 वोट 754 के रूप में रिपोर्ट किए जाएंगे)। अल्बर्टो के वोटों की सटीक रिपोर्ट की जाएगी।

जैसा कि आप अनुमान लगा सकते हैं, यह वोटों को गिनने वाला नहीं है, लेकिन वोटों को प्रारूपित करने वाला कौन है। मैंने इसे अस्पष्ट करने की कोशिश की है ( PrettyString.newएक वास्तविक चीज़ नहीं है और कभी भी कॉल नहीं किया जाता है), लेकिन formatterवास्तव में नाम स्ट्रिंग है। यदि नाम का दूसरा अक्षर 'ओ' है, तो मतगणना को दशमलव के बजाय अष्टक में प्रिंट किया जाएगा।

Answer 3

दे घुमा के

(क्या यह विनिर्देश पूरा करता है?)

uniq -c|sort -rk2,2|uniq -f1|sort -gr

हमेशा की तरह, यह वैध आउटपुट सुनिश्चित करने के लिए अतिरिक्त सावधानी बरतता है।

uniq -cजितनी बार यह होती है, उतनी संख्या के साथ प्रत्येक पंक्ति को उपसर्ग करता है। यह मूल रूप से सभी काम करता है।

जैसे uniq -cही कुछ गलत होता है, हम अब इसके उत्पादन को उल्टे क्रम में उम्मीदवारों के नामों के आधार पर क्रमबद्ध करते हैं, फिर uniq -f1किसी भी नकली उम्मीदवारों को निकालने के लिए इसे (प्रथम फ़ील्ड [वोटों की संख्या]) की अनदेखी करते हुए डुप्लिकेट लाइनें न प्रिंट करें)। अंत में हम sort -gr"जनरल न्यूमेरिक" और "रिवर्स" ऑर्डर (वोटों की संख्या के अनुसार अवरोही क्रम) को क्रमबद्ध करने के लिए उपयोग करते हैं ।

uniq -cलगातार होने वाली घटनाओं को गिनाता है, पूरी फाइल पर नहीं होता है। सबसे अधिक मतों के साथ विजेता उम्मीदवार होगा।

Comments

यह कैसे किसी विशेष उम्मीदवार को पूर्वाग्रह करता है। आपने बस चुनाव की जीतने की स्थिति बदल दी है। (यह अराजकता होगी अगर यह चुनाव वास्तव में कैसे तय किया गया :)। आप क्रमिक रूप से मतदान करने के लिए विशाल इंटरनेट समूह का आयोजन करेंगे)

— क्रंचर

@ सवाल पर टिप्पणी में क्रंचर, पूछने वाले का कहना है कि किसी भी तरह से फ़ाइल में पहला नाम चुनना ठीक है, इसलिए यह संभवतः ठीक है

Answer 4

सी#

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        var candidates = new SortedDictionary<string, int>();
        string candidate;
        using (var sr = new StreamReader("candidates.txt"))
        {
            while ((candidate = sr.ReadLine()) != null)
            {
                if (candidates.ContainsKey(candidate)) 
                    candidates[candidate]++;
                else 
                    candidates.Add(candidate, 1);
            }
        }

        // order by the votes
        var votes = candidates.OrderByDescending(k => k.Value).Select(x => x.Value);

        Console.WriteLine("Candidate | Votes"); 
        for (int i = 0; i < candidates.Count; i++)
        {   
            Console.WriteLine(candidates.ElementAt(i).Key + " " + votes.ElementAt(i));
        }

        Console.ReadKey();
    }
}

पाठ फ़ाइल में पहला उम्मीदवार हमेशा जीत जाएगा!

यह कर देगा अल्बर्टो अर्बुस्टो को विजेता !

उम्मीदवारों के नाम शब्दकोश में वर्णानुक्रम में दिए गए हैं, लेकिन वोट संख्या द्वारा आदेश दिए गए हैं।

Comments

तो क्या यह चुनाव को पहले उम्मीदवार को वर्णानुक्रम में सौंप देगा, या क्या हमें किसी भी उम्मीदवार को पसंद करने के लिए इसमें हेरफेर किया जा सकता है?

— जेम्स_पिक

यह उम्मीदवारों को वर्णानुक्रम में क्रमबद्ध नहीं करता है। यह केवल वोटों को छांटता है। आप किसी भी उम्मीदवार को जीतने के लिए जोड़ तोड़ कर सकते हैं। बस सुनिश्चित करें कि वह पाठ फ़ाइल में पहला है।

— माई

लेकिन IIUC अभ्यर्थियों को वर्णानुक्रम में क्रमबद्ध SortedDictionary करेगा ।

— जेम्स_पिक

ओह मैं समझा। यहां गलती हो सकती है। मुझे फिर से परखने दो।

— माई

@James_pic: Dictionary<TK,TV>कक्षा की हैश तालिका , जैसा कि कार्यान्वित की जाती है, सूचकांकों को वास्तविक वस्तुओं के बैकिंग सरणी में संग्रहीत करती है। ऐसा Dictionary<TK,TV> कोई आइटम जिससे कभी हटाए नहीं गए , वे जोड़े गए क्रम में तत्वों की गणना करेंगे; इस तरह के व्यवहार को निर्दिष्ट नहीं किया गया है, लेकिन यह पर्याप्त रूप से लंबे समय तक रहा है मुझे उम्मीद नहीं होगी कि एमएस इसे कभी भी बदल देगा।

— सुपरकैट

Answer 5

सी

#include <stdio.h>

#define NCANDIDATES 4
static const char * const cand_list[NCANDIDATES] = {
    "Alberto Arbusto",
    "Juan Perez",
    "Mickey Mouse",
    "Jorge Sangre"
};

#define BUFFER_SIZE 100

int
main(int argc, char **argv)
{
    int votes[NCANDIDATES];
    int candidate;
    size_t name_start;
    int i;
    int j;
    int place;
    int max;
    size_t bytes;
    char buffer[BUFFER_SIZE];

    /*
    Make sure input is read in text mode, so we don't have to
    worry about whether line endings are LF or CRLF.
    */
    freopen(NULL, "rt", stdin);

    /* Initialize vote tally. */
    for (candidate = 0; candidate < NCANDIDATES; candidate++) {
        votes[candidate] = 0;
    }

    /* Read and process vote file. */
    do {
        /* Read a block of data. */
        bytes = fread(buffer, 1, BUFFER_SIZE, stdin);

        /* Loop over the data, finding and counting the votes. */
        name_start = 0;
        for (i = 0; i < bytes; i++) {
            if (buffer[i] == '\n') {
                /* Found name. */
                buffer[i] = '\0'; // nul-terminate name so strcmp will work
                /* Look up candidate. */
                for (j = 0; j < NCANDIDATES; j++) {
                    if (strcmp(&buffer[name_start], cand_list[j]) == 0) {
                        candidate = j;
                        break;
                    }
                }
                /* Count vote. */
                ++votes[candidate];

                /* Next name starts at next character */
                name_start = i + 1;
            }
        }
    } while (bytes > 0);

    /* Output the candidates, in decreasing order of votes. */
    for (place = 0; place < NCANDIDATES; place++) {
        max = -1;
        for (j = 0; j < NCANDIDATES; j++) {
            if (votes[j] > max) {
                candidate = j;
                max = votes[j];
            }
        }
        printf("%8d %s\n", votes[candidate], cand_list[candidate]);
        votes[candidate] = -1; // Remove from consideration for next place.
    }

    return 0;
}

एहसान जोर्ज संग्रे।

बेतरतीब ढंग से उत्पन्न वोट फ़ाइलों के साथ परीक्षण में, यहां तक ​​कि जब अल्बर्टो अर्बुस्टो को वास्तविक वोटों का 1.4% अधिक (जोर्ज संग्रे के लिए 49.7% बनाम 48.3%) प्राप्त होता है, तो मेरा आदमी जॉर्ज संग्रे आमतौर पर गिनती जीतता है।

निश्चित आकार के ब्लॉक में डेटा पढ़ने से अक्सर दो ब्लॉकों में एक रेखा विभाजित हो जाती है। पहले ब्लॉक के अंत में लाइन के टुकड़े की गिनती नहीं होती है क्योंकि इसमें एक नई रेखा नहीं होती है। दूसरे ब्लॉक में टुकड़ा एक वोट उत्पन्न करता है, लेकिन यह किसी भी उम्मीदवार के नामों से मेल नहीं खाता है, इसलिए 'उम्मीदवार' चर अपडेट नहीं होता है। यह उस उम्मीदवार के वोट को स्थानांतरित करने का प्रभाव है जिसका नाम उस उम्मीदवार को विभाजित किया गया था जिसने पिछले वोट प्राप्त किया था। एक लंबे नाम के ब्लॉक में विभाजित होने की अधिक संभावना है, इसलिए अल्बर्टो अर्बुस्टो एक वोट "दाता" होता है जो कि जॉर्ज संग्रे की तुलना में अधिक बार होता है।

Answer 6

अजगर

from collections import defaultdict

def count_votes(candidate, votes=defaultdict(int)):
    with open('votes.txt') as f:
        for line in f:
            votes[line.strip()] += 1

    return votes[candidate]

if __name__ == '__main__':
    candidates = [
        'Mickey Mouse',
        'Juan Perez',
        'Alberto Arbusto',
        'Jorge Sangre'
    ]

    results = {candidate: count_votes(candidate) for candidate in candidates}

    for candidate in sorted(results, key=results.get, reverse=True):
        print results[candidate], candidate

मतगणना सूची के अंत के करीब उम्मीदवारों का पक्ष लेगी।

पायथन में, उत्परिवर्तनीय डिफ़ॉल्ट तर्क बनाए जाते हैं और परिभाषा पर कार्य के लिए बाध्य होते हैं। इसलिए वोटों को फ़ंक्शन कॉल के बीच बनाए रखा जाएगा और बाद के उम्मीदवारों के लिए ले जाया जाएगा। वोटों की संख्या दूसरे उम्मीदवार के लिए दो बार गिना जाएगा, तीसरे के लिए तीन बार, और इसी तरह।

Comments

इस तथ्य को छोड़कर कि कुल मत गणना अब इनपुट डेटा के अनुरूप नहीं है, यह मेरे पास था।

— ज़ैद

Answer 7

tr | सेड | डीसी

tr ' [:upper:]' '\n[:lower:]' <votes |\
sed -e '1i0sa0ss0sp' -e \
    '/^[asp]/!d;s/\(.\).*/l\1 1+s\1/
    ${p;c[Alberto Arbusto: ]P lap[Jorge Sangre: ]P lsp[Juan Perez: ]P lpp
    }' | dc

यह मेरे दोस्त अल्बर्टो को हर बार दो बार गिनता है।

"ओह - trठीक है, यह सिर्फ आवश्यक है क्योंकि कंप्यूटर बड़े अक्षरों के साथ बहुत अच्छे नहीं हैं - बेहतर अगर वे सभी लोअरकेस हैं .... हाँ, मुझे पता है, कंप्यूटर पागल हैं।"

आउटपुट

Alberto Arbusto: 12
Jorge Sangre: 5
Juan Perez: 1

यहाँ एक और संस्करण है जो जुआन पेरेस को जोर्ज संग्रे को वोट देता है:

tr '[:upper:]' '[:lower:]' <votes |\
sed -e '1i0sj0sa1so' -e \
    's/\(.\).*/l\1 1+s\1/
    ${p;c[Alberto Arbusto: ]P lap[Jorge Sangre: ]P ljp[Others: ]P lop
    }' | dc

आउटपुट

Alberto Arbusto: 6
Jorge Sangre: 6
Others: 1

Answer 8

जावास्क्रिप्ट

    function Election(noOfVoters) {
    candidates = ["Albert", "Jorge", "Tony", "Chip"];
    votes = [];

    for (i = 1; i <= noOfVoters; i++) {

        votes.push(prompt("1 - Albert, 2 - Jorge, 3 - Tony , 4 - Chip"))

    }
    votes.sort();
    WinningOrder = count(votes);

    var placement = [];

    for (x = 0; x < candidates.length; x++) {
        placement.push(x + " place with " + WinningOrder[x] + " votes is " + candidates[x] + "\n");
    }
    placement.reverse();
    alert(placement)
}


function count(arr) {
    var a = [],
        b = [],
        prev;

    arr.sort();
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] !== prev) {
            a.push(arr[i]);
            b.push(1);
        } else {
            b[b.length - 1]++;
        }
        prev = arr[i];
    }

    b.sort();

    return b;
}

उम्मीदवारों की सूची में अंतिम व्यक्ति हमेशा जीत जाएगा।