Third Biggest Number

April 13, 2018

Today’s exercise is for all the beginning programming students who read this blog:

Write a program to read ten numbers input by the user and write the third largest of those ten numbers.

Your task is to write the program described above. When you are finished, you are welcome to read or run a suggested solution, or to post your own solution or discuss the exercise in the comments below.

Advertisements

Pages: 1 2

12 Responses to “Third Biggest Number”

  1. mcmillhj said

    Alternate solution keeps track of the three largest values using an array:

    #!perl
    
    use strict;
    use warnings;
    
    use feature qw(say);
    
    my @biggest3 = (0, 0, 0);
    while(my $n = readline(*DATA)) {
      chomp $n;
      foreach my $i (0 .. $#biggest3) {
        if ($n >= $biggest3[$i]) {
          my $tmp = $biggest3[$i];
          $biggest3[$i] = $n;
          foreach my $k ($i + 1 .. $#biggest3) {
            ($biggest3[$k], $tmp) = ($tmp, $biggest3[$k]);
          }
          last;
        }
      }
    }
    
    say $biggest3[-1];
    
    __DATA__
    14
    23
    102
    97
    29
    4
    19
    85
    53
    111
    
  2. kgashok said
    int third_biggest(int arr[], int size){
        int third = -1; 
        int second = -1; 
        int biggest = -1;
        printf("size: %d\n", size); 
        int i = 0;
        while (size > i){
            if (arr[i] > biggest) {
                third = second; 
                second = biggest; 
                biggest = arr[i];
            }
            else if (arr[i] > second){
                third = second; 
                second = arr[i];
            }
            else if (arr[i] > third)
                third = arr[i];
            
            i++;
            printf("third: %d\n", third); 
        }
        return third;
        
    }
    
    int main() { 
        int input={100, 7, 50, 1, 2, 3, 4, 5, 6, 40};
        int size = sizeof(input) / sizeof(int);
    
        printf("third largest %d\n", third_biggest(input, size));  // 40 is the answer
        return 0;
    }
    
  3. Steve said

    Mumps solutions

    zjsg     ;
             q
    3rd      ;
             k arr
             f i=1:1:10 r !,"Enter number: ",x s arr(x)=1
             w !!,"3rd number is ",$o(arr($o(arr($o(arr(""))))))
             q
    

    USER>k

    USER>d 3rd^zjsg

    Enter number: 999999
    Enter number: 10000
    Enter number: 2345
    Enter number: 781
    Enter number: 56
    Enter number: 1
    Enter number: 2
    Enter number: 99
    Enter number: 678
    Enter number: 3456

    3rd number is 56

  4. Globules said

    A Haskell version.

    -- Given a series of integers on standard input first remove duplicates, then
    -- print the 3'rd biggest number of those remaining, if it exists.
    --
    -- Why remove duplicates?  Consider the list [1, 1, 2, 2, 3, 3].  The third
    -- biggest number in the list is 1, not 2 (the third element after sorting).
    
    import Data.List.Ordered (nubSortOn)
    import Data.Ord (Down(Down))
    
    -- Just the n'th element of a list (starting at 1) or Nothing if n < 1 or if the
    -- list has fewer than n elements.
    nth :: Int -> [a] -> Maybe a
    nth n xs = if n < 1 then Nothing else go n xs
      where go _ [] = Nothing
            go 1 (y:_) = Just y
            go m (_:ys) = go (m-1) ys
    
    -- Just the n'th biggest element of the list after duplicates have been removed,
    -- or Nothing if there are fewer than n elements left.
    nthBiggest :: Ord a => Int -> [a] -> Maybe a
    nthBiggest n = nth n . nubSortOn Down
    
    main :: IO ()
    main = do
      x <- nthBiggest 3 . map read . words <$> getContents
      print (x :: Maybe Int)
    
    $ (jot 10 3 8 | tee /dev/fd/2) | ./third
    3
    4
    4
    5
    5
    6
    6
    7
    7
    8
    Just 6
    $ (jot 10 1 1 | tee /dev/fd/2) | ./third
    1
    1
    1
    1
    1
    1
    1
    1
    1
    1
    Nothing
    
  5. Milbrae said

    Python 3

    import random
    
    def third_biggest(seq):
        uniq = sorted(set(seq))
        return uniq[-3:-2] if len(uniq) > 2 else None
    
    if __name__ == "__main__":
        data = [random.randint(1, 10**6) for k in range(10)]
        print (data)
        print (third_biggest(data))
    

    Sample output:
    [76631, 719928, 63284, 348692, 521266, 687164, 663331, 845208, 466387, 33721]
    [687164]

  6. V said

    Ruby. Assumes clean input of positive integers. This is a trick question right?

    puts "#{10.times.map { print "Enter a number: "; Integer(gets) }.uniq.sort[-3] || 'Nop'}"    
    
  7. V said

    My previous entry is invalid Ruby. This one does the trick.

    puts 10.times.map { print "Enter a number: "; Integer(gets) }.uniq.sort[-3] || 'Nop'
    
  8. PowerShell said

    (1..10 | % { (Read-Host -Prompt “Enter a number”) -as [int] } | Sort -Unique)[-3]

  9. V said

    A translation of my Ruby version in Go.

    package main

    import (
    "fmt"
    "sort"
    )

    func main() {
    numbers := make([]int, 10)

    // Get numbers from user
    for i := range numbers {
    fmt.Print("Enter a number: ")
    fmt.Scan(&numbers[i])
    }

    // Remove duplicates
    uniqNumbers := []int{}
    m := make(map[int]bool)
    for _, x := range numbers {
    m[x] = true
    }
    for k, _ := range m {
    uniqNumbers = append(uniqNumbers, k)
    }

    if len(uniqNumbers) < 3 {
    fmt.Println("Nop")
    return
    }

    // Sort in descending order
    sort.Sort(sort.Reverse(sort.IntSlice(numbers)))
    fmt.Println("Third lagest is:", numbers[2])
    }

  10. Scott McMaster said

    A classic interview answer is to use a min-heap of fixed-size:

    import java.util.PriorityQueue;
    import java.util.Scanner;
    
    public class ThirdBiggest {
    
      public static void main(String[] args) {
        PriorityQueue<Integer> numbers = new PriorityQueue<>();
        
        System.out.println("Enter 10 numbers:");
        Scanner sc = null;
        try {
          sc = new Scanner(System.in);
          for (int i = 0; i < 10; i++) {
            int num = sc.nextInt();
            if (numbers.size() < 3) {
              numbers.add(num);
            } else if (num >= numbers.peek()){
              numbers.remove();
              numbers.add(num);
            }
          }
        } finally {
          if (sc != null) {
            sc.close();
          }
        }
        System.out.println("The third biggest is " + numbers.peek());
      }
    }
    
  11. Nicky Marler said

    Kotlin with a recursion approach. Give the first parameter

    fun main(args: Array) {
    var myList = mutableListOf(1,65,89,45,32,75,11,32,82,11)
    println(recThirdBig(myList,null,null,null))
    }

    tailrec fun recThirdBig(testList: List, oneBig: Int?, twoBig: Int?, threeBig: Int?): Int? {
    if (testList.isEmpty()) return threeBig
    if (oneBig == null || testList[0] > oneBig) return recThirdBig(testList.drop(1), testList[0], oneBig, twoBig)
    if (twoBig == null || testList[0] > twoBig) return recThirdBig(testList.drop(1), oneBig, testList[0], twoBig)
    if (threeBig == null || testList[0] > threeBig) return recThirdBig(testList.drop(1), oneBig, twoBig, testList[0])
    return recThirdBig(testList.drop(1), oneBig, twoBig, threeBig)
    }

  12. Daniel said

    This is similar to a prior problem.

    Here’s a solution in C.

    #include <stdbool.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    #define N_ENTERED 10
    #define N_RETAINED 3
    
    int main(void) {
      int array[N_RETAINED];
      for (size_t i = 0; i < N_ENTERED; ++i) {
        int x;
        while (true) {
          printf("Enter Number %zu: ", i+1);
          int n_assigned = scanf("%d", &x);
          size_t n_trailing = 0;
          while (getchar() != '\n') ++n_trailing;
          if (n_assigned == 1 && n_trailing == 0) break;
        }
        bool reorder = true;
        if (i < N_RETAINED) {
          array[i] = x;
        } else if (x > array[0]) {
          array[0] = x;
        } else {
          reorder = false;
        }
        if (reorder) {
          for (size_t j = 1; j < N_RETAINED; ++j) {
            if (j > i) break;
            if (array[j-1] > array[j]) {
              int tmp = array[j-1];
              array[j-1] = array[j];
              array[j] = tmp;
            }
          }
        }
      }
      printf("Biggest Number %d: %d\n", N_RETAINED, array[0]);
      return EXIT_SUCCESS;
    }
    

    Example:

    $ ./third_biggest 
    Enter Number 1: 20       
    Enter Number 2: 64
    Enter Number 3: 96
    Enter Number 4: 28
    Enter Number 5: 83
    Enter Number 6: 58
    Enter Number 7: 63
    Enter Number 8: 33
    Enter Number 9: 37
    Enter Number 10: 70
    Biggest Number 3: 70
    

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: