Fraction reduction: Difference between revisions

{{trans|Python}}

 

V idx = 0

L(straw) haystack

j++

print()

 

{{out}}

=={{header|Ada}}==

{{trans|Python}}

with Ada.Text_IO; use Ada.Text_IO;

procedure Fraction_Reduction is

end loop;

 

=={{header|C}}==

{{trans|C#}}

#include <stdio.h>

#include <stdlib.h>

 

return 0;

{{out}}

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

=={{header|C sharp|C#}}==

{{trans|Kotlin}}

 

namespace FractionReduction {

}

}

{{out}}

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

=={{header|C++}}==

{{trans|D}}

#include <iomanip>

#include <iostream>

 

return 0;

{{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

===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}}

=={{header|Groovy}}==

{{trans|Java}}

static void main(String[] args) {

for (int size = 2; size <= 5; size++) {

return true

}

 

=={{header|Haskell}}==

import Data.List (intersect, unfoldr, delete, nub, group, sort)

import Text.Printf (printf)

where

groups = [ findGroupReductions [10^1..99], findGroupReductions [10^2..999]

{{out}}

<pre>16/64 = 1/4 by dropping 6

=={{header|J}}==

The algorithm generates all potential rational fractions of given size in base 10 and successively applies conditions to restrict the candidates. By avoiding boxing and rational numbers this version is much quicker than that which may be found in the page history.

Filter=: (#~`)(`:6)

assert 'ac' -: 1 0 1"_ Filter 'abc'

result

)

<pre>

 

=={{header|Java}}==

import java.util.ArrayList;

import java.util.Collections;

 

}

{{out}}

<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

=={{header|Lua}}==

{{trans|C++}}

for idx,straw in pairs(haystack) do

if straw == needle then

end

 

{{out}}

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

351 have 8's omitted

2988 have 9's omitted</pre>

 

=={{header|MiniZinc}}==

===The Model===

%Fraction Reduction. Nigel Galloway, September 5th., 2019

include "alldifferent.mzn"; include "member.mzn";

 

output [show(n)++"/"++show(i)++" becomes "++show(e)++"/"++show(g)++" when "++show(w)++" is omitted"]

===The Tasks===

;Displaying 12 solutions

{{trans|Phix}}

Using Phix algorithm with some adaptations.

# Fraction reduction.

 

echo &"{n}-digit fractions found: {count}, omitted {omitted}\n"

echo &"Took {gettime() - start}"

 

{{out}}

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>

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

printf " %s => %s removed %s\n", substr($f,0,$digit*2+1), $reduced{$f}, substr($f,-1)

}

{{out}}

<pre>4 2-digit reducible fractions:

 

=={{header|Phix}}==

{{out}}

<pre>

"10 minutes and 13s"

</pre>

 

=={{header|Python}}==

idx = 0

for straw in haystack:

return None

 

{{out}}

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

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}}

{{works with|Rakudo|2019.07.1}}

;[[wp:Anomalous cancellation|Anomalous Cancellation]]

my $digits = 2..4;

 

say " {.key.substr(0, $digit * 2 + 1)} => {.value} removed {.key.substr(* - 1)}"

for %d.pairs.pick(12).sort;

{{out|Sample output}}

<pre>(4) 2 digit reduceable fractions:

 

=={{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>

=={{header|Ruby}}==

{{trans|Python}}

idx = 0

for straw in haystack

end

 

{{out}}

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

=={{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

 

Have still needed to restrict to 5-digit fractions which finishes in just under 2 minutes on my machine.

 

var Result = Struct.create("Result", ["n", "nine"])

}

Fmt.print("$d-digit fractions found:$d, omitted $s\n", n, count, omitted)

 

{{out}}

=={{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>