Votre tâche - si vous l'acceptez - est d'écrire un programme qui aide à comprendre ma proposition sur les méta en calculant le gagnant d'une compétition code-golf-inversé . Bien sûr, les réponses à cette question seront traitées comme proposées, de sorte que votre programme (s'il est correct) puisse calculer si votre réponse deviendra la réponse acceptée.

Règles

• Le programme lit un fichier avec plusieurs lignes du format suivant (voir l'exemple ci-dessous): TAB [Language] [NumberOfCharacters] TAB [LinkToAnswer]
• Le nom de fichier est transmis comme argument à votre programme ou le fichier est redirigé vers l'entrée standard de votre programme. C'est votre choix, veuillez mentionner la méthode lors de la réponse
• Il est prévu que le format d'entrée soit correct. Il n'est pas nécessaire de traiter les erreurs.
• Le nombre de caractères est positif. Votre programme doit gérer des longueurs allant jusqu'à 65535. 64 Ko devraient être suffisants pour tout le monde :-)
• Le programme produit ces lignes sur une sortie standard qui répond à l'idée de la méta-proposition, c'est-à-dire
  • le code le plus court d'un langage de programmation particulier gagne (phase de réduction)
  • le code le plus long parmi tous les langages de programmation gagne (phase de tri)
  • en cas d'égalité, toutes les réponses de même longueur doivent être imprimées
• L'ordre de sortie n'est pas important
• Bien que le code le plus long gagne, ce n'est pas du bowling . Votre code doit être aussi court que possible pour votre langage de programmation.
• Les réponses concernant rarement les langages de programmation qui n'essaient pas de raccourcir le code méritent un downvote, car ils essaient de contourner l'intention de ce genre de question. S'il n'y a qu'une seule réponse pour un langage de programmation spécifique, il serait considéré comme un candidat gagnant, vous pourriez donc commencer à souffler son code.

Exemple de fichier d'entrée (séparé par des onglets uniques en cas de problème de formatage):

GolfScript  34  http://short.url/answer/ags
GolfScript  42  http://short.url/answer/gsq
C#  210 http://short.url/answer/cs2
Java    208 http://short.url/answer/jav
C#  208 http://short.url/answer/poi
J   23  http://short.url/answer/jsh
Ruby    67  http://short.url/answer/rub
C#  208 http://short.url/answer/yac
GolfScript  210 http://short.url/answer/210

Sortie attendue (l'ordre n'est pas important):

C#  208 http://short.url/answer/poi
C#  208 http://short.url/answer/yac
Java    208 http://short.url/answer/jav

Mise à jour

Certains programmes reposent sur le fait qu'il existe un seul maximum (comme le programme de caractères C # 210). Dérivé de la réalité, quelqu'un peut également écrire un programme GolfScript avec 210 caractères. La sortie resterait la même. J'ai ajouté un tel GolfScript à l'entrée.

Update 2

Comme suggéré, j'ai repensé (toujours le code-golf aussi) et la date limite est le 2014-03-06 (qui ressemble à une date arbitraire, mais je serai de retour en Allemagne après avoir voyagé à ce moment-là).

Résultats finaux

J'ai décidé de voter comme suit:

• Les réponses où le nombre de caractères ne peut être confirmé obtiennent un commentaire pour expliquer le nombre.
• Les réponses qui peuvent être facilement réduites obtiennent un commentaire, une suggestion de modification et entrent dans le résultat avec la valeur de comptage la plus faible. (J'espère que je l'ai vu à l'avance).
• Les réponses qui ne compilent pas obtiennent un downvote. (Une tâche assez difficile en fin de compte).
• Les réponses qui ne sont pas jouées obtiennent un downvote (comme décrit dans les règles déjà).
• Les réponses qui produisent la sortie attendue obtiennent un vote positif. En raison de certaines réponses qui ne fonctionnent pas comme prévu, j'utilise 4 fichiers d'entrée différents et vérifie le résultat attendu.

Enfin, le gagnant est déterminé en fournissant le tableau des réponses qualificatives en entrée de mon programme de référence (plus une double vérification manuelle du résultat). Si ma propre réponse était la gagnante, je l'exclurais de la liste. En cas de plusieurs gagnants, je ne devrais en choisir qu'un. Par conséquent, certains bonus peuvent être gagnés:

• réponses qui acceptent plus de données que prévu (par exemple en dehors des plages définies)
• des réponses qui utilisent une idée intelligente de faire court

J'ai pris un instantané des réponses le 6 mars 2014, 19:45 UTC + 1. L'analyse est en cours. Vérifier toutes les réponses est plus difficile que prévu ...

Java - 556

import java.util.*;class G{public static void main(String[]x){TreeMap<?,TreeMap>m=new TreeMap();try{Scanner s=new Scanner(System.in);for(;;){String[]a=s.nextLine().split("\t");a(new Long(a[1]),a(a[0],m)).put(a[2],a);}}catch(Exception e){}TreeMap<?,Map<?,String[]>>n=new TreeMap();for(TreeMap o:m.values())a(o.firstEntry().getKey(),n).putAll((Map)o.firstEntry().getValue());for(String[]o:n.lastEntry().getValue().values())System.out.println(o[0]+"\t"+o[1]+"\t"+o[2]);}static<T>Map a(T t,Map m){if(m.get(t)==null)m.put(t,new TreeMap());return(Map)m.get(t);}}

Le programme lira à partir de STDIN.

import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

class G {
    public static void main(String[] x) {
        TreeMap<?, TreeMap> m = new TreeMap();
        try {
            Scanner s = new Scanner(System.in);
            for (; ; ) {
                String[] a = s.nextLine().split("\t");
                a(new Long(a[1]), a(a[0], m)).put(a[2], a);
            }
        } catch (Exception e) {
        }
        TreeMap<?, Map<?, String[]>> n = new TreeMap();
        for (TreeMap o : m.values())
            a(o.firstEntry().getKey(), n).putAll((Map) o.firstEntry().getValue());
        for (String[] o : n.lastEntry().getValue().values())
            System.out.println(o[0] + "\t" + o[1] + "\t" + o[2]);
    }

    static <T> Map a(T t, Map m) {
        if (m.get(t) == null)
            m.put(t, new TreeMap());
        return (Map) m.get(t);
    }
}

1. Le programme lira ligne par ligne jusqu'à ce qu'une exception se produise (soit ArrayIndexOutOfBoundsExceptionlorsqu'une ligne vierge est rencontrée, soit NoSuchElementExceptionsi l'entrée se termine sans traîner de nouvelle ligne). Chaque ligne lue est ajoutée à la TreeMap m, qui aurait pu être définie comme TreeMap<String, TreeMap<Long, TreeMap<String,String[]>>>(de gauche à droite: langue, taille du code, URL, entrée).
2. Ensuite, un résultat TreeSet<Long, TreeSet<String, String[]>> n(de gauche à droite: taille du code, URL, entrée) est construit où le contenu de chaque langue firstEntry()est agrégé.
3. lastEntry()de l'agrégat TreeMapcontient notre résultat - il suffit de l'imprimer.

Essayez sur ideone.com (commuté les deux dernières lignes d'entrée pour montrer que toutes les lignes sont lues)

Perl, 195 octets

while(<>){/(\S+)\t(\d+)\t(.+)/;push@{$a{$1}},$3if$2==$l{$1};$l{$1}=$2,$a{$1}=[$3]if $2<($l{$1}//65536)}$m=(sort{$b<=>$a}values%l)[0];map{$l=$_;map{print"$l\t$m\t$_\n"if$l{$l}==$m}@{$a{$l}}}keys%l

Une entrée est attendue dans STDIN, le résultat est écrit dans STDOUT:

C#      208     http://short.url/answer/poi
C#      208     http://short.url/answer/yac
Java    208     http://short.url/answer/jav

Version non golfée

#!/usr/bin/env perl
use strict;
$^W=1;

# hash %language remembers the minimum count for a language
# %language: <language> => <minimum count>
my %language;
# hash %array remembers the URLs for the minimum count of the language
# %array: <language> => [<url>, <url>, ....]
my %array;

while(<>){
    # parse input line (no error checking)
    /(\S+)\t(\d+)\t(.+)/;
    my ($lang, $count, $url) = ($1, $2, $3);
    # add URL, if the count is the current minimum for the language
    if ($count == ($language{$lang}//0)) {
    # better, but longer version:
    # if (defined $language{$lang} and $count == $language{$lang}) {
        push @{$array{$lang}}, $url;
    }
    # create a new entry for the language, if there is a new minimum
    if ($count < ($language{$lang}//65536)) {
    # better, but longer version:
    # if (not defined $language{$lang} or $count < $language{$lang}) {
        $language{$lang} = $count;
        $array{$lang} = [$url];   
    }
}

# Sort the minimal values in numerical descending order and
# get the first entry as maximum.
my $maximum = (sort { $b <=> $a } values %language)[0];

# Loop over all URLs of minimal answers for the language,
# but print only the entries for the languages with the largest
# minima.
foreach my $lang (keys %language) {
    foreach my $url (@{$array{$lang}}) {
        if ($language{$lang} == $maximum) {
            print "$lang\t$maximum\t$url\n";
        }
    }
}
__END__

Python 378 377 372

import sys
d=__import__("collections").defaultdict(list)
o={}
x=int
n="\n"
for i,l,u in[a.split()for a in sys.stdin.read().strip().split(n)]:d[i]+=[(l,u)]
for e,b in d.items():o[e]=[i for i in b if i[0]==str(min([x(i[0])for i in b]))]
print("".join(n.join("\t".join([u,s[0],s[1]])for s in y if x(s[0])==max(x(i[0][0])for i in o.values()))+n for u,y in o.items()).strip())

Entrée sur le stdin:

C:\Users\gcq\Documents\python>type m.txt | python test.py
C#      208     http://short.url/answer/poi
C#      208     http://short.url/answer/yac
Java    208     http://short.url/answer/jav

Et voici ce que j'avais avant de commencer à le compresser, à 551 caractères:

from collections import defaultdict
import sys
d = defaultdict(list)

for language, length, url in [a.split() for a in sys.stdin.read().strip().split("\n")]:
    d[language].append((length, url))

o = {}
for language, data in d.items():
    winval = data[0][0]
    for i in data:
        if int(i[0]) < int(winval):
            winval = i[0]
    o[language] = [i for i in data if i[0] == winval]

maxlen = max(int(i[0][0]) for i in o.values())

for language, dataa in o.items():
    for data in dataa:
        if int(data[0]) == maxlen:
            print("\t".join([language, data[0], data[1]]))

C # - 628

Voici une alternative plus longue de la vôtre qui utilise DataTable:

using Microsoft.VisualBasic.FileIO;namespace System{using T=Data.DataTable;using R=Data.DataRow;using V=Data.DataView;using C=Data.DataColumn;class p{static void Main(string[] a){var I=typeof(Int32);T t=new T();t.Columns.AddRange(new[]{new C("a"),new C("b",I),new C("c"),new C("d",I)});var f=new TextFieldParser(a[0]);f.SetDelimiters("\t");while(!f.EndOfData){var r=t.NewRow();r.ItemArray=f.ReadFields();t.Rows.Add(r);}foreach(R r in t.Rows){r[3]=t.Compute("min(b)","a='"+r[0]+"'");}V v=new V(t);T s=v.ToTable();foreach(R r in s.Select("b='"+t.Compute("max(d)","")+"'")){Console.WriteLine(String.Join("\t",r[0],r[1],r[2]));}}}}

Au départ, je pensais que j'avais peut-être obtenu une légère réduction de code en utilisant max / min avec DataTable, mais les types requis pour construire le DataTable(lignes / colonnes / vue) ajoutent beaucoup de longueur, malheureusement. Je suis nouveau dans le domaine du golf afin que quelqu'un puisse peut-être le réduire davantage. Encore un défi amusant.

dg - 286 281 260 251 218 octets

import '/sys'
d=dict!
for(a,b,c)in(map str.split$(sys.stdin.read!).splitlines!)=>d!!a=(d.get a list!)+(list'(int b,c))
for(i,l)in(d.items!)=>for(s,u)in l=>s==(max$map(i->fst$min i)d.values!)=>print$i+' '+(str s)+' '+u

Exemple:

$ cat langs.txt | dg langs.dg 
C# 208 http://short.url/answer/poi
C# 208 http://short.url/answer/yac
Java 208 http://short.url/answer/jav

Version non golfée :

import '/sys'

s = sys.stdin.read!
d = dict!
# convert the string into a list of tuples (name, score, url)
u = map str.split $ s.splitlines!
# add all the values to the dict (converting the score to an integer)
for (a, b, c) in u =>
  d!!a = (d.get a list!) + (list' (int b, c))
# computes the maximum value amongst the mins
m = max $ map (i -> fst $ min i) d.values!
for (i, l) in (d.items!) =>
  for (s, u) in l =>
    # if the score equals the maximum then print all the line
    s == m => print $ i + ' ' + (str s) + ' ' + u  # actually here .format()
                                                   # would be better

Q: Qu'est-ce que c'est que dg?
R: Un langage de programmation qui se compile en bytecode CPython, un peu comme Scala se compile en JVM. Cela signifie essentiellement que dg est une syntaxe alternative pour Python 3. Il vous permet également d'utiliser toutes les bibliothèques existantes.

Plus d'informations ici (même un tutoriel!): Https://pyos.github.io/dg

Rebol - 314

d: map[]foreach r read/lines to-file system/script/args[r: split r tab p: take r r/1: to-integer r/1 r/2: reduce[r/2]either none? d/:p[repend d[p r]][case[d/:p/1 > r/1[d/:p: r]d/:p/1 = r/1[append d/:p/2 r/2]]]]l: 0 foreach[k v]d[l: max l v/1]foreach[k v]d[if l = v/1[foreach n v/2[print rejoin[k tab v/1 tab n]]]]

non golfé

d: map []

foreach r read/lines to-file system/script/args [
    r: split r tab
    p: take r
    r/1: to-integer r/1
    r/2: reduce [r/2]
    either none? d/:p [repend d [p r]] [
        case [
            d/:p/1 > r/1 [d/:p: r]
            d/:p/1 = r/1 [append d/:p/2 r/2]
        ]
    ]
]

l: 0 foreach [k v] d [l: max l v/1]
foreach [k v] d [
    if l = v/1 [
        foreach n v/2 [print rejoin [k tab v/1 tab n]]
    ]
]

Exemple d'utilisation:

$ rebol script.reb data.txt
C#    208   http://short.url/answer/poi
C#    208   http://short.url/answer/yac
Java  208   http://short.url/answer/jav

C # - 515

Attend un nom de fichier comme argument

using System.Collections.Generic;namespace N{using S=SortedList<int,T>;class T:List<string>{static void Main(string[]a){var d=new Dictionary<string,S>();int n,m=0;T w=new T();foreach(var l in System.IO.File.ReadAllLines(a[0])){var p=(a=l.Split('\t'))[0];n=int.Parse(a[1]);if(!d.ContainsKey(p))d.Add(p,new S());if(!d[p].ContainsKey(n))d[p].Add(n,new T());d[p][n].Add(l);}foreach(var e in d){n=e.Value.Keys[0];if(n==m)w.AddRange(e.Value[n]);if(n>m)w=e.Value[m=n];}foreach(var e in w)System.Console.WriteLine(e);}}}

J'ai d'abord conçu mon programme C # pour qu'il soit simple, car je voulais avoir une sorte de programme de référence. Mais j'ai alors décidé de me lancer moi aussi dans le concours et de jouer au golf. Il s'agit d'une des versions antérieures du code + quelques commentaires:

// N: namespace
// P: Program
// S: type definition: sorted dictionary
// a: arguments
// d: data container
// r: lines read from text file
// l: single line from r
// t: tabbed part of l after splitting
// p: programming language name
// n: character count
// m: maximum character count
// w: list of winners
// e: entry in data container
// c: winner candidate
using System.Collections.Generic;
namespace N
{
    using S = SortedList<int, P>;
    public class P : List<string>
    {
        public static void Main(string[] a)
        {
            var r = System.IO.File.ReadAllLines(a[0]);
            // Make it a data structure
            var d = new Dictionary<string, S>();
            foreach (var l in r)
            {
                var t = l.Split('\t');
                var p = t[0];
                var n = int.Parse(t[1]);
                if (!d.ContainsKey(p)) d.Add(p, new S());
                if (!d[p].ContainsKey(n)) d[p].Add(n, new P());
                d[p][n].Add(l);
            }
            // Get the maximum values
            var m = 0;
            P w = null;
            foreach (var e in d)
            {
                foreach (var s in e.Value.Keys)
                {
                    if (s > m)
                    {
                        w = e.Value[s];
                        m = s;
                    }
                    else if (s == m)
                    {
                        w.AddRange(e.Value[s]);
                    }
                    break; // Break here to get the shortest solution per language
                }
            }
            // Print everything on console
            foreach (var e in w)
            {
                System.Console.WriteLine(e);
            }
        }
    }
}

C # - 460 359

Après avoir réalisé à quel point ma DataTablesolution était volumineuse , j'ai créé l'exemple suivant à l'aide de Linq. Il utilise la même méthodologie que ma solution précédente.

Golfé

namespace System{using Linq;using IO;class p{static void Main(string[]i){var l=(from f in File.ReadAllLines(i[0])let s=f.Split('\t')select new Tuple<string,int,string>(s[0],Convert.ToInt16(s[1]),f)).ToList();foreach(var f in l.Where(a=>a.Item2==l.Where(b=>b.Item1==l.Single(c=>c.Item2==l.Max(d=>d.Item2)).Item1).Min(e=>e.Item2)))Console.WriteLine(f.Item3);}}}

Non golfé

namespace System
{
    using Linq;
    using IO;
    class p
    {
        static void Main(string[]i)
        {
            var l=(from f in File.ReadAllLines(i[0])
                   let s=f.Split('\t')
                   select new Tuple<string, int, string>(s[0],Convert.ToInt16(s[1]),f)).ToList();
            foreach(var f in l.
                Where(a=>a.Item2==l.
                    Where(b=>b.Item1==l.
                        Single(c=>c.Item2==l.
                            Max(d=>d.Item2)).Item1).
                                Min(e=>e.Item2)))
            Console.WriteLine(f.Item3);
        }
    }
}

Je suis encore relativement nouveau à Linq, donc je suis presque certain que ces expressions peuvent être encore réduites.

D'après votre question, il n'est pas clair s'il existe une seule solution de longueur maximale. Pour mes réponses, j'ai utilisé l'hypothèse qu'il existe un seul point maximum (c'est-à-dire que s'il y avait aussi un maximum GolfScript de 210, il pourrait échouer en fonction de l'enregistrement maximum unique renvoyé). La solution d'Heiko aurait le même problème. Pour résoudre ce problème, nous devions ajouter une autre étape qui contenait une liste de maxima liés pour vérifier les minima pour chaque langue.

C ++ - 535

Ne sortira les réponses liées pour la position la plus longue qu'après avoir sélectionné uniquement les réponses les plus courtes de chaque langue en tant que gagnants potentiels.

#include<fstream>
#include<iostream>
#include<string>
#include<vector>
using namespace std;
int main(){

    string s;
    vector<string>l;
    vector<int>v;
    vector<string>u;
    cin>>s;

    ifstream i(s.c_str());

    do{
        int n;
        i>>s;
        if(i.eof())break;
        l.push_back(s);
        i>>n;
        v.push_back(n);
        i>>s;
        u.push_back(s);
    }while(1);

    for(int i=0;i<l.size();i++){
        for(int j=0;j<l.size();j++){
            if(l[j]==l[i]){
                if(v[i]>v[j])l[i]="";
                else if(v[i]<v[j])l[j]="";
            }
        }
    }
    int n=0;
    for(int i=0;i<v.size();i++)
        if(n<v[i]&l[i]!="")n=v[i];

    for(int i=0;i<v.size();i++)
        if(v[i]==n)cout<<l[i]<<'\t'<<v[i]<<'\t'<<u[i]<<endl;
}

Golfé (pas aussi illisible que certaines langues):

#include<fstream>
#include<iostream>
#include<string>
#include<vector>
using namespace std;
int main(){string s;vector<string>l;vector<int>v;vector<string>u;cin>>s;ifstream i(s.c_str());do{int n;i>>s;if(i.eof())break;l.push_back(s);i>>n;v.push_back(n);i>>s;u.push_back(s);}while(1);for(int i=0;i<l.size();i++)for(int j=0;j<l.size();j++)if(l[j]==l[i]){if(v[i]>v[j])l[i]="";else if(v[i]<v[j])l[j]="";}int n=0;for(int i=0;i<v.size();i++)if(n<v[i]&l[i]!="")n=v[i];for(int i=0;i<v.size();i++)if(v[i]==n)cout<<l[i]<<'\t'<<v[i]<<'\t'<<u[i]<<endl;}