Next highest int from digits: Difference between revisions

:*   9589776899767587796600

<br><br>

 

=={{header|AutoHotkey}}==

===Permutation Version===

Arr := []

for i, v in permute(num)

res .= x[A_Index]

return res

. "`n" Next_highest_int(9)

. "`n" Next_highest_int(12)

. "`n" Next_highest_int(738440)

. "`n" Next_highest_int(45072010)

{{out}}

<pre>0

95322200</pre>

===Scanning Version===

Loop % StrLen(num){

i := A_Index

res .= v

return res

. "`n" Next_highest_int(9)

. "`n" Next_highest_int(12)

. "`n" Next_highest_int(45072010)

. "`n" Next_highest_int(95322020)

{{out}}

<pre>0

 

=={{header|C}}==

#include <stdio.h>

#include <stdint.h>

printf("%s -> %s\n", big, next);

return 0;

 

{{out}}

9589776899767587796600 -> 9589776899767587900667

</pre>

 

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

{{libheader|GMP}}

This solution makes use of std::next_permutation, which is essentially the same as Algorithm 2.

#include <iostream>

#include <sstream>

std::cout << big << " -> " << next_highest(big) << '\n';

return 0;

 

{{out}}

=={{header|D}}==

{{trans|Java}}

import std.array;

import std.conv;

testAll("12345");

testAll("11122");

{{out}}

<pre>0 -> 0

{{libheader| System.Generics.Collections}}

{{Trans|Go}}

program Next_highest_int_from_digits;

 

{$IFNDEF UNIX}

readln; {$ENDIF}

 

=={{header|Factor}}==

This uses the <code>next-permutation</code> word from the <code>math.combinatorics</code> vocabulary. <code>next-permutation</code> wraps around and returns the smallest lexicographic permutation after the largest one, so additionally we must check if we're at the largest permutation and return zero if so. See the implementation of <code>next-permutation</code> [https://docs.factorcode.org/content/word-next-permutation%2Cmath.combinatorics.html here].

{{works with|Factor|0.99 2020-01-23}}

math.parser sequences ;

 

9589776899767587796600

}

{{out}}

<pre>

9589776899767587796600 -> 9589776899767587900667

</pre>

 

=={{header|Go}}==

This uses a modified version of the recursive code in the [[https://rosettacode.org/wiki/Permutations#Go Permutations#Go]] task.

 

import (

algorithm1(nums[:len(nums)-1]) // exclude the last one

algorithm2(nums) // include the last one

 

{{out}}

{{Trans|Python}}

(Generator version)

 

digitShuffleSuccessors :: Integer -> [Integer]

 

rjust :: Int -> Char -> String -> String

{{Out}}

<pre>Taking up to 5 digit-shuffle successors of a positive integer:

(The digit-swap approach makes it feasible to obtain successors of this kind for much larger numbers)

 

 

digitShuffleSuccessors n =

 

minimalSwap ([], xs) = []

minimalSwap (_, []) = []

 

 

main :: IO ()

main = do

putStrLn $

fTable

show

let harvest = take 5 xs

digitShuffleSuccessors

[0, 9, 12, 21, 12453, 738440, 45072010, 95322020]

[9589776899767587796600]

 

reversedDigits 0 = [0]

reversedDigits n = go n

| otherwise = (fst (head ys) : map snd ys, map snd zs)

 

unDigits = foldl (\a b -> 10 * a + b) 0

 

fTable s xShow fxShow f xs =

unlines $

where

w = maximum (length . xShow <$> xs)

 

rjust :: Int -> Char -> String -> String

{{Out}}

<pre>Taking up to 5 digit-shuffle successors of a positive integer:

=={{header|Java}}==

Additional testing is performed, including a number with all unique digits and a number with duplicate digits. Included test of all permutations, that the order and correct number of permutations is achieved, and that each permutation is different than all others. If a library is not used, then this testing will provide a better proof of correctness.

import java.math.BigInteger;

import java.text.NumberFormat;

}

}

{{out}}

<pre>

 

=={{header|JavaScript}}==

const toString = x => x + '';

const reverse = x => Array.from(x).reduce((p, c) => [c, ...p], []);

test(95322020);

test('9589776899767587796600');

{{out}}

<pre>0 => 0

9589776899767587796600 => 9589776899767587900667</pre>

 

=={{header|Julia}}==

 

asint(dig) = foldl((i, j) -> 10i + Int128(j), dig)

@btime nexthighest_2(n)

println(" for method 2 and n $n.")

<pre>

N 1A 1B 2

=={{header|Kotlin}}==

{{trans|Java}}

import java.text.NumberFormat

 

}

return sb.toString()

{{out}}

<pre>0 -> 0

Permutations unique: OK = true

Permutation count: Actual = 10, Expected = 10, OK = true</pre>

 

=={{header|Nim}}==

Using the scanning algorithm.

 

type Digit = range[0..9]

when isMainModule:

for n in [0, 9, 12, 21, 12453, 738440, 45072010, 95322020]:

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

for (0, 9, 12, 21, 12453, 738440, 45072010, 95322020, 9589776899767587796600, 3345333) {

printf "%30s -> %s\n", comma($_), comma next_greatest_integer $_;

{{out}}

<pre> 0 -> 0

=={{header|Phix}}==

===algorithm 1===

{{out}}

<pre>

</pre>

===algorithm 2===

{{out}}

<pre>

===Python: Algorithm 2===

Like Algorithm 2, but digit order is reversed for easier indexing, then reversed on return.

"(index of) closest int from lst, to n that is also > n"

large = max(lst) + 1

for x in [0, 9, 12, 21, 12453, 738440, 45072010, 95322020,

9589776899767587796600]:

 

{{out}}

===Python: Algorithm 1===

I would not try it on the stretch goal, otherwise results as above.

 

 

if perm != this:

return int(''.join(perm))

 

===Python: Generator===

A variant which defines (in terms of a concatMap over permutations), a generator of '''all''' digit-shuffle successors for a given integer:

 

 

from itertools import chain, islice, permutations, tee

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Taking up to 5 digit-shuffle successors for each:

45072010 -> 5 of 1861: [45072100, 45100027, 45100072, 45100207, 45100270]

95322020 -> 1 of 1: [95322200]</pre>

 

=={{header|Raku}}==

Minimal error trapping. Assumes that the passed number is an integer. Handles positive or negative integers, always returns next largest regardless (if possible).

 

 

sub next-greatest-index ($str, &op = &infix:«<» ) {

printf "%30s -> %s%s\n", .&comma, .&next-greatest-integer < 0 ?? '' !! ' ', .&next-greatest-integer.&comma for

flat 0, (9, 12, 21, 12453, 738440, 45072010, 95322020, 9589776899767587796600, 3345333,

{{out}}

<pre>Next largest integer able to be made from these digits, or zero if no larger exists:

 

=={{header|REXX}}==

parse arg n /*obtain optional arguments from the CL*/

if n='' | n="," then n= 0 9 12 21 12453 738440 45072010 95322020 /*use the defaults?*/

end /*k*/

do m=0 for 10; if @.m==0 then iterate; $= $ || copies(m, @.m)

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

 

last -= 1

end

Output:

<pre>

</pre>

 

=={{header|Rust}}==

let len = array.len();

if len < 2 {

println!("{} -> {}", n, next_highest_int(*n));

}

 

{{out}}

 

=={{header|Sidef}}==

 

var a = n.digits(b).flip

) {

printf("%30s -> %s\n", n, next_from_digits(n))

{{out}}

<pre>

{{libheader|Wren-fmt}}

{{libheader|Wren-str}}

 

var permute = Fn.new { |s|

var nums = ["0", "9", "12", "21", "12453", "738440", "45072010", "95322020", "9589776899767587796600"]

algorithm1.call(nums[0...-1]) // exclude the last one

 

{{out}}

 

=={{header|zkl}}==

// ds:=N.split().copy(); // mutable, int

ds:=N.toString().split("").apply("toInt").copy(); // handle "234" or BigInt

}

"0"

foreach n in (ns){ println("%,d --> %,d".fmt(n,nextHightest(n))) }

 

n:="9589776899767587796600"; // or BigInt(n)

{{out}}

<pre>