English cardinal anagrams

Certain numbers, when spelled out in their English cardinal representation, are anagrams of other numbers.

English cardinal anagrams is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Some are very obvious: sixty-seven <=> seventy-six

Others are a little more subtle: one hundred twelve <=> two hundred eleven

Task

• Find and display the first thirty numbers that are a member of English cardinal anagrams, starting from zero.
• Find and display the count of English cardinal anagrams from zero to one thousand.
• Find and display the largest group(s) of English cardinal anagrams from zero to one thousand.

Stretch

• Find and display the count of English cardinal anagrams from zero to ten thousand, restricted to numbers within those bounds. (Ignore anagrams of numbers outside those bounds. E.G. 1010 <=> 10001)
• Find and display the largest group(s) of English cardinal anagrams from zero to ten thousand.

See also

• OEIS::A169936 - Numbers whose name in English is an anagram of the name of another number
• Related task: Number names

J

This example is incorrect. Please fix the code and remove this message. Details: Counts for English cardinal anagrams in 0 through 1000 and 0 through 10000 seem way off, though admittedly it is difficult to tell as nothing is labeled

Using the definitions at Number_names#J and

sample=: I.(e. ~. #~ 1<#/.~)/:~@uk&.> i. 1e6

largegroups=: {{
   tokens=. /:~@uk&.> y
   utokens=. ~. tokens
   ucounts=. #/.~ tokens
   uids=. utokens #~ (=>./) ucounts
   >}.y </.~ uids i. tokens
}}

We get:

   3 10$ sample
 67  69  76  79  96  97 102 103 104 105
106 107 108 109 112 122 123 124 125 126
127 128 129 132 133 134 135 136 137 138
   +/1000>:sample
680
   largegroups (#~ 1000&>:) sample
679 697 769 796 967 976

Stretch:

   +/10000>:sample
9662
   largegroups (#~ 10000&>:) sample
1679 1697 1769 1796 1967 1976 6179 6197 6791 6971 7169 7196 7691 7961 9167 9176 9671 9761
2679 2697 2769 2796 2967 2976 6279 6297 6792 6972 7269 7296 7692 7962 9267 9276 9672 9762
3679 3697 3769 3796 3967 3976 6379 6397 6793 6973 7369 7396 7693 7963 9367 9376 9673 9763
4679 4697 4769 4796 4967 4976 6479 6497 6794 6974 7469 7496 7694 7964 9467 9476 9674 9764
5679 5697 5769 5796 5967 5976 6579 6597 6795 6975 7569 7596 7695 7965 9567 9576 9675 9765
6798 6879 6897 6978 7698 7869 7896 7968 8679 8697 8769 8796 8967 8976 9678 9768 9867 9876

Phix

for limit in {1000, 10000} do
    sequence ana = {}, ani = {}
    for i=0 to limit do
        string key = trim(sort(ordinal(i,true)))
        integer k = find(key,ana)
        if k then
            ani[k] &= i
        else
            ana = append(ana,key)
            ani = append(ani,{i})
        end if
    end for
    sequence lengths = apply(ani,length)
    if limit==1000 then
        sequence all = {}
        for i,l in lengths do
            if l>1 then all &= ani[i] end if
        end for
        all = sort(deep_copy(all))[1..30]
        printf(1,"First 30 English cardinal anagrams:\n%s\n",
                 join_by(all,1,10," ",fmt:="%3d"))
    end if
    printf(1,"Count of English cardinal anagrams up to %,d: %,d\n\n",
             {limit, length(filter(lengths,">",1))})
    integer maxlen = max(lengths)
    sequence biggest = {}
    for i,l in lengths do
        if l=maxlen then
            biggest = append(biggest,"["&join(ani[i]," ",fmt:="%d")&"]")
        end if
    end for
    printf(1,"Largest group%s of English cardinal anagrams up to %,d:\n %s\n\n",
              {iff(length(biggest)=1?"":"s"),limit,join(biggest,"\n ")})
end for

Output:

First 30 English cardinal anagrams:
 67  69  76  79  96  97 102 103 104 105
106 107 108 109 112 122 123 124 125 126
127 128 129 132 133 134 135 136 137 138

Count of English cardinal anagrams up to 1,000: 317

Largest group of English cardinal anagrams up to 1,000:
 [679 697 769 796 967 976]

Count of English cardinal anagrams up to 10,000: 2,534

Largest groups of English cardinal anagrams up to 10,000:
 [1679 1697 1769 1796 1967 1976 6179 6197 6791 6971 7169 7196 7691 7961 9167 9176 9671 9761]
 [2679 2697 2769 2796 2967 2976 6279 6297 6792 6972 7269 7296 7692 7962 9267 9276 9672 9762]
 [3679 3697 3769 3796 3967 3976 6379 6397 6793 6973 7369 7396 7693 7963 9367 9376 9673 9763]
 [4679 4697 4769 4796 4967 4976 6479 6497 6794 6974 7469 7496 7694 7964 9467 9476 9674 9764]
 [5679 5697 5769 5796 5967 5976 6579 6597 6795 6975 7569 7596 7695 7965 9567 9576 9675 9765]
 [6798 6879 6897 6978 7698 7869 7896 7968 8679 8697 8769 8796 8967 8976 9678 9768 9867 9876]

Raku

use Lingua::EN::Numbers;
use List::Allmax;

for 1_000, 10_000 {
    my %eca; # English cardinal anagrams
    (^$_).map: { %eca{.&cardinal.comb.sort.join}.push: $_ }

    once say "\nFirst 30 English cardinal anagrams:\n " ~
    (sort flat %eca.grep(+*.value > 1)».value.map: *.flat)[^30]\
    .batch(10)».fmt("%3d").join: "\n ";

    say "\nCount of English cardinal anagrams up to {.&comma}: " ~
        +%eca.grep(+*.value > 1)».value.map: *.flat;

    say "\nLargest group(s) of English cardinal anagrams up to {.&comma}:\n [" ~
        %eca.&all-max( :by(+*.value) )».value.sort.join("]\n [") ~ ']'
}

Output:

First 30 English cardinal anagrams:
  67  69  76  79  96  97 102 103 104 105
 106 107 108 109 112 122 123 124 125 126
 127 128 129 132 133 134 135 136 137 138

Count of English cardinal anagrams up to 1,000: 317

Largest group(s) of English cardinal anagrams up to 1,000:
 [679 697 769 796 967 976]

Count of English cardinal anagrams up to 10,000: 2534

Largest group(s) of English cardinal anagrams up to 10,000:
 [1679 1697 1769 1796 1967 1976 6179 6197 6791 6971 7169 7196 7691 7961 9167 9176 9671 9761]
 [2679 2697 2769 2796 2967 2976 6279 6297 6792 6972 7269 7296 7692 7962 9267 9276 9672 9762]
 [3679 3697 3769 3796 3967 3976 6379 6397 6793 6973 7369 7396 7693 7963 9367 9376 9673 9763]
 [4679 4697 4769 4796 4967 4976 6479 6497 6794 6974 7469 7496 7694 7964 9467 9476 9674 9764]
 [5679 5697 5769 5796 5967 5976 6579 6597 6795 6975 7569 7596 7695 7965 9567 9576 9675 9765]
 [6798 6879 6897 6978 7698 7869 7896 7968 8679 8697 8769 8796 8967 8976 9678 9768 9867 9876]

Wren

Library: Wren-sort

Library: Wren-fmt

I've reused the code for determining the number names from the related task.

import "./sort" for Sort
import "./fmt" for Fmt

var small = [
    "zero", "one", "two", "three", "four", "five", "six",  "seven", "eight", "nine", "ten", "eleven",
    "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"
]

var tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"]

var illions = ["", " thousand", " million", " billion"," trillion", " quadrillion", " quintillion"]

var say
say = Fn.new { |n|
    var t = ""
    if (n < 0) {
        t = "negative "
        n = -n
    }
    if (n < 20) {
        t = t + small[n]
    } else if (n < 100) {
        t = t + tens[(n/10).floor]
        var s = n % 10
        if (s > 0) t = t + "-" + small[s]
    } else if (n < 1000) {
        t = t + small[(n/100).floor] + " hundred"
        var s = n % 100
        if (s > 0) t = t + " " + say.call(s)
    } else {
        var sx = ""
        var i = 0
        while (n > 0) {
            var p = n % 1000
            n = (n/1000).floor
            if (p > 0) {
                var ix = say.call(p) + illions[i]
                if (sx != "") ix = ix + " " + sx
                sx = ix
            }
            i = i + 1
        }
        t = t + sx
    }
    return t
}

for (limit in [1000, 10000]) {
    var ana = {}
    for (i in 0..limit) {
        var key = Sort.quick(say.call(i).toList).join("")
        if (ana.containsKey(key)) {
            ana[key].add(i)
        } else {
            ana[key] = [i]
        }
    }
    if (limit == 1000) {
        var all = []
        for (v in ana.values) {
            if (v.count > 1) all.addAll(v)
        }
        System.print("First 30 English cardinal anagrams:")
        Fmt.tprint("$3d", all.sort().take(30), 10)
        System.print()
    }
    var count = ana.count { |me| me.value.count > 1 }
    Fmt.print("Count of English cardinal anagrams up to $,d: $,d", limit, count)
    var max = 0
    var largest
    for (v in ana.values) {
        if (v.count > max) {
            max = v.count
            largest = [v]
        } else if (v.count == max) {
            largest.add(v)
        }
    }
    Fmt.print("\nLargest group(s) of English cardinal anagrams up to $,d:", limit)
    largest.sort { |l1, l2| l1[0] < l2[0] }
    System.print(largest.map { |l| "[" + l.join(" ") + "]" }.join("\n"))
    if (limit == 1000) System.print()
}

Output:

First 30 English cardinal anagrams:
 67  69  76  79  96  97 102 103 104 105
106 107 108 109 112 122 123 124 125 126
127 128 129 132 133 134 135 136 137 138

Count of English cardinal anagrams up to 1,000: 317

Largest group(s) of English cardinal anagrams up to 1,000:
[679 697 769 796 967 976]

Count of English cardinal anagrams up to 10,000: 2,534

Largest group(s) of English cardinal anagrams up to 10,000:
[1679 1697 1769 1796 1967 1976 6179 6197 6791 6971 7169 7196 7691 7961 9167 9176 9671 9761]
[2679 2697 2769 2796 2967 2976 6279 6297 6792 6972 7269 7296 7692 7962 9267 9276 9672 9762]
[3679 3697 3769 3796 3967 3976 6379 6397 6793 6973 7369 7396 7693 7963 9367 9376 9673 9763]
[4679 4697 4769 4796 4967 4976 6479 6497 6794 6974 7469 7496 7694 7964 9467 9476 9674 9764]
[5679 5697 5769 5796 5967 5976 6579 6597 6795 6975 7569 7596 7695 7965 9567 9576 9675 9765]
[6798 6879 6897 6978 7698 7869 7896 7968 8679 8697 8769 8796 8967 8976 9678 9768 9867 9876]