Défi méta golf


22

Sur ce défi, vous devez résoudre ce défi.

Le concours est terminé! Vérifiez la fin de la question

Spécifications:

  1. Écrivez le plus petit code (N'importe quelle langue *).
  2. Le score d'une réponse est la somme de:
    • Longueur de code sans espace .
    • Nombre de réponses utilisant cette même langue au carré.
    • Longueur du nom de la plus grande langue du concours moins la longueur de votre langue.
    • Downvotes moins Upvotes (alias moins Total des votes)
  3. Écrivez la position des utilisateurs et le score.
  4. Chaque utilisateur ne peut écrire qu'une seule réponse.
  5. Le score le plus bas l'emporte.

Essai:

Donc, à la fin du concours, une entrée possible pourrait être (STDIN):

Les colonnes sont: Nom d'utilisateur, Langue, Longueur du code (sans espace) et TotalVotes

UserA Python 100 1
UserB Perl 30 2
UserC Java 500 3
UserD Brainfuck 499 4
UserE Perl 29 5

Si votre nom d'utilisateur comporte des espaces comme "Mon nom d'utilisateur", il deviendra "MonNomUtilisateur", donc l'entrée aura toujours exactement 4 colonnes .

La sortie sera (STDOUT):

1 UserE 33
2 UserB 37
3 UserA 103
4 UserD 496
5 UserC 503

Explication:

User  P  N^2  L   V
 A   100  1   3  -1
 B    30  4   5  -2
 C   500  1   5  -3
 D   499  1   0  -4
 E    29  4   5  -5

Brainfuck est le plus grand nom avec 9 caractères ( 9 - 9 = 0).

Perl et Java ont 4 caractères ( 9 - 4 = 5).

Python a 6 caractères ( 9 - 6 = 3).

Perl a 2 entrées donc chacun obtient 4 points supplémentaires.


À propos des langues:

Le nom de la langue ne doit contenir que des lettres anglaises (c'est-à-dire [A-Za-z]) et celles qui ne correspondent pas doivent être "traduites" en autre chose.

À la fin du concours, chaque langue doit avoir sa représentation (vous pouvez proposer de meilleures représentations)

Exemples:

Python3      -> Python
Ruby1.9      -> Ruby
Shell Script -> Shell
C++          -> Cpp
C#           -> CSharp
><>          -> Fish

Date limite: 20 août 2011 00:00 UTC

À la fin du concours, le gagnant doit utiliser son programme pour trouver le gagnant. Il est permis aux non gagnants d'utiliser leurs programmes pour trouver le gagnant et de lui dire d'utiliser son programme pour trouver le gagnant. :)

Le gagnant (voir ci-dessus) obtient la réponse acceptée!

* Le langage des espaces blancs a l'avantage injuste de pouvoir introduire une complexité illimitée sans pénalité sur le nombre de caractères. Les réponses écrites en blanc peuvent être sur le concours mais ne peuvent pas gagner.

Si vous pouvez faire la logique de votre programme dans les espaces blancs , vous ne pouvez pas non plus gagner. C'est un sujet subjectif, mais si votre programme peut augmenter considérablement de taille sans être pénalisé, il tombe dans cette condition.


Entrée finale

Ordre alphabétique des noms (au 20 août 2011 UTC 00:00)

boothby Sage 41 9
Harpyon Python 203 4
JBernardo Python 184 7
JoeyAdams PostgreSQL 225 6
jpjacobs AWK 269 4
Lowjacker Ruby 146 2
PeterTaylor Golfscript 82 4
rmackenzie CommonLisp 542 2
shesek Javascript 243 3
userunknown Scala 252 1

Comme les réponses de la mienne et de boothby ne sont pas autorisées à gagner, le gagnant doit se proclamer vainqueur en éditant cette question et en affichant le résultat final ci-dessous.

Sortie finale

1 boothby 39
2 PeterTaylor 79
3 Lowjacker 151
4 JBernardo 185
5 Harpyon 207
6 JoeyAdams 220
7 shesek 241
8 userunknown 257
9 jpjacobs 273
10 rmackenzie 541

8
Cela signifie-t-il qu'une solution dans Whitespace gagnera automatiquement?
Joey Adams

1
D'où proviennent les informations sur les autres réponses? Nos programmes sont-ils censés se connecter à StackExchange et exploiter les réponses à cette question?
Justin Morgan

1
@Justin À la fin du concours, je ferai la vraie entrée du programme avec les réponses. J'ai donné le format
JBernardo

1
@Harpyon <> <ti dexif I! SknahT
JBernardo

1
Faut-il trier la sortie par scores? Si oui, que devons-nous faire en cas d'égalité?
boothby

Réponses:


11

Golfscript, 83 caractères (82 sans compter les espaces blancs)

n/{},{' ':s/}%.{1=}%\{~~\~\-\.`{=}+4$\,,.*\,-+2${,}%$)\;+[\]}%$\;.,,]zip{~)s@~s@n}%

Explication:

# Split the string containing all the input on newlines
n/
# Remove empty lines
{},
# Split each line on spaces (storing the space character in variable s)
{' ':s/}%
# We now have an array of arrays of words. Duplicate it, filter the copy to contain
# only the second word of each array, and reorder with the array of second words first
.{1=}%\
# Map each line
{
    # Unpack the array ["user" "lang" "length" "votes"] and evaluate the integers
    ~~\~\
    # Subtract votes from length and bring "lang" to the top
    -\
    # Create a function to match the string "lang"
    .`{=}+
    # Stack is currently [array of langs] "user" (length-votes) "lang" {"lang"=}
    # Duplicate the array of langs and apply the match function as a filter
    4$\,
    # Get the length of the array of matches and square it
    ,.*
    # Stack is [array of langs] "user" (length-votes) "lang" (num with lang)^2
    # Bring the "lang" to the top, get its length, subtract and add
    \,-+
    # Stack is [array of langs] "user" (score-length of longest lang)
    # Get an array of length of language names and sort it
    2${,}%$
    # Drop it apart from the largest value, and add that to the score
    )\;+
    # Package the "user" score from the top of the stack as [score "user"]
    [\]
}%
# Sort. Since each element is a [score "user"] value, this will sort by score.
$
# Discard the [array of langs].
\;
# Stack is an array of [score "user"] arrays. Get its length and create an array of the
# same length which counts from 0.
.,,
# Group and zip, so we go from [[score0 "user0"] ... [scoren "usern"]] [0 ... n] to
# [[[score0 "user0"] 0] ... [[scoren "usern"] n]]
]zip
# Map each [[scorei "useri"] i]
{
    # Expand, increment i (so we count from 1 rather than 0), add a space
    ~)s
    # Bring the [scorei "useri"] to the top, unpack, add a space
    @~s
    # Bring the scorei to the top, add a newline
    @n
}%
# We now have an array [[1 " " "userA" " " scoreA "\n"] ... [n " " "userZ" " " scoreZ "\n"]
# so Golfscript's standard output formatting does the rest

C'est plutôt bien, je devrais jeter un oeil à GolfScript ... Je n'ai aucune idée de comment cela est analysé en quelque chose de significatif
shesek

3
@shesek, a ajouté une version fortement commentée
Peter Taylor

wow, très cool! merci :-)
shesek

15

Sage: 48 42 41 non blanc (60246 octets au total)

Juste pour être une piqûre:

s = '   '
for c in '<lots of whitespace>'.split(s):
    s+=chr(len(c))
exec s

Notez que la première ligne doit être équivalente à s='\t', mais le bloc de code SE traduit la tabulation en 4 espaces.

L'espace se décompresse pour:

exec preparse("""
import sys
instances = {}
maxlen = 0
inputs = [line.split() for line in sys.stdin.readlines()]
for i in [0..len(inputs)-1]:
    user, language, length, votes = inputs[i]
    if language in instances:
        instances[language]+=1
    else:
        instances[language]=1
    if len(language) > maxlen:
        maxlen = len(language)

scoresheet = []
for i in [0..len(inputs)-1]:
    user, language, length, votes = inputs[i]
    length = int(length)
    votes = int(votes)
    score = length + (maxlen - len(language)) + instances[language]*instances[language] - votes
    scoresheet.append((score,user))

scoresheet.sort(reverse=False)
for user, score in scoresheet:
    print user, score""")

Notez que mon utilisation de [0..len(inputs)-1]assure que ce n'est pas un script Python, car Sage est un superpython *. Malheureusement, l'exec retombe sur Python ... donc je dois le préparer.

edit 1: fractionnement sur les onglets, pas les sauts de ligne - à quoi pensais-je? édition 2: a rendu le code plus facile pour les yeux et a recyclé l'onglet de fractionnement en poussant une autre «nouvelle ligne» vers l'espace blanc

* ok, pas tout à fait: on casse xor


10

Python, 184

C'est pourquoi j'aime les espaces.

import          sys
x = sys.stdin.read(
    ).split()
z = x [  1 : : 4  ]
for i , ( j , k
) in enumerate (
      sorted (
       zip (
        [
      int(i)
    - int(j) +
  z.count(k) ** 2
+ max(map(len, z)) -
      len(k)
  for i, j, k in
       zip (
    x[2 : : 4],
    x[3 : : 4],
         z
         )
         ],
     x[ : : 4]
         )
         ),
         1
         ):
   print i, k, j

C'est beaucoup plus lisible!


3
est-ce censé être une sorte d'art ascii représentant quelque chose? si oui, à quoi devrait-il ressembler?
oenone

@oenone tu me dis.
JBernardo

2
il semble que cela devrait, mais je ne peux rien reconnaître
oenone

1
@oneone moi non plus ...
JBernardo

7

PostgreSQL - 225 caractères non spatiaux

242 → 225: sous-requêtes remplacées par des clauses de fenêtrage .

\set QUIET 1
\t
\a
\f ' '
CREATE TEMPORARY TABLE t (u TEXT, l TEXT, c INT, v INT);
\copy t FROM PSTDIN WITH DELIMITER ' ';
SELECT row_number() OVER (ORDER BY score), *
    FROM (SELECT u,
                 c
                 + count(*) OVER (PARTITION BY l)^2
                 + max(length(l)) OVER ()
                 - length(l)
                 - v AS score
                 FROM t) AS q

testé sur 9.2devel

Utilisation et sortie:

$ psql -f meta.sql < meta.in
1 UserE 33
2 UserB 37
3 UserA 103
4 UserD 496
5 UserC 503

4

Python 2 - 210 203 caractères non spatiaux

import sys
e=enumerate
n=len
l=[x.split()for x in sys.stdin.readlines()]
for i,(x,y)in e(sorted((int(x[2])-int(x[3])+n(list(y for y in l if y[1]==x[1]))**2+max(n(x[1])for x in l)-n(x[1]),i)for i, x in e(l))):print i+1,l[y][0],x

Utilisation et sortie:

$ cat meta.txt | python meta.py
1 UserE 33
2 UserB 37
3 UserA 103
4 UserD 496
5 UserC 503

vous ne pouvez utiliser que x.split()(cela supprimera également \n)
JBernardo

@JBernardo Cheers! 7 caractères enregistrés.

Vous pouvez abandonner le .readlines () sur sys.stdin .... pour toute longueur d'entrée raisonnable, l'appel de fonction ne fera aucune différence et coûtera quelques caractères. Je viens de comprendre cela dans un autre golf et j'ai pensé partager.
arrdem

4

AWK, 277 269 ​​caractères non spatiaux

Utilisé inpour couper 8 caractères.

Version espacée et version commentée:

{
        # read in user strings
        u[NR]=$0
        # count number of times language has been used
        l[$2]+=1
}

END{
        # get maximum language length
        M=0
        X=NR
        for (g in l){
                f=length(g)
                if(f>M)
                        M=f
        }
        # get score for user i
        for(i in u){
                split(u[i],c)
                s[i]=c[3]+l[c[2]]^2+M-length(c[2])-c[4]
        }
        # sort scores and users
        for(i=2;i<=X;++i){
                for(j=i;s[j-1]>s[j];--j){
                        t=s[j]
                        x=u[j]
                        s[j]=s[j-1]
                        u[j]=u[j-1]
                        s[j-1]=t
                        u[j-1]=x
                }
        }
        # output
        for(i=1;i<=X;++i){
                split(u[i],c)
                print i,c[1],s[i]
        }
}

usage:

awk -f meta.awk data.txt

utilisé sed '/#/ d' meta.awk|sed ':a;$!N;s/\n//;ta;s/\s//g;'|wc -cpour compter les caractères.
jpjacobs

3

Rubis, 146 caractères + 4 espaces

b=$<.map &:split
puts b.map{|u,l,c,v|[b.map{|_,n|n.size}.max-l.size+b.count{|_,n|n==l}**2+eval(c+?-+v),u]}.sort.map.with_index{|(s,u),i|[i+1,u,s]*' '}

3

JavaScript, 243 caractères

for(g=0,H="length",i=J.split("\n"),p=[],l={};i[H]&&p.push(a=i.pop().split(" "));)
    X=a[1],X[H]>g&&(g=X[H]),l[X]=l[X]+1||1
for(i=-1;m=p[++i];)p[i]=[m[0],+m[2]+Math.pow(l[m[1]],2)+(g-m[1][H])-m[3]]
p.sort(function(a,b){return a[1]<b[1]?-1:1}).join("\n")

Plus long que la plupart des autres solutions ... mais le meilleur que j'ai pu trouver en JavaScript.

Usage

L'entrée doit être dans une variable J. Par exemple, ouvrez une console et écrivez:

J="UserA Python 100 1\nUserB Perl 30 2\nUserC Java 500 3\nUserD Brainfuck 499 4\nUserE Perl 29 5";
for(g=0,H="length",i=J.split("\n"),p=[],l={};i[H]&&p.push(a=i.pop().split(" "));)
    X=a[1],X[H]>g&&(g=X[H]),l[X]=l[X]+1||1
for(i=-1;m=p[++i];)p[i]=[m[0],+m[2]+Math.pow(l[m[1]],2)+(g-m[1][H])-m[3]]
p.sort(function(a,b){return a[1]<b[1]?-1:1}).join("\n")

CoffeScript, 177 caractères

À propos de la même logique, dans CoffeScript:

g=0;H="length";l={};([A,+C+Math.pow(l[B],2)+(g-B[H])-D] for [A,B,C,D] in for a in J.split "\n" then [_,X]=a=a.split " ";X[H]>g&&g=X[H];l[X]=l[X]+1||1;a).sort((a,b)->`a[1]<b[1]?-1:1`).join "\n"

J'aime la façon dont vous abrégez l' lengthattribut en utilisant une variable et des indices.
Joey Adams

3

Lisp commun - 546

(lorsque le garçon a joué au golf en consolidant les parenthèses, sans compter les espaces)

;;;; This is an answer to Code-Golf question
;;;; 3203/meta-golf-challenge
;;;; By using Common Lisp I plan to have the longest
;;;; Language-name while I cannot hope to have the
;;;; lowest character count due to Lisp's
;;;; linguistic tradition I can avoid the 16 or 25-pt
;;;; penalty atached to being the 4th or 5th PY
;;;; based answer.

(defun f (i)
 (loop for e in y do
  (if (eq i (nth 0 e))
   (return (nth 1 e))
  )
 )
)

(setf x
 (loop for l = (read-line () () () ())
  while l collect (loop for i = 0 then (1+ j)
                   as j = (position #\Space l :start i)
                   collect (subseq l i j) while j)
 )
)

(setf y
 (loop for a in x collect
  (list
   (+
    (read-from-string (nth 2 a))
    (expt (reduce #'+ (loop for b in x collect (if (string= (nth 1 a) (nth 1 b)) 1 0) ) ) 2 )
    (+ 5 (- (reduce #'min (loop for b in x collect (length (nth 1 b)))) (length (nth 1 a))))
    (* -1 (read-from-string (nth 3 a)))
   )
   (car a)
  )
 )
)

(setf g
 (sort (loop for c in y collect (nth 0 c)) #'<)
)

(loop for i = 0 then (1+ i) while (< i (length g)) do
 (setf a (nth i g))
 (format t "~A ~A ~A~%" (1+ i) (f a) a)
)

Fortement golfée, ma solution lisp commune était et est la plus longue sur la planche. J'ai donc décidé de tricher un peu en écrivant un chargeur de démarrage beaucoup plus court et en prétendant que ma soumission.(Je considère que la soumission de @ Boothby est un précédent en faveur de ce comportement)

Un grand merci à Peter Taylor pour son aide à éliminer tous les derniers caractères de ce bootstrapper.

BASH - 35

wget -q goo.gl/R4R54
cat -|clisp l.lsp

Utilisation : cat ./test0 | bash ./btstrp.sh

Joey Adams a souligné que ce n'est pas une solution équitable car je peux "augmenter arbitrairement la complexité de votre solution sans augmentation correspondante de la taille du code", un point qui n'est pas clairement exprimé dans la spécification.


1
Une boucle for ne serait-elle pas plus courte que la jusqu'à?
Peter Taylor

pas sûr ... mais trouvé un peu de temps!
arrdem

1
De plus, si vous spécifiez la variable à lire, vous n'avez pas besoin de l'utiliser $REPLY. Essayez while read x;do a=$x"\n"$a;done. Et vous devriez pouvoir supprimer les espaces après le |s sur la dernière ligne. Sur une autre note, je ne suis pas sûr que l'utilisation d'une adresse IP interne soit très utile: cela ne fonctionnera pas pour quelqu'un d'autre.
Peter Taylor

Ou mêmewget -q http://url/l.lsp ;cat - |clisp l.lsp
Peter Taylor

D'accord, tu m'as perdu sur le chat -
arrdem

2

Scala 269 ​​266 252 sans espaces ni sauts de ligne.

val b = io.Source.stdin.getLines.toList.map (_.split (" "))
b.map (a => {
  val l = b.filter (_(1) .equals ( a(1))).size
  a(0) -> (a (2).toInt + l * l + (b.map (x => x(1).length).max - a(1).length) - a(3).toInt)
}).sortBy (_._2).zipWithIndex .map (m => m._2 + " " + m._1._1 + " "+ m._1._2).mkString ("\n")

Invocation:

cat user.lst | scala -i metagolf.scala

mises à jour:

  • simplifié (l => l.foo) -> (_.foo)
  • invocation
  • Gareths fait allusion à Stdin

ma solution:

* 0 boothby 39
1 PeterTaylor 79
2 Lowjacker 151
* 3 JBernardo 185
4 Harpyon 207
5 JoeyAdams 220
6 shesek 241
7 userunknown 257
8 jpjacobs 273
9 rmackenzie 541

*) hors concours


Vous pouvez utiliser à la stdinplace de fromFile(System.in).
Gareth

1
Merci. Maintenant, j'ai besoin de 179 votes positifs et j'aurais gagné le défi - ceteris paribus.
utilisateur inconnu

Aucun problème. Hmm ... je ne suis pas sûr qu'il y ait suffisamment de trafic pour obtenir 179 votes positifs ...
Gareth
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.