Fraction reduction: Difference between revisions

:*   Wikipedia entry:   [https://en.wikipedia.org/wiki/Anomalous_cancellation anomalous cancellation and/or accidental cancellation].

<br><br>

 

=={{header|C}}==

{{trans|C#}}

#include <stdio.h>

#include <stdlib.h>

 

return 0;

{{out}}

<pre>16/64 = 1/4 by omitting 6's

2988 have 9's omitted</pre>

 

 

}

 

}

 

 

 

}

 

}

}

}

}

}

 

}

}

}

{{out}}

<pre>16/64 = 1/4 by omitting 6's

2988 have 9's omitted</pre>

 

 

}

 

}

 

 

 

}

 

}

}

}

}

}

 

}

}

}

{{out}}

<pre>16/64 = 1/4 by omitting 6's

=={{header|D}}==

{{trans|C#}}

import std.stdio;

 

writeln;

}

{{out}}

<pre>16/64 = 1/4 by omitting 6's

351 have 8's omitted

2988 have 9's omitted</pre>

=={{header|Go}}==

===Version 1===

This produces the stats for 5-digit fractions in less than 25 seconds but takes a much longer 15.5 minutes to process the 6-digit case. Timings are for an Intel Core i7-8565U machine.

 

import (

}

fmt.Printf("Took %s\n", time.Since(start))

 

{{out}}

{{trans|Phix}}

Rather than iterate through all numbers in the n-digit range and check if they contain unique non-zero digits, this generates all such numbers to start with which turns out to be a much more efficient approach - more than 20 times faster than before.

 

import (

}

fmt.Printf("Took %s\n", time.Since(start))

 

{{out}}

 

Took 42.251172302s

</pre>

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.Collections;

 

}

{{out}}

<pre>

 

</pre>

=={{header|Julia}}==

 

toi(set) = parse(Int, join(set, ""))

 

testfractionreduction()

<pre>

For 2 digits, there were 4 fractions with anomalous cancellation.

=={{header|Kotlin}}==

{{trans|Go}}

for (i_j in s.withIndex()) {

if (n == i_j.value) {

println()

}

{{out}}

<pre>16/64 = 1/4 by omitting 6's

351 have 8's omitted

2988 have 9's omitted</pre>

 

=={{header|Pascal}}==

Using a permutation k out of n with k <= n<BR>

Inserting a record with this number and all numbers with one digit removed of that number.So only once calculated.Trade off is big size and no cache friendly local access.

program FracRedu;

{$IFDEF FPC}

writeln;

end;

{{out}}

<pre>

Took 1m38.85577279s

*/</pre>

 

=={{header|Python}}==

idx = 0

for straw in haystack:

return None

 

{{out}}

<pre>16/64 = 1/4 by omitting 6's

351 have 8's omitted

2988 have 9's omitted</pre>

 

=={{header|Racket}}==

Racket's generator is horribly slow, so I roll my own more efficient generator. Pretty much using continuation-passing style, but then using macro to make it appear that we are writing in the direct style.

 

 

(require racket/generator

(stats 5))

 

 

{{out}}

The digit 9 was crossed out 2988 times

</pre>

 

=={{header|REXX}}==

parse arg high show . /*obtain optional arguments from the CL*/

if high=='' | high=="," then high= 4 /*Not specified? Then use the default.*/

hasDup: parse arg x; /* if L<2 then return 0 */ /*L will never be 1.*/

do i=1 for L-1; if pos(substr(x,i,1), substr(x,i+1)) \== 0 then return 1

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 5 &nbsp; 12 </tt>}}

<pre>

For 5-digit fractions, there are 2988 with crossed-out 9's.

</pre>

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function IndexOf(n As Integer, s As Integer()) As Integer

End Sub

 

{{out}}

<pre>16/64 = 1/4 by omitting 6's

351 have 8's omitted

2988 have 9's omitted</pre>

 

=={{header|zkl}}==

{{trans|Phix}}

if(remove_digit!=0) digits=digits.copy().del(digits.index(remove_digit));

digits.reduce(fcn(s,d){ s*10 + d });

println("%d-digit fractions found: %d, omitted %s\n"

.fmt(n,count,omitted.concat(",")));

{{out}}

<pre>