introduction

Mon grand-père est fan de James Bond, mais il ne sait toujours pas comment classer ses acteurs préférés. À ce titre, il fait toujours des listes, ce qui représente beaucoup de travail. Il m'a demandé de produire un programme qui va lui faciliter la vie, mais je n'ai pas le temps pour ça, je dois travailler! Je vais donc compter sur vous.

Défi

Le défi est simple. L'entrée consistera en une liste, au format suivant:

<number> <space> <actor's name> <newline>

Votre tâche consiste à les trier en fonction du nombre au début de la ligne, en commençant par le dernier et en terminant par le premier. Tous les numéros doivent être supprimés.

Cependant, mon grand-père fait parfois des erreurs. À ce titre, vous devrez valider les données. Si l'un des noms de la liste ne fait pas référence à l'un des acteurs qui ont joué Bond, vous devez le jeter. En cas de répétitions, les répétitions doivent être supprimées et le nom doit conserver le poids le plus bas auquel il a été associé (exemple # 3).

Il n'y a pas de limite au nombre de lignes.

La sortie ne doit être qu'une liste quelconque, que ce soit un tableau, une chaîne séparée par des virgules, juste des valeurs séparées par des espaces, ou autre chose entièrement

Pierce Brosnan, Sean Connery, David Niven

Un retour à la ligne ou un espace de fin est autorisé.

Exemple d'entrée et de sortie

Contribution:

1 Sean Connery

2 Emma Watson

5 Timothy Dalton

4 Roger Moore

3 Daniel Craig

Sortie:

Timothy Dalton, Roger Moore, Daniel Craig, Sean Connery

Contribution:

2 Timothy Dalton

4 George Lazenby

5 George Lazenby

3 Bob Simmons

Sortie:

George Lazenby, Bob Simmons, Timothy Dalton

Contribution:

3 Sean Connery

2 Pierce Brosnan

1 Sean Connery

Sortie:

Pierce Brosnan, Sean Connery

Comme il s'agit d'un code golf, le code le plus court (en octets) gagne!

appendice

Liste des acteurs qui ont joué le rôle de Bond:

• Barry Nelson
• Bob Simmons
• Sean Connery
• Roger Moore
• David Niven
• George Lazenby
• Timothy Dalton
• Pierce Brosnan
• Daniel Craig

Pyth, 136 132 octets

_{mtcd\ f}stcTdc"BarryNelson BobSimmons SeanConnery RogerMoore DavidNiven GeorgeLazenby TimothyDalton PierceBrosnan DanielCraig"dS.z

Essayez-le ici!

Explication

_ {mtcd \ f} stcTdc "BarryNelson BobSimmons ..." dS.z # .z = liste de toutes les lignes d'entrée
                                             Sz # Entrée de tri croissant
        f # filtre les lignes triées avec T étant la ligne courante
            cTd # Fractionner une ligne sur les espaces
          st # Dicardez le numéro et joignez le prénom et le nom
               c "BarryNelson BobSimmons ..." d # Fractionner la liste des acteurs obligataires sur les espaces ...
         } # ne conserve que les lignes qui sont dans la liste des acteurs
   mtcd \ # supprime le numéro des lignes filtrées
_ {# Supprimer les doublons du résultat de mappage et inverser le résultat

Retina ,201 197 191

\ d +
$ 0 $ * 1
G` ^ 1 + (Barry Nelson | Bob Simmons | Sean Connery | Roger Moore | David Niven | George Lazenby | Timothy Dalton | Pierce Brosnan | Daniel Craig) $
+ `\ b ((1 +) \ D *) ¶ (\ 2. +)
$ 3¶ $ 1
+ s`1 + (\ D +) ¶ (. * \ 1)
2 $
1+ 

Essayez-le en ligne!

6 octets économisés grâce à Martin!

Whee, tri à bulles avec regex. Notez que dix octets sont consacrés à la conversion décimale en unaire au début, si l'entrée unaire est correcte, cela n'est pas nécessaire. De plus, si les nombres ne peuvent pas être dans les noms des personnes, alors quelques octets supplémentaires peuvent être enregistrés en déplaçant la ligne qui supprime les acteurs non-Bond à la fin et en supprimant le 1+(non testé avec la \Dversion).

Explication:

Un programme Retina est composé de plusieurs étapes, je vais donc expliquer chaque étape séparément.

Étape 1:

\d+
$0$*1

Remplace les nombres dans l'entrée par unaire. Cela utilise le jeton de remplacement spécial de Retina: $*qui répète le personnage après un nombre de fois égal à la valeur de base 10 du jeton précédent.

Étape 2:

G`^1+ (Barry Nelson|Bob Simmons|Sean Connery|Roger Moore|David Niven|George Lazenby|Timothy Dalton|Pierce Brosnan|Daniel Craig)$

Le truc avant une `étape change le mode utilisé. Cela active le mode grep, ce qui signifie que chaque ligne qui ne correspond pas à l'expression régulière est supprimée. Les ancres sont nécessaires pour empêcher les allumettes proches de glisser.

Étape 3:

+`\b((1+)\D*)¶(\2.+)
$3¶$1

Il s'agit de l'étape de tri. Le +mode signifie que cette étape doit être répétée jusqu'à ce que le remplacement ne change pas lorsqu'il est appliqué (c'est-à-dire que nous atteignons un point fixe). L'expression régulière trouve une limite de mot, suivie d'un certain nombre de 1s, puis de tout le reste de la ligne jusqu'à la nouvelle ligne. Ensuite, si la ligne suivante a plus de 1s que cela, l'expression régulière correspondra et nous échangeons les lignes.

Étape 4:

+s`1+(\D+)¶(.*\1)
$2

Cette étape utilise à +nouveau le mode, mais permet également sde faire correspondre le .méta-caractère aux nouvelles lignes. Cela supprime les lignes en double, en faisant correspondre les doublons exacts après le 1s et en capturant le contenu après le premier doublon pour remplacer toute la correspondance par lui. Cela fonctionnera sans avoir à prendre en compte l'ordre de départage, car les noms sont déjà triés de manière appropriée, avec les plus grands nombres ci-dessus, par conséquent, nous conserverons toujours les valeurs les plus petites.

Étape 5:

1+ 

Vraiment simple ici, tout est en ordre, sauf que nous avons un tas de 1s devant nos obligations, donc nous les remplaçons et l'espace après eux avec rien.

TSQL 426 octets (y compris les données + entrée)

Solution golfée:

create table A(Name varchar(99))insert into A values('Barry Nelson'),('Bob Simmons'),('Sean Connery'),('Roger Moore'),('David Niven'),('George Lazenby'),('Timothy Dalton'),('Pierce Brosnan'),('Daniel Craig')declare @I as table (R int, N varchar(99))insert into @I values(3,'Sean Connery'),(2,'Pierce Brosnan'),(1,'Sean Connery')select N from(select N,min(R) R from @I where N in (select N from A) group by N) x order by R desc

Essayez-le ici

SQL excelle (sans jeu de mots) dans ce type de tâche: relier des ensembles, ordonner, supprimer les doublons, etc.

Tout ce dont vous avez besoin est de créer et de remplir un tableau d'acteurs comme celui-ci:

create table Actor (Name varchar(99))
insert into Actor values
 ('Barry Nelson')
,('Bob Simmons')
,('Sean Connery')
,('Roger Moore')
,('David Niven')
,('George Lazenby')
,('Timothy Dalton')
,('Pierce Brosnan')
,('Daniel Craig')

Maintenant, si nous utilisons une variable de table en entrée, nous avons juste besoin d'obtenir l'intersection des deux ensembles. La suppression des doublons et la commande dans SQL sont vraiment faciles.

Exemple 1:

declare @Input as table (Rnk int, Name varchar(99))
insert into @Input values
 (1,'Sean Connery')
,(2,'Emma Watson')
,(5,'Timothy Dalton')
,(4,'Roger Moore')
,(3,'Daniel Craig')

select Name
from
(
    select Name, min(Rnk) as R
    from @Input
    where Name in (select Name from Actor)
    group by Name
) x
order by R desc

Exemple 2:

declare @Input as table (Rnk int, Name varchar(99))
insert into @Input values
 (2,'Timothy Dalton')
,(4,'George Lazenby')
,(5,'George Lazenby')
,(3,'Bob Simmons')

select Name
from
(
    select Name, min(Rnk) as R
    from @Input
    where Name in (select Name from Actor)
    group by Name
) x
order by R desc

La version golfée est juste la chose complète, par exemple l'entrée 3

En plus, ce SQL peut fonctionner pour les anciennes versions de SGBD (même être réécrit sur ANSI SQL) et s'exécuter sans problème sur des ordinateurs plus anciens que la plupart des langues.

Perl, 242 179 217 octets

print reverse grep{/^(Barry Nelson|Bob Simmons|Sean Connery|Roger Moore|David Niven|George Lazenby|Timothy Dalton|Pierce Brosnan|Daniel Craig)$/&&!$s{$_}++}map{s/\d+ //;$_}sort{($a=~/(\d+)/)[0]<=>($b=~/(\d+)/)[0]}<>;

Version formatée plus agréable, avec commentaires:

print
     # reverse ranking order
     reverse
     # filter entries...
     grep {
         # only actual bonds
         /^(Barry Nelson|Bob Simmons|Sean Connery|Roger Moore|David Niven|George Lazenby|Timothy Dalton|Pierce Brosnan|Daniel Craig)$/
         # only new bonds
         && !$s{$_}++
     } map {s/\d+ //;$_}         # remove leading digits+space
     # sort according to embedded numbers
     sort {($a=~/(\d+)/)[0] <=> ($b=~/(\d+)/)[0]}
     <>;                        # slurp input as list (list context)

La plus grande partie de la taille est la liste des obligations; Je ne peux pas trouver un bon moyen de compresser cette expression régulière sans autoriser les faux positifs.

Python 2, 250 octets:

lambda I:zip(*sorted({k:v for v,k in[x.split(' ',1)for x in I.split('\n')]if k in'Barry Nelson,Bob Simmons,Sean Connery,Roger Moore,David Niven,George Lazenby,Timothy Dalton,Pierce Brosnan,Daniel Craig'.split(',')}.items(),key=lambda t:-int(t[1])))[0]

Démo:

>>> L = ["Barry Nelson",
...     "Bob Simmons",
...     "Sean Connery",
...     "Roger Moore",
...     "David Niven",
...     "George Lazenby",
...     "Timothy Dalton",
...     "Pierce Brosnan",
...     "Daniel Craig"]

>>> I="""2 Timothy Dalton
... 4 George Lazenby
... 5 George Lazenby
... 3 Bob Simmons"""
>>> F(I,L)
('George Lazenby', 'Bob Simmons', 'Timothy Dalton')

>>> I = """1 Sean Connery
... 2 Emma Watson
... 5 Timothy Dalton
... 4 Roger Moore
... 3 Daniel Craig"""
>>> 
>>> F(I,L)
('Timothy Dalton', 'Roger Moore', 'Daniel Craig', 'Sean Connery')

PowerShell v3 +, 227 219 octets

$a=$args-split"`n"|sort|%{$c,$b=-split$_;$b-join' '}|?{$_-in('Barry Nelson,Bob Simmons,Sean Connery,Roger Moore,David Niven,George Lazenby,Timothy Dalton,Pierce Brosnan,Daniel Craig'-split',')}|select -u
$a[$a.count..0]

_{121 octets ne sont que la liste des acteurs ...}

Prend entrée $argset -splits sur les nouvelles lignes avec `n. Dirigez-le vers sort, qui triera les entrées par ordre croissant, ce qui est OK pour l'instant. Nous les redirigeons vers une boucle foreach |%{...}, chaque itération prend l'entrée, -splitcelle - ci sur les espaces, puis -joinla seconde moitié en arrière avec un espace (c'est-à-dire en supprimant les nombres du début). Ces noms (ascendants) triés sont maintenant laissés sur le pipeline. Nous les dirigeons vers un endroit où ?cela garantit qu'ils sont -inla liste approuvée des acteurs. Enfin, nous n'avons selectque les -uentrées niques, qui pour les doublons sélectionneront la première qu'elle rencontre (c'est-à-dire la plus faible pondérée) et rejetterons le reste. Nous stockons le tableau de noms résultant dans $a.

Donc, maintenant, nous avons une liste ascendante triée d'acteurs. Étant donné que le défi nécessite une descente, nous effectuons une opération d'inversion sur place $aen indexant de $a.countbas en haut 0.

Exemple

PS C:\Tools\Scripts\golfing> .\sort-these-james-bond-ratings.ps1 "1 Sean Connery`n2 Emma Watson`n5 Daniel Craig`n4 Roger Moore`n3 Daniel Craig"
Roger Moore
Daniel Craig
Sean Connery

_{Edit - pas besoin d'utiliser [array] :: Reverse () quand l'indexation fera l'affaire}

Python 309 286 octets

import sys
i='Barry Nelson.Bob Simmons.Sean Connery.Roger Moore.David Niven.George Lazenby.Timothy Dalton.Pierce Brosnan.Daniel Craig'.split('.')
print ', '.join(i.pop(i.index(x)) for x in zip(*sorted((x.strip().split(' ',1) for x in sys.stdin),None,lambda x:int(x[0]),1))[1] if x in i)

JavaScript (ES6), 232 octets

s=>s.split`
`.sort((a,b)=>(p=parseInt)(a)<p(b)).map(l=>l.replace(/\d+ /,"")).filter(l=>!p[l]&/^(Barry Nelson|Bob Simmons|Sean Connery|Roger Moore|David Niven|George Lazenby|Timothy Dalton|Pierce Brosnan|Daniel Craig)$/.test(p[l]=l))

Explication

var solution =

s=>
  s.split`
`
  .sort((a,b)=>                 // sort the list by the number
    (p=parseInt)(a)<p(b)        // parseInt reads only the first number in a string
                                // the variable p also holds names that appeared in the
                                //     list previously
  )
  .map(l=>l.replace(/\d+ /,"")) // remove the number at the beginning of each line
  .filter(l=>
    !p[l]&                      // remove duplicates
    
    // Bond actor regex
    /^(Barry Nelson|Bob Simmons|Sean Connery|Roger Moore|David Niven|George Lazenby|Timothy Dalton|Pierce Brosnan|Daniel Craig)$/
    
    .test(p[l]=l)               // test for bondness and add the line to p
  )

<textarea id="input" rows="6" cols="40">1 Sean Connery
2 Emma Watson
5 Timothy Dalton
4 Roger Moore
3 Daniel Craig</textarea><br />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>