Remove duplicates from my academic transcript

Question

Consider a list of subject, grade pairs. E.g.

[("Latin", "A"),  ("French", "A*"),  ("Math", "B"), ("Latin", "A*")]

The task is to return the same list but with each subject given at most once. Where a subject occurred more than once originally, the returned list should have the highest grade for that subject.

Using the UK system, "A*" is a better grade than "A" and of course "A" is better than "B" etc. Only "A" can be followed by an asterisk.

The output for this case should be:

[("Latin", "A*"),  ("French", "A*"),  ("Math", "B")]

Another example:

[("Latin", "A*"),  ("French", "A*"),  ("Math", "B"), ("French", "A*"), ("Math", "C")]

The output should be:

[("Latin", "A*"),  ("French", "A*"),  ("Math", "B")]

Your returned output list can be in any order you like.

This is code-golf, so the shortest code in bytes wins.

Languages I am hoping for:

• Python, because I wrote a terrible solution in python which inspired this question. Done.
• C. Because real men/women code in C when it makes no sense for the problem at hand. Done.
• Julia. Because it's an awesome language.

Input assumptions

You can assume there are no more than 10 subject/grade pairs, the input is printable ASCII and there are no spaces within the subject names.

Answer 1

Python, 52 bytes

lambda x:dict(sorted(x,key=lambda n:n[1][~0])[::-1])

is there a way to golf the list reversal?

Attempt This Online!

Answer 2

Haskell, 58 bytes

import Data.List
s=nubBy((.fst).(==).fst).sortOn(last.snd)

Try it online!

Haskell, 77 bytes

import Data.List
(c?f)a=c(f a).f
s=nubBy((==)?fst).sortBy(compare?(last.snd))

Try it online!

Haskell, 84 bytes

import Data.List;import Data.Function
s=nubBy(on(==)fst).sortBy(on compare$last.snd)

Try it online!

Haskell, 97 bytes

import Data.List;import Data.Function
g"A*"="@";g s=s
s=nubBy(on(==)fst).sortBy(on compare$g.snd)

Try it online!

Answer 3

Vyxal, 9 8 bytes

⁽hġ‡tṘv∵

Try it Online!

Sort by the reverse of each grade, group by subject, best of each subject group

-1 thanks to emanresuA

Explained

⁽hġ‡tṘv∵
⁽hġ       # Group subjects by their subject
      v∵  # Get the maximum of each group by
   ‡tṘ    # Reversed grade.

Answer 4

Elm, 82 bytes

import Dict
List.sortBy(Tuple.second>>String.reverse)>>List.reverse>>Dict.fromList

Takes a list and returns a dict.

>> is function composition in the reversed direction: f>>g in Elm is g.f in Haskell.

According to the source code of Elm's core package, Dict.fromList will keep the last value when there are duplicate keys.

You can try it here. Here is a full test program:

import Html exposing (text)

import Dict
f=List.sortBy(Tuple.second>>String.reverse)>>List.reverse>>Dict.fromList

main = 
  [("Latin", "A*"),  ("French", "B"),  ("Math", "A"), ("French", "A*"), ("Math", "C")]
  |> f
  |> Debug.toString
  |> text

Answer 5

Factor + sets.extras, 65 49 47 bytes

[ [ last last ] sort-with [ first ] unique-by ]

Attempt This Online!

• [ last last ] sort-with Sort the input by the last character of each grade.
• [ first ] unique-by Retain every entry that has a subject that has not been encountered before.

Answer 6

Jelly, 10 9 7 5 bytes

ZḢ«/ƙ

Try it online!

    ƙ    Group pairs by
ZḢ       their first elements,
    ƙ    and for each group
   /     reduce by
  «      recursively vectorizing minimum.

The vectorizing minimum leaves the shared subject name unchanged while taking the minimum of the letter grades, and the vectorization mechanism's length mismatch handling adds an asterisk if any of the grades for that subject has an asterisk.

Answer 7

Charcoal, 30 bytes

≔⦃⦄ηＦθＦ‹⮌§ι¹⮌∨§η§ι⁰Z§≔η§ι⁰§ι¹η

Attempt This Online! Link is to verbose version of code. Explanation:

≔⦃⦄η

Start with no grades.

Ｆθ

Loop over the input grades.

Ｆ‹⮌§ι¹⮌∨§η§ι⁰Z

If the reversed grade is less than the subject's reversed grade so far or Z if there is no grade yet, then...

§≔η§ι⁰§ι¹

... update the grade for that subject.

η

Output all of the grades in Python dict format.

Answer 8

Japt, 9 7 (6?) bytes

The second Ô could be removed if we could output the pairs in reverse order.

üÎËñÔÎÔ

Try it

üÎËñÔÎÔ     :Implicit input of 2D array
ü           :Group & sort by
 Î          :  First element
  Ë         :Map
   ñ        :  Sort by
    Ô       :    Reverse (mutating the arrays)
     Î      :  First element
            :  Reverse

---

6 bytes

I think this works but it needs more testing.

üÎËñÍÎ

Try it

Answer 9

JavaScript (Node.js), 42 bytes

x=>x.sort().filter(v=>[v[0]!=x,x=v[0]][0])

Try it online!

Requiring an extra empty slot after each pair, which looks not that elegant

JavaScript (Node.js), 55 bytes

x=>x.filter((v,i)=>!x.some(w=>v[0]>w[0]^[v,i--]>[w,0]))

Try it online!

JavaScript (Node.js), 53 bytes

x=>x.map(v=>!v.l[1]&v.l>o[v.n]||[o[v.n]=v.l],o={})&&o

Try it online!

Answer 10

Retina 0.8.2, 23 bytes

A\*
@$&
O`
D`.*,
G`,
@

Try it online! Takes input as a newline-separated list of subject, grade pairs. Explanation:

A\*
@$&

Prefix @ to any A* grades.

O`

Sort everything into lexical order.

D`.*,

Delete duplicate subjects.

G`,

Remove lines whose subjects were deleted.

@

Remove any @ prefixes.

Answer 11

awk, 53 bytes

51 bytes of AWK, in quotes, and 9 for shell invocation…

awk -F, '{if(t[$1]<$2)t[$1]=$2}END{for(s in t) print s,t[s]}'

As noticed by user Dominic van Essen, there're cases that should be fixed that way (from 51 to 53):

awk -F, '$2$2<=t[$1]$2$2{t[$1]=$2}END{for(s in t)print s,t[s]}'

If use of blank delimiters (space or tab) is allowed, we can shorten invocation with removal of -F, (4 bytes)

Usage and notes

…assuming that the table/list is represented by a pair subject,grade per line. Then, you can echo the list directly

... | invocation

or put the list in a file

invocation < grades.txt

To try, first create the grade.txt file this way

cat >grade.txt <<-EOF
  foo,A
  bar,A
  foo,A*
  baz,D
  fiz,E
  baz,B
EOF

or with nano grade.txt for example.

Ungolfed/explanation

For golfing purposes I've used one letter variables and removed some extra spaces usually good for readability.

BEGIN {           # this block is processed once before main
IFS=","           # change Input Field Separator to comma...
}                 # ...or done via command option `-F ','`
{                 # this is the main block, executed for each line
  if (T[$1]<$2)   # build a Table indexed by first field (subject)
                  # when the second field (current grade) is greater
                  # than the existing value (cell initially empty) 
      T[$1]=$2    # then replace the table value with current grade
}
END {             # this block is executed once after main processing
  for(S in T)     # loop over the grades Table indexed by Subject
     print S,T[S] # for each entry, output the key (the Subject then)
                  # and the associated value (the maximum grade then)
}

I'm sure an AWK guru can improve it a little.

Answer 12

05AB1E, 10 bytes

.¡н}εΣθR}н

Try it online.

Explanation:

.¡ }        # Group the (implicit) input-list of pairs by:
  н         #  The first string of the pair (the subject)
    ε       # Then map over each group:
     Σ  }   #  Sort the list of pairs in this group by:
      θ     #   The last string of the pair (the grade)
       R    #   Reversed
         н  #  Then just keep the first pair
            # (after which the result is output implicitly)

Answer 13

Perl 5 -a, 66 bytes

$f{$F[0]}.=$F[1]}{pairmap{say"$a ",(sort$b=~/./g)[0]=~s/\*/A*/r}%f

Try it online!

Answer 14

Excel (ms365), 88 bytes

Formula in C1:

=LET(x,SORTBY(A1:B4,"*"&B1:B4,-1),y,TAKE(x,,1),FILTER(x,MATCH(y,y,0)=SEQUENCE(ROWS(x))))

Answer 15

Bash, 72 bytes

tr 'ABC*' '3210' | sort -k 2,2 -n -r | sort -k 1,1 -u | tr '3210' 'ABC*'

Try it online!

---

Original Input

Latin A*
French A
Math B
French A*
Math C

tr 'ABC*' '3210'
^{Convert marks into numbers}

Latin 30
French 3
Math 2
French 30
Math 1

sort -k 2,2 -n -r
^{Numeric sort using the 2nd field; reverse order}

French 30
French 3
Latin 30
Math 2
Math 1

sort -k 1,1 -u
^{Sort using the 1st field only (already sorted); keep unique entries}

French 30
Latin 30
Math 2

tr '3210' 'ABC*'
^{Reverse conversion}

French A*
Latin A*
Math B

Answer 16

Arturo, 66 bytes

$[a][select a'x[every? select a'y->x\0=y\0'z[>=last z\1last x\1]]]

Try it

$[a][                                ; a function taking an argument a
  select a'x[                        ; select pairs in a; assign current pair to x
    every?      <block>       'z[    ; is every element z in <block> true?
           select a'y->x\0=y\0       ; select pairs in a where subject = x's subject
      >=last z\1last x\1             ; is the last letter of z's grade >= x's?
    ]                                ; end every?
  ]                                  ; end select
]                                    ; end function

Answer 17

C (gcc), 183 177 164 155 bytes

-7 bytes thanks to ceilingcat; -13 bytes thanks to Neil; -8 bytes thanks to l4m2

#define F for(j=0;j<l;j++){for(i=0;strcmp(s[i],s[j]);i++);
i,j;f(s,g,l)char**s,**g;{F*g[i]>*g[j]|g[j][1]?g[i]=g[j]:0;}F i-j?:printf("%s %s\n",s[i],g[i]);}}

Defines a function f that takes an array of subjects, an array of grades, and an integer representing the length of both arrays. It prints each subject and the best grade in that subject to stdout. Try it online!

Ungolfed/explanation

This is an awful mess still pretty hacky, but looking a bit nicer than it originally did.

#include <stdio.h>
#include <string.h>

int i, j;
int f(char *subjects[], char *grades[], int length) {
  // Loop through the arrays using index j
  for(j = 0; j < length; j++) {
    // For each j, loop through the indices i before it until reaching one with the
    // same subject (i.e. the first entry for that subject)
    for(i = 0; strcmp(subjects[i], subjects[j]); i++);
    // Compare the grades by comparing their first characters (smaller characters
    // are better); if the first characters are the same, check if the second
    // grade has a second character (star is better than no star)
    // If the grade at index j is better than the grade at index i...
    if(grades[i][0] > grades[j][0] || grades[j][1]) {
      // Change the grade at index i to point to the grade at index j instead
      grades[i] = grades[j];
    }
  }
  // Loop through the arrays again
  for(j = 0; j < length; j++) {
    // Find the first entry for this subject
    for(i = 0; strcmp(subjects[i], subjects[j]); i++);
    // If the current entry is the first entry for this subject...
    if(i == j) {
      // Output the subject and the associated grade
      printf("%s %s\n", subjects[i], grades[i]);
    }
  }
}