Dans ce défi, vous devez analyser les fichiers de la morgue du jeu roguelike Dungeon Crawl Stone Soup et les exporter vers STDOUT.

Quels sont ces fichiers de morgue ??

Lorsque vous mourez, un fichier texte est généré avec les données de ce personnage à l'intérieur. Vous pouvez voir quel équipement le personnage possédait, ce qui s'est passé au cours des derniers tours et combien de monstres il a tués.

Vous pouvez trouver un exemple de fichier de morgue ici

Le défi

Votre travail consiste à créer un programme qui prend l'un de ces fichiers depuis STDIN, le paralyse et génère les données vers STDOUT.

Pour rendre ce défi un peu plus facile, il vous suffit d'analyser le premier bloc de texte. (jusqu'àThe game lasted <time> (<turns> turns).

Vous devez analyser et produire les informations suivantes:

• Le numéro de version.
• Le score.
• Le nom, le titre, la race et la classe du personnage.
• Le niveau du personnage.
• La cause de la mort / victoire.
• Le nombre de tours que la course a duré.

Exemple:

Dungeon Crawl Stone Soup version <version number> character file.

<score> <name> the <title> (level <level>, 224/224 HPs)
         Began as a <race> <class> on Mar 16, 2015.
         Was the Champion of the Shining One.
         <cause of death/victory>

         The game lasted 16:11:01 (<turns> turns).

Cas de test

Cas d'essai 1 - Victoire

Fichier d'entrée

Exemple de sortie - Victoire:

Version: 0.16.0-8-gd9ae3a8 (webtiles)
Score: 16059087
Name: Ryuzilla the Conqueror
Character: Gargoyle Berserker
Level: 27
Cause of Death/Victory: Escaped with the Orb and 15 runes on Mar 17 2015!
Turns: 97605

Cas d'essai 2 - Décès

Fichier d'entrée

Exemple de sortie - Décès:

Version: 0.16-a0-3667-g690a316 (webtiles)
Score: 462
Name: 8Escape the Ruffian
Character: Bearkin Transmuter
Level: 6
Cause of Death/Victory: Slain by an orc wielding a +0 trident (3 damage) on level 4 of the Dungeon.
Turns: 3698

Règles

• C'est du code-golf donc le code le plus court l'emporte.
• En cas d'égalité, la réponse la plus ancienne l'emporte.
• Pas de failles standard.
• L'entrée de fichier doit provenir de STDIN
• La sortie doit être envoyée à STDOUT
• Les étiquettes avant la sortie (ex. Turns:) Sont facultatives.

Exemple de code non golfé pour l'inspiration

Code de génération de fichier de morgue dans DCSS

Perl, 151 octets

Code 148 + 3 interrupteurs ( -0, -l, -p). Je suis sûr que cela peut être amélioré :)

Prend l'entrée de STDIN et imprime le résultat à la réception de l'EOF.

perl -lp0e 's/\.{3}|\s/ /g;y/ //s;$_=join$\,(/(\d.*?).{15}\..(\d+).(.+?).\(.+?(\d+).+?\b(?:a|an) (.+?) o.+? ([^.!]+[.!])[^.!]*?(\d+)[^(]+\)..\3/)[0..2,4,3,5..7]'

Non golfé:

use strict;
use warnings;

# set the input record separator to undef (the -0 switch)
$/=undef;
# read the text (the -l switch)
$_=<STDIN>;

# replace all '...' and spaces by a ' '
s/\.{3}|\s/ /g;
# squeeze all contiguous spaces into a single space
y/ //s;
# collect the captured groups into @p
my @p=
/(\d.*?).{15}\..      # version is the first string starting with a digit and ending 15 characters before the period
 (\d+).               # points is the next string with only digits
 (.+?).\(.+?          # name starts after a gap of one character
 (\d+).+?\b(?:a|an)\s # level is inside the next open paranthesis
 (.+?)\so.+?\s        # race, class occur after the 'a' or 'an' and end before ' o' i.e. (' on')
 ([^.!]+[.!])[^.!]*?  # cause of death is the a sentence ending with '.' or '!'
 (\d+)[^(]+\)..\3     # turns is the next sentence with digits within parantheses, followed by 2 characters and the player's name
/x;
$_=join"\n",@p[0..2,4,3,5..7]; # the level and race lines need to be swapped

# print the output (the -p switch)
print $_;

ideone.com

F #, 377 octets

open System.Text.RegularExpressions
let s=System.String.IsNullOrWhiteSpace>>not
let m f=Regex.Match((f+"").Split[|'\r';'\n'|]|>Seq.filter s|>Seq.take 8|>Seq.reduce(fun a z->a+z.Trim()), ".*n (.*) c.*\.([0-9]+) (.*) \(l.* (.*),.*a (.*) o.*\.(?:(S.*)|W.*(E.*)).*.T.*\((.*) .*\).").Groups|>Seq.cast<Group>|>Seq.skip 1|>Seq.map(fun z ->z.Value)|>Seq.filter s|>Seq.iter(printfn"%s")

Javascript (ES6), 297 230 octets

Pour l'instant, il s'agit d'une expression régulière pilotée par les tests.

Il remplace simplement les informations indésirables et conserve les informations importantes.

Il crée une fonction anonyme qui renvoie simplement le texte voulu.

_=>_.replace(/^.+version(.*) character file\.([\n\r]+)(\d+)([^\(]+) \([^\d]+( \d+),.+\n\s+.+as a(.+) on.+\n\s+(?:Was.+One\.\n)?((?:.|\n)+[!.])\n(?:.|\n)+\((\d+)(?:.|\n)+$/,'$1\n$3\n‌​$4\n$6\n$5\n$7\n$8').replace(/\s+(\.{3} ?)?/,' ')

N'est-ce pas une bête?

Merci pour le conseil de sysreq sur les étiquettes en option. Cela m'a fait économiser 67 octets !

Vous pouvez tester l'expression resulgar sur: https://regex101.com/r/zY0sQ0/1

Python3, 472 octets

Je pensais que je serais en mesure de raccourcir ce délai. Pas surpris cependant d'avoir battu ma propre soumission. Exécutez-le comme python3 dcss.py morgue-file.txt.

import sys
n="\n"
s=" "
f=open(sys.argv[1],'r').read().split(n)[:11]
m=range
a=len
d=","
for i in m(a(f)):
 f[i]=f[i].split(s)
 for x in m(a(f[i])):
  f[i][x]=f[i][x].strip()
h=f[0]
g=f[10]
k=f[2]
def r(j,u):
 j=list(j)
 while u in j:
  j.remove(u)
 return"".join(j)
def l(x):
 c=s
 for i in m(a(x)):
  c+=x[i]+s
 return c.strip()
print(h[6]+s+h[7]+n+k[0]+n+g[0]+s+g[1]+s+g[2]+n+r(g[3],"(")+s+r(g[4],")")+n+r(k[5],d)+n+r(l(f[4])+l(f[5])+l(f[6])+l(f[7]),".")+n+r(g[17],d))

Go, 589 502 489 487 octets

package main;import(."fmt";."io/ioutil";"os";."strings");func d(z,ch string)string{return Map(func(r rune)rune{if IndexRune(ch,r)<0{return r};return -1},z)};func main(){x:=Split;f,_:=ReadFile(os.Args[1]);n:="\n";l:=" ";m:=",";h:=".";q:=x(string(f),n)[:11];k:=x(q[0],l);y:=x(q[10],l);u:=x(q[2],l);g:="";for _,e:=range Fields(d(q[4],n+h)+l+d(q[5],n+h)+l+d(q[6],n+h)+l+d(q[7],n+h)){g=g+e+l};Print(k[6]+l+k[7]+n+u[0]+n+y[0]+l+y[1]+l+y[2]+n+d(y[3]+l+y[4],"()")+n+d(u[5],m)+n+g+n+d(y[17],m))}

après l'exécution go fmt, go fixet go vetvoici la version "non golfée":

package main

import (
    . "fmt"
    . "io/ioutil"
    "os"
    . "strings"
)

func d(z, ch string) string {
    return Map(func(r rune) rune {
        if IndexRune(ch, r) < 0 {
            return r
        }
        return -1
    }, z)
}
func main() {
    x := Split
    f, _ := ReadFile(os.Args[1])
    n := "\n"
    l := " "
    m := ","
    h := "."
    q := x(string(f), n)[:11]
    k := x(q[0], l)
    y := x(q[10], l)
    u := x(q[2], l)
    g := ""
    for _, e := range Fields(d(q[4], n+h) + l + d(q[5], n+h) + l + d(q[6], n+h) + l + d(q[7], n+h)) {
        g = g + e + l
    }
    Print(k[6] + l + k[7] + n + u[0] + n + y[0] + l + y[1] + l + y[2] + n + d(y[3]+l+y[4], "()") + n + d(u[5], m) + n + g + n + d(y[17], m))
}

Edit: l' utilisation de dot-imports aide beaucoup.

Assez explicite mais je peux expliquer si besoin est. Ceci est mon premier «vrai» programme Go et je suis toujours un débutant au codegolf, donc les conseils sont les bienvenus!

Edit: vous avez dit "prendre un fichier de STDIN", et vous pouvez exécuter ce script (si vous avez installé) en exécutant go install <foldername>puis puis <binaryname> morgue-file.txtougo run main.go morgue.txt