1 | list | login |load

| {202:202} 543ms |

_h1 hamming number | [[1|?view=hamming_numbers]] | [[2|?view=hamming_numbers2]] | 3 | [[4|?view=hamming_numbers4]]

_h2 1) compute

_p Build a table of {b 2{sup i}•3{sup j}•5{sup k}} from {b i,j,k = 0} to {b n} and sort it.

{prewrap
'{def ham
 {lambda {:n}
  {S.sort <
   {S.map {{lambda {:n :i}
   {S.map {{lambda {:n :i :j} ;; {div}
   {S.map {{lambda {:i :j :k} 
                   {* {pow 2 :i} {pow 3 :j} {pow 5 :k}}} :i :j}
   {S.serie 0 :n} } } :n :i}
   {S.serie 0 :n} } } :n}
   {S.serie 0 :n} }
}}} 
-> {def ham
 {lambda {:n}
  {S.sort <
   {S.map {{lambda {:n :i}
   {S.map {{lambda {:n :i :j} ;; {div}
   {S.map {{lambda {:i :j :k} 
                   {* {pow 2 :i} {pow 3 :j} {pow 5 :k}}} :i :j}
   {S.serie 0 :n} } } :n :i}
   {S.serie 0 :n} } } :n}
   {S.serie 0 :n} }
}}}

'{def H {ham 30}}
-> {def H {ham 30}}

'{S.slice 0 19 {H}}
-> {S.replace , by space in {S.slice 0 19 {H}}}

'{S.get 1690 {H}} 
-> {S.get 1690 {H}}  
  
}

_h2 2) display
_p Display a hamming number as 2{sup a}•3{sup b}•5{sup c}

{pre
'{def factor
 {def factor.r
  {lambda {:n :i}
   {if {> :i :n}
    then 
    else {if {= {% :n :i} 0}
    then :i {factor.r {/ :n :i} :i}
    else {factor.r :n {+ :i 1}} }}}}
 {lambda {:n}
  :n is the product of 1 {factor.r :n 2} }}
-> {def factor
 {def factor.r
  {lambda {:n :i}
   {if {> :i :n}
    then 
    else {if {= {% :n :i} 0}
    then :i {factor.r {/ :n :i} :i}
    else {factor.r :n {+ :i 1}} }}}}
 {lambda {:n}
  :n is the product of 1 {factor.r :n 2} }}

'{def asproductofpowers
 {def asproductofpowers.loop
  {lambda {:a :b :c :n}
   {if {= {S.first :n} 1}
    then 2{sup :a}•3{sup :b}•5{sup :c}
    else {asproductofpowers.loop
          {if {= {S.first :n} 2} then {+ :a 1} else :a}
          {if {= {S.first :n} 3} then {+ :b 1} else :b}
          {if {= {S.first :n} 5} then {+ :c 1} else :c}
          {W.rest :n} }
 }}}
 {lambda {:n}
  {asproductofpowers.loop 0 0 0 {S.reverse :n}}}}
-> {def asproductofpowers
 {def asproductofpowers.loop
  {lambda {:a :b :c :n}
   {if {= {S.first :n} 1}
    then 2{sup :a}•3{sup :b}•5{sup :c}
    else {asproductofpowers.loop
          {if {= {S.first :n} 2} then {+ :a 1} else :a}
          {if {= {S.first :n} 3} then {+ :b 1} else :b}
          {if {= {S.first :n} 5} then {+ :c 1} else :c}
          {W.rest :n} }
 }}}
 {lambda {:n}
  {asproductofpowers.loop 0 0 0 {S.reverse :n}}}}

'{factor 2125764000}
-> {factor 2125764000}

'{asproductofpowers {factor 2125764000}}
-> {asproductofpowers {factor 2125764000}}

'{S.map {lambda {:i} {div}:i: {S.get :i {H}} =
                    {asproductofpowers {factor {S.get :i {H}}}}} 
       {S.serie 0 19}}
->
{S.map {lambda {:i} {div}:i: {S.get :i {H}} = {asproductofpowers {factor {S.get :i {H}}}}} {S.serie 0 19}}

}

{script 
LAMBDATALK.DICT['BigInt'] = function() {
  var args = arguments[0].trim();
  return BigInt( Number(args) )
};

LAMBDATALK.DICT['BI.+'] = function() {
  var args = arguments[0].trim().split(' ');
  return BigInt( args[0] ) + BigInt( args[1] )
};
LAMBDATALK.DICT['BI.-'] = function() {
  var args = arguments[0].trim().split(' ');
  return BigInt( args[0] ) - BigInt( args[1] )
};
LAMBDATALK.DICT['BI.*'] = function() {
  var args = arguments[0].trim().split(' ');
  return BigInt( args[0] ) * BigInt( args[1] )
};
LAMBDATALK.DICT['BI./'] = function() {
  var args = arguments[0].trim().split(' ');
  return BigInt( args[0] ) / BigInt( args[1] )
};
LAMBDATALK.DICT['BI.%'] = function() {
  var args = arguments[0].trim().split(' ');
  return BigInt( args[0] ) % BigInt( args[1] )
};
LAMBDATALK.DICT['BI.**'] = function() {
  var args = arguments[0].trim().split(' ');
  return BigInt( args[0] ) ** BigInt( args[1] )
};

/*
LAMBDATALK.DICT['BI.min'] = function() {   // {BI.min a b c}
  var args = arguments[0].trim().split(" "),
         a = BigInt(args[0]),
         b = BigInt(args[1]),
         c = BigInt(args[2]); 
  return ((a < b) && (a < c)) ?
          a : ((b < a) && (b < c)) ?
          b : c
};
*/

LAMBDATALK.DICT['BI.min'] = function() {   // {BI.min a b}
  var args = arguments[0].trim().split(" "),
         a = BigInt(args[0]),
         b = BigInt(args[1]);
  return ( a < b ) ? a : b
};

LAMBDATALK.DICT['removedup'] = function() {  // {removedup a b c ...}
  var args = arguments[0].trim().split(" ");
  var out = [args[0]];
  for (var i=1; i < args.length; i++)
    if (args[i] !== args[i-1]) out.push( args[i] )
  return out.join(" ")
};

}

hamming number | 1 | 2 | 3 | 4

1) compute

Build a table of 2ⁱ•3^j•5^k from i,j,k = 0 to n and sort it.

{def ham
 {lambda {:n}
  {S.sort <
   {S.map {{lambda {:n :i}
   {S.map {{lambda {:n :i :j} 
   {S.map {{lambda {:i :j :k} 
                   {* {pow 2 :i} {pow 3 :j} {pow 5 :k}}} :i :j}
   {S.serie 0 :n} } } :n :i}
   {S.serie 0 :n} } } :n}
   {S.serie 0 :n} }
}}} 
-> ham 

{def H {ham 30}}
-> H

{S.slice 0 19 {H}}
-> 1 2 3 4 5 6 8 9 10 12 15 16 18 20 24 25 27 30 32 36

{S.get 1690 {H}} 
-> 2125764000

2) display

Display a hamming number as 2^a•3^b•5^c

{def factor
 {def factor.r
  {lambda {:n :i}
   {if {> :i :n}
    then 
    else {if {= {% :n :i} 0}
    then :i {factor.r {/ :n :i} :i}
    else {factor.r :n {+ :i 1}} }}}}
 {lambda {:n}
  :n is the product of 1 {factor.r :n 2} }}
-> factor

{def asproductofpowers
 {def asproductofpowers.loop
  {lambda {:a :b :c :n}
   {if {= {S.first :n} 1}
    then 2{sup :a}•3{sup :b}•5{sup :c}
    else {asproductofpowers.loop
          {if {= {S.first :n} 2} then {+ :a 1} else :a}
          {if {= {S.first :n} 3} then {+ :b 1} else :b}
          {if {= {S.first :n} 5} then {+ :c 1} else :c}
          {W.rest :n} }
 }}}
 {lambda {:n}
  {asproductofpowers.loop 0 0 0 {S.reverse :n}}}}
-> asproductofpowers  

{factor 2125764000}
-> 2125764000 is the product of 1 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 5 5 5 

{asproductofpowers {factor 2125764000}}
-> 2⁵•3¹²•5³

{S.map {lambda {:i} {div}:i: {S.get :i {H}} =
                    {asproductofpowers {factor {S.get :i {H}}}}} 
       {S.serie 0 19}}
->
0: 1 = 2⁰•3⁰•5⁰ 
1: 2 = 2¹•3⁰•5⁰ 
2: 3 = 2⁰•3¹•5⁰ 
3: 4 = 2²•3⁰•5⁰ 
4: 5 = 2⁰•3⁰•5¹ 
5: 6 = 2¹•3¹•5⁰ 
6: 8 = 2³•3⁰•5⁰ 
7: 9 = 2⁰•3²•5⁰ 
8: 10 = 2¹•3⁰•5¹ 
9: 12 = 2²•3¹•5⁰ 
10: 15 = 2⁰•3¹•5¹ 
11: 16 = 2⁴•3⁰•5⁰ 
12: 18 = 2¹•3²•5⁰ 
13: 20 = 2²•3⁰•5¹ 
14: 24 = 2³•3¹•5⁰ 
15: 25 = 2⁰•3⁰•5² 
16: 27 = 2⁰•3³•5⁰ 
17: 30 = 2¹•3¹•5¹ 
18: 32 = 2⁵•3⁰•5⁰ 
19: 36 = 2²•3²•5⁰