Print all jumping numbers in ascending order by given limits

Here given code implementation process.

/*
    Java program
    Print all jumping numbers in ascending order by given limits
*/
class QNode
{
    public int data;
    public QNode next;
    public QNode(int data)
    {
        this.data = data;
        this.next = null;
    }
}
// Define custom queue class
class MyQueue
{
    public QNode front;
    public QNode rear;
    public int size;
    public MyQueue()
    {
        this.front = null;
        this.rear = null;
        this.size = 0;
    }
    // Add a new node at last of queue
    public void enqueue(int data)
    {
        QNode node = new QNode(data);
        if (this.front == null)
        {
            // When first node of queue
            this.front = node;
        }
        else
        {
            // Add node at last level
            this.rear.next = node;
        }
        this.size++;
        this.rear = node;
    }
    // Delete front node of queue
    public void dequeue()
    {
        if (this.front != null)
        {
            if (this.rear == this.front)
            {
                this.rear = null;
                this.front = null;
            }
            else
            {
                this.front = this.front.next;
            }
            this.size--;
        }
    }
    public int isSize()
    {
        return this.size;
    }
    public boolean isEmpty()
    {
        if (this.isSize() == 0)
        {
            return true;
        }
        return false;
    }
    public QNode peek()
    {
        if (this.isSize() == 0)
        {
            return null;
        }
        else
        {
            return this.front;
        }
    }
}
public class Jumping
{
    public void JumpingSteps(int num)
    {
        if (num < 0)
        {
            return;
        }
        int v = 0;
        if (num <= 10)
        {
            while (v <= num)
            {
                System.out.print("  " + v);
                v++;
            }
            return;
        }
        MyQueue record = new MyQueue();
        int count = 1;
        int digit = 0;
        System.out.print("  0");
        while (count <= num || record.isEmpty() == false)
        {
            if (count <= num)
            {
                if (count <= 9)
                {
                    System.out.print("  " + count);
                    record.enqueue(count);
                    count++;
                }
                else
                {
                    // Get head value
                    v = record.peek().data;
                    // Remove head node
                    record.dequeue();
                    // Find last digit
                    digit = v % 10;
                    if (digit != 0)
                    {
                        // Make new number
                        count = (v * 10) + (digit - 1);
                        if (count <= num)
                        {
                            System.out.print("  " + count);
                            record.enqueue(count);
                        }
                    }
                    if (digit != 9 && count <= num)
                    {
                        // Make new number
                        count = (v * 10) + (digit + 1);
                        if (count <= num)
                        {
                            System.out.print("  " + count);
                            record.enqueue(count);
                        }
                    }
                }
            }
            else
            {
                record.dequeue();
            }
        }
    }
    public static void main(String[] args)
    {
        Jumping task = new Jumping();
        // 0..1400
        task.JumpingSteps(1400);
    }
}

Output

  0  1  2  3  4  5  6  7  8  9  10  12  21  23  32  34  43  45  54  56  65  67  76  78  87  89  98  101  121  123  210  212  232  234  321  323  343  345  432  434  454  456  543  545  565  567  654  656  676  678  765  767  787  789  876  878  898  987  989  1010  1012  1210  1212  1232  1234

// Include header file
#include <iostream>
using namespace std;
/*
    C++ program
    Print all jumping numbers in ascending order by given limits
*/
class QNode
{
    public: int data;
    QNode *next;
    QNode(int data)
    {
        this->data = data;
        this->next = NULL;
    }
};
// Define custom queue class
class MyQueue
{
    public: QNode *front;
    QNode *rear;
    int size;
    MyQueue()
    {
        this->front = NULL;
        this->rear = NULL;
        this->size = 0;
    }
    // Add a new node at last of queue
    void enqueue(int data)
    {
        QNode *node = new QNode(data);
        if (this->front == NULL)
        {
            // When first node of queue
            this->front = node;
        }
        else
        {
            // Add node at last level
            this->rear->next = node;
        }
        this->size++;
        this->rear = node;
    }
    // Delete front node of queue
    void dequeue()
    {
        if (this->front != NULL)
        {
            if (this->rear == this->front)
            {
                this->rear = NULL;
                this->front = NULL;
            }
            else
            {
                this->front = this->front->next;
            }
            this->size--;
        }
    }
    int isSize()
    {
        return this->size;
    }
    bool isEmpty()
    {
        if (this->isSize() == 0)
        {
            return true;
        }
        return false;
    }
    QNode *peek()
    {
        if (this->isSize() == 0)
        {
            return NULL;
        }
        else
        {
            return this->front;
        }
    }
};
class Jumping
{
    public: void JumpingSteps(int num)
    {
        if (num < 0)
        {
            return;
        }
        int v = 0;
        if (num <= 10)
        {
            while (v <= num)
            {
                cout << "  " << v;
                v++;
            }
            return;
        }
        MyQueue *record = new MyQueue();
        int count = 1;
        int digit = 0;
        cout << "  0";
        while (count <= num || record->isEmpty() == false)
        {
            if (count <= num)
            {
                if (count <= 9)
                {
                    cout << "  " << count;
                    record->enqueue(count);
                    count++;
                }
                else
                {
                    // Get head value
                    v = record->peek()->data;
                    // Remove head node
                    record->dequeue();
                    // Find last digit
                    digit = v % 10;
                    if (digit != 0)
                    {
                        // Make new number
                        count = (v *10) + (digit - 1);
                        if (count <= num)
                        {
                            cout << "  " << count;
                            record->enqueue(count);
                        }
                    }
                    if (digit != 9 && count <= num)
                    {
                        // Make new number
                        count = (v *10) + (digit + 1);
                        if (count <= num)
                        {
                            cout << "  " << count;
                            record->enqueue(count);
                        }
                    }
                }
            }
            else
            {
                record->dequeue();
            }
        }
    }
};
int main()
{
    Jumping *task = new Jumping();
    // 0..1400
    task->JumpingSteps(1400);
    return 0;
}

Output

  0  1  2  3  4  5  6  7  8  9  10  12  21  23  32  34  43  45  54  56  65  67  76  78  87  89  98  101  121  123  210  212  232  234  321  323  343  345  432  434  454  456  543  545  565  567  654  656  676  678  765  767  787  789  876  878  898  987  989  1010  1012  1210  1212  1232  1234

// Include namespace system
using System;
/*
    Csharp program
    Print all jumping numbers in ascending order by given limits
*/
public class QNode
{
    public int data;
    public QNode next;
    public QNode(int data)
    {
        this.data = data;
        this.next = null;
    }
}
// Define custom queue class
public class MyQueue
{
    public QNode front;
    public QNode rear;
    public int size;
    public MyQueue()
    {
        this.front = null;
        this.rear = null;
        this.size = 0;
    }
    // Add a new node at last of queue
    public void enqueue(int data)
    {
        QNode node = new QNode(data);
        if (this.front == null)
        {
            // When first node of queue
            this.front = node;
        }
        else
        {
            // Add node at last level
            this.rear.next = node;
        }
        this.size++;
        this.rear = node;
    }
    // Delete front node of queue
    public void dequeue()
    {
        if (this.front != null)
        {
            if (this.rear == this.front)
            {
                this.rear = null;
                this.front = null;
            }
            else
            {
                this.front = this.front.next;
            }
            this.size--;
        }
    }
    public int isSize()
    {
        return this.size;
    }
    public Boolean isEmpty()
    {
        if (this.isSize() == 0)
        {
            return true;
        }
        return false;
    }
    public QNode peek()
    {
        if (this.isSize() == 0)
        {
            return null;
        }
        else
        {
            return this.front;
        }
    }
}
public class Jumping
{
    public void JumpingSteps(int num)
    {
        if (num < 0)
        {
            return;
        }
        int v = 0;
        if (num <= 10)
        {
            while (v <= num)
            {
                Console.Write("  " + v);
                v++;
            }
            return;
        }
        MyQueue record = new MyQueue();
        int count = 1;
        int digit = 0;
        Console.Write("  0");
        while (count <= num || record.isEmpty() == false)
        {
            if (count <= num)
            {
                if (count <= 9)
                {
                    Console.Write("  " + count);
                    record.enqueue(count);
                    count++;
                }
                else
                {
                    // Get head value
                    v = record.peek().data;
                    // Remove head node
                    record.dequeue();
                    // Find last digit
                    digit = v % 10;
                    if (digit != 0)
                    {
                        // Make new number
                        count = (v * 10) + (digit - 1);
                        if (count <= num)
                        {
                            Console.Write("  " + count);
                            record.enqueue(count);
                        }
                    }
                    if (digit != 9 && count <= num)
                    {
                        // Make new number
                        count = (v * 10) + (digit + 1);
                        if (count <= num)
                        {
                            Console.Write("  " + count);
                            record.enqueue(count);
                        }
                    }
                }
            }
            else
            {
                record.dequeue();
            }
        }
    }
    public static void Main(String[] args)
    {
        Jumping task = new Jumping();
        // 0..1400
        task.JumpingSteps(1400);
    }
}

Output

  0  1  2  3  4  5  6  7  8  9  10  12  21  23  32  34  43  45  54  56  65  67  76  78  87  89  98  101  121  123  210  212  232  234  321  323  343  345  432  434  454  456  543  545  565  567  654  656  676  678  765  767  787  789  876  878  898  987  989  1010  1012  1210  1212  1232  1234

package main
import "fmt"
/*
    Go program
    Print all jumping numbers in ascending order by given limits
*/
type QNode struct {
    data int
    next * QNode
}
func getQNode(data int) * QNode {
    var me *QNode = &QNode {}
    me.data = data
    me.next = nil
    return me
}
// Define custom queue class
type MyQueue struct {
    front * QNode
    rear * QNode
    size int
}
func getMyQueue() * MyQueue {
    var me *MyQueue = &MyQueue {}
    me.front = nil
    me.rear = nil
    me.size = 0
    return me
}
// Add a new node at last of queue
func(this *MyQueue) enqueue(data int) {
    var node * QNode = getQNode(data)
    if this.front == nil {
        // When first node of queue
        this.front = node
    } else {
        // Add node at last level
        this.rear.next = node
    }
    this.size++
    this.rear = node
}
// Delete front node of queue
func(this *MyQueue) dequeue() {
    if this.front != nil {
        if this.rear == this.front {
            this.rear = nil
            this.front = nil
        } else {
            this.front = this.front.next
        }
        this.size--
    }
}
func(this MyQueue) isSize() int {
    return this.size
}
func(this MyQueue) isEmpty() bool {
    if this.isSize() == 0 {
        return true
    }
    return false
}
func(this MyQueue) peek() * QNode {
    if this.isSize() == 0 {
        return nil
    } else {
        return this.front
    }
}
type Jumping struct {}
func getJumping() * Jumping {
    var me *Jumping = &Jumping {}
    return me
}
func(this Jumping) JumpingSteps(num int) {
    if num < 0 {
        return
    }
    var v int = 0
    if num <= 10 {
        for (v <= num) {
            fmt.Print("  ", v)
            v++
        }
        return
    }
    var record * MyQueue = getMyQueue()
    var count int = 1
    var digit int = 0
    fmt.Print("  0")
    for (count <= num || record.isEmpty() == false) {
        if count <= num {
            if count <= 9 {
                fmt.Print("  ", count)
                record.enqueue(count)
                count++
            } else {
                // Get head value
                v = record.peek().data
                // Remove head node
                record.dequeue()
                // Find last digit
                digit = v % 10
                if digit != 0 {
                    // Make new number
                    count = (v * 10) + (digit - 1)
                    if count <= num {
                        fmt.Print("  ", count)
                        record.enqueue(count)
                    }
                }
                if digit != 9 && count <= num {
                    // Make new number
                    count = (v * 10) + (digit + 1)
                    if count <= num {
                        fmt.Print("  ", count)
                        record.enqueue(count)
                    }
                }
            }
        } else {
            record.dequeue()
        }
    }
}
func main() {
    var task * Jumping = getJumping()
    // 0..1400
    task.JumpingSteps(1400)
}

Output

  0  1  2  3  4  5  6  7  8  9  10  12  21  23  32  34  43  45  54  56  65  67  76  78  87  89  98  101  121  123  210  212  232  234  321  323  343  345  432  434  454  456  543  545  565  567  654  656  676  678  765  767  787  789  876  878  898  987  989  1010  1012  1210  1212  1232  1234

<?php
/*
    Php program
    Print all jumping numbers in ascending order by given limits
*/
class QNode
{
    public $data;
    public $next;
    public  function __construct($data)
    {
        $this->data = $data;
        $this->next = NULL;
    }
}
// Define custom queue class
class MyQueue
{
    public $front;
    public $rear;
    public $size;
    public  function __construct()
    {
        $this->front = NULL;
        $this->rear = NULL;
        $this->size = 0;
    }
    // Add a new node at last of queue
    public  function enqueue($data)
    {
        $node = new QNode($data);
        if ($this->front == NULL)
        {
            // When first node of queue
            $this->front = $node;
        }
        else
        {
            // Add node at last level
            $this->rear->next = $node;
        }
        $this->size++;
        $this->rear = $node;
    }
    // Delete front node of queue
    public  function dequeue()
    {
        if ($this->front != NULL)
        {
            if ($this->rear == $this->front)
            {
                $this->rear = NULL;
                $this->front = NULL;
            }
            else
            {
                $this->front = $this->front->next;
            }
            $this->size--;
        }
    }
    public  function isSize()
    {
        return $this->size;
    }
    public  function isEmpty()
    {
        if ($this->isSize() == 0)
        {
            return true;
        }
        return false;
    }
    public  function peek()
    {
        if ($this->isSize() == 0)
        {
            return NULL;
        }
        else
        {
            return $this->front;
        }
    }
}
class Jumping
{
    public  function JumpingSteps($num)
    {
        if ($num < 0)
        {
            return;
        }
        $v = 0;
        if ($num <= 10)
        {
            while ($v <= $num)
            {
                echo("  ".$v);
                $v++;
            }
            return;
        }
        $record = new MyQueue();
        $count = 1;
        $digit = 0;
        echo("  0");
        while ($count <= $num || $record->isEmpty() == false)
        {
            if ($count <= $num)
            {
                if ($count <= 9)
                {
                    echo("  ".$count);
                    $record->enqueue($count);
                    $count++;
                }
                else
                {
                    // Get head value
                    $v = $record->peek()->data;
                    // Remove head node
                    $record->dequeue();
                    // Find last digit
                    $digit = $v % 10;
                    if ($digit != 0)
                    {
                        // Make new number
                        $count = ($v * 10) + ($digit - 1);
                        if ($count <= $num)
                        {
                            echo("  ".$count);
                            $record->enqueue($count);
                        }
                    }
                    if ($digit != 9 && $count <= $num)
                    {
                        // Make new number
                        $count = ($v * 10) + ($digit + 1);
                        if ($count <= $num)
                        {
                            echo("  ".$count);
                            $record->enqueue($count);
                        }
                    }
                }
            }
            else
            {
                $record->dequeue();
            }
        }
    }
}

function main()
{
    $task = new Jumping();
    // 0..1400
    $task->JumpingSteps(1400);
}
main();

Output

  0  1  2  3  4  5  6  7  8  9  10  12  21  23  32  34  43  45  54  56  65  67  76  78  87  89  98  101  121  123  210  212  232  234  321  323  343  345  432  434  454  456  543  545  565  567  654  656  676  678  765  767  787  789  876  878  898  987  989  1010  1012  1210  1212  1232  1234

/*
    Node JS program
    Print all jumping numbers in ascending order by given limits
*/
class QNode
{
    constructor(data)
    {
        this.data = data;
        this.next = null;
    }
}
// Define custom queue class
class MyQueue
{
    constructor()
    {
        this.front = null;
        this.rear = null;
        this.size = 0;
    }
    // Add a new node at last of queue
    enqueue(data)
    {
        var node = new QNode(data);
        if (this.front == null)
        {
            // When first node of queue
            this.front = node;
        }
        else
        {
            // Add node at last level
            this.rear.next = node;
        }
        this.size++;
        this.rear = node;
    }
    // Delete front node of queue
    dequeue()
    {
        if (this.front != null)
        {
            if (this.rear == this.front)
            {
                this.rear = null;
                this.front = null;
            }
            else
            {
                this.front = this.front.next;
            }
            this.size--;
        }
    }
    isSize()
    {
        return this.size;
    }
    isEmpty()
    {
        if (this.isSize() == 0)
        {
            return true;
        }
        return false;
    }
    peek()
    {
        if (this.isSize() == 0)
        {
            return null;
        }
        else
        {
            return this.front;
        }
    }
}
class Jumping
{
    JumpingSteps(num)
    {
        if (num < 0)
        {
            return;
        }
        var v = 0;
        if (num <= 10)
        {
            while (v <= num)
            {
                process.stdout.write("  " + v);
                v++;
            }
            return;
        }
        var record = new MyQueue();
        var count = 1;
        var digit = 0;
        process.stdout.write("  0");
        while (count <= num || record.isEmpty() == false)
        {
            if (count <= num)
            {
                if (count <= 9)
                {
                    process.stdout.write("  " + count);
                    record.enqueue(count);
                    count++;
                }
                else
                {
                    // Get head value
                    v = record.peek().data;
                    // Remove head node
                    record.dequeue();
                    // Find last digit
                    digit = v % 10;
                    if (digit != 0)
                    {
                        // Make new number
                        count = (v * 10) + (digit - 1);
                        if (count <= num)
                        {
                            process.stdout.write("  " + count);
                            record.enqueue(count);
                        }
                    }
                    if (digit != 9 && count <= num)
                    {
                        // Make new number
                        count = (v * 10) + (digit + 1);
                        if (count <= num)
                        {
                            process.stdout.write("  " + count);
                            record.enqueue(count);
                        }
                    }
                }
            }
            else
            {
                record.dequeue();
            }
        }
    }
}

function main()
{
    var task = new Jumping();
    // 0..1400
    task.JumpingSteps(1400);
}
main();

Output

  0  1  2  3  4  5  6  7  8  9  10  12  21  23  32  34  43  45  54  56  65  67  76  78  87  89  98  101  121  123  210  212  232  234  321  323  343  345  432  434  454  456  543  545  565  567  654  656  676  678  765  767  787  789  876  878  898  987  989  1010  1012  1210  1212  1232  1234

#    Python 3 program
#    Print all jumping numbers in ascending order by given limits
class QNode :
    def __init__(self, data) :
        self.data = data
        self.next = None
    

#  Define custom queue class
class MyQueue :
    def __init__(self) :
        self.front = None
        self.rear = None
        self.size = 0
    
    #  Add a new node at last of queue
    def enqueue(self, data) :
        node = QNode(data)
        if (self.front == None) :
            #  When first node of queue
            self.front = node
        else :
            #  Add node at last level
            self.rear.next = node
        
        self.size += 1
        self.rear = node
    
    #  Delete front node of queue
    def dequeue(self) :
        if (self.front != None) :
            if (self.rear == self.front) :
                self.rear = None
                self.front = None
            else :
                self.front = self.front.next
            
            self.size -= 1
        
    
    def isSize(self) :
        return self.size
    
    def isEmpty(self) :
        if (self.isSize() == 0) :
            return True
        
        return False
    
    def peek(self) :
        if (self.isSize() == 0) :
            return None
        else :
            return self.front
        
    

class Jumping :
    def JumpingSteps(self, num) :
        if (num < 0) :
            return
        
        v = 0
        if (num <= 10) :
            while (v <= num) :
                print("  ", v, end = "")
                v += 1
            
            return
        
        record = MyQueue()
        count = 1
        digit = 0
        print("  0", end = "")
        while (count <= num or record.isEmpty() == False) :
            if (count <= num) :
                if (count <= 9) :
                    print("  ", count, end = "")
                    record.enqueue(count)
                    count += 1
                else :
                    #  Get head value
                    v = record.peek().data
                    #  Remove head node
                    record.dequeue()
                    #  Find last digit
                    digit = v % 10
                    if (digit != 0) :
                        #  Make new number
                        count = (v * 10) + (digit - 1)
                        if (count <= num) :
                            print("  ", count, end = "")
                            record.enqueue(count)
                        
                    
                    if (digit != 9 and count <= num) :
                        #  Make new number
                        count = (v * 10) + (digit + 1)
                        if (count <= num) :
                            print("  ", count, end = "")
                            record.enqueue(count)
                        
                    
                
            else :
                record.dequeue()
            
        
    

def main() :
    task = Jumping()
    #  0..1400
    task.JumpingSteps(1400)

if __name__ == "__main__": main()

Output

  0   1   2   3   4   5   6   7   8   9   10   12   21   23   32   34   43   45   54   56   65   67   76   78   87   89   98   101   121   123   210   212   232   234   321   323   343   345   432   434   454   456   543   545   565   567   654   656   676   678   765   767   787   789   876   878   898   987   989   1010   1012   1210   1212   1232   1234

#    Ruby program
#    Print all jumping numbers in ascending order by given limits
class QNode 
    # Define the accessor and reader of class QNode
    attr_reader :data, :next
    attr_accessor :data, :next
    def initialize(data) 
        self.data = data
        self.next = nil
    end

end

#  Define custom queue class
class MyQueue 
    # Define the accessor and reader of class MyQueue
    attr_reader :front, :rear, :size
    attr_accessor :front, :rear, :size
    def initialize() 
        self.front = nil
        self.rear = nil
        self.size = 0
    end

    #  Add a new node at last of queue
    def enqueue(data) 
        node = QNode.new(data)
        if (self.front == nil) 
            #  When first node of queue
            self.front = node
        else
 
            #  Add node at last level
            self.rear.next = node
        end

        self.size += 1
        self.rear = node
    end

    #  Delete front node of queue
    def dequeue() 
        if (self.front != nil) 
            if (self.rear == self.front) 
                self.rear = nil
                self.front = nil
            else
 
                self.front = self.front.next
            end

            self.size -= 1
        end

    end

    def isSize() 
        return self.size
    end

    def isEmpty() 
        if (self.isSize() == 0) 
            return true
        end

        return false
    end

    def peek() 
        if (self.isSize() == 0) 
            return nil
        else
 
            return self.front
        end

    end

end

class Jumping 
    def JumpingSteps(num) 
        if (num < 0) 
            return
        end

        v = 0
        if (num <= 10) 
            while (v <= num) 
                print("  ", v)
                v += 1
            end

            return
        end

        record = MyQueue.new()
        count = 1
        digit = 0
        print("  0")
        while (count <= num || record.isEmpty() == false) 
            if (count <= num) 
                if (count <= 9) 
                    print("  ", count)
                    record.enqueue(count)
                    count += 1
                else
 
                    #  Get head value
                    v = record.peek().data
                    #  Remove head node
                    record.dequeue()
                    #  Find last digit
                    digit = v % 10
                    if (digit != 0) 
                        #  Make new number
                        count = (v * 10) + (digit - 1)
                        if (count <= num) 
                            print("  ", count)
                            record.enqueue(count)
                        end

                    end

                    if (digit != 9 && count <= num) 
                        #  Make new number
                        count = (v * 10) + (digit + 1)
                        if (count <= num) 
                            print("  ", count)
                            record.enqueue(count)
                        end

                    end

                end

            else
 
                record.dequeue()
            end

        end

    end

end

def main() 
    task = Jumping.new()
    #  0..1400
    task.JumpingSteps(1400)
end

main()

Output

  0  1  2  3  4  5  6  7  8  9  10  12  21  23  32  34  43  45  54  56  65  67  76  78  87  89  98  101  121  123  210  212  232  234  321  323  343  345  432  434  454  456  543  545  565  567  654  656  676  678  765  767  787  789  876  878  898  987  989  1010  1012  1210  1212  1232  1234

/*
    Scala program
    Print all jumping numbers in ascending order by given limits
*/
class QNode(var data: Int,
    var next: QNode)
{
    def this(data: Int)
    {
        this(data, null);
    }
}
// Define custom queue class
class MyQueue(var front: QNode,
    var rear: QNode,
        var size: Int)
{
    def this()
    {
        this(null, null, 0);
    }
    // Add a new node at last of queue
    def enqueue(data: Int): Unit = {
        var node: QNode = new QNode(data);
        if (this.front == null)
        {
            // When first node of queue
            this.front = node;
        }
        else
        {
            // Add node at last level
            this.rear.next = node;
        }
        this.size += 1;
        this.rear = node;
    }
    // Delete front node of queue
    def dequeue(): Unit = {
        if (this.front != null)
        {
            if (this.rear == this.front)
            {
                this.rear = null;
                this.front = null;
            }
            else
            {
                this.front = this.front.next;
            }
            this.size -= 1;
        }
    }
    def isSize(): Int = {
        return this.size;
    }
    def isEmpty(): Boolean = {
        if (this.isSize() == 0)
        {
            return true;
        }
        return false;
    }
    def peek(): QNode = {
        if (this.isSize() == 0)
        {
            return null;
        }
        else
        {
            return this.front;
        }
    }
}
class Jumping()
{
    def JumpingSteps(num: Int): Unit = {
        if (num < 0)
        {
            return;
        }
        var v: Int = 0;
        if (num <= 10)
        {
            while (v <= num)
            {
                print("  " + v);
                v += 1;
            }
            return;
        }
        var record: MyQueue = new MyQueue();
        var count: Int = 1;
        var digit: Int = 0;
        print("  0");
        while (count <= num || record.isEmpty() == false)
        {
            if (count <= num)
            {
                if (count <= 9)
                {
                    print("  " + count);
                    record.enqueue(count);
                    count += 1;
                }
                else
                {
                    // Get head value
                    v = record.peek().data;
                    // Remove head node
                    record.dequeue();
                    // Find last digit
                    digit = v % 10;
                    if (digit != 0)
                    {
                        // Make new number
                        count = (v * 10) + (digit - 1);
                        if (count <= num)
                        {
                            print("  " + count);
                            record.enqueue(count);
                        }
                    }
                    if (digit != 9 && count <= num)
                    {
                        // Make new number
                        count = (v * 10) + (digit + 1);
                        if (count <= num)
                        {
                            print("  " + count);
                            record.enqueue(count);
                        }
                    }
                }
            }
            else
            {
                record.dequeue();
            }
        }
    }
}
object Main
{
    def main(args: Array[String]): Unit = {
        var task: Jumping = new Jumping();
        // 0..1400
        task.JumpingSteps(1400);
    }
}

Output

  0  1  2  3  4  5  6  7  8  9  10  12  21  23  32  34  43  45  54  56  65  67  76  78  87  89  98  101  121  123  210  212  232  234  321  323  343  345  432  434  454  456  543  545  565  567  654  656  676  678  765  767  787  789  876  878  898  987  989  1010  1012  1210  1212  1232  1234

/*
    Swift 4 program
    Print all jumping numbers in ascending order by given limits
*/
class QNode
{
    var data: Int;
    var next: QNode? ;
    init(_ data: Int)
    {
        self.data = data;
        self.next = nil;
    }
}
// Define custom queue class
class MyQueue
{
    var front: QNode? ;
    var rear: QNode? ;
    var size: Int;
    init()
    {
        self.front = nil;
        self.rear = nil;
        self.size = 0;
    }
    // Add a new node at last of queue
    func enqueue(_ data: Int)
    {
        let node: QNode = QNode(data);
        if (self.front == nil)
        {
            // When first node of queue
            self.front = node;
        }
        else
        {
            // Add node at last level
            self.rear!.next = node;
        }
        self.size += 1;
        self.rear = node;
    }
    // Delete front node of queue
    func dequeue()
    {
        if (self.front  != nil)
        {
            if (self.rear === self.front)
            {
                self.rear = nil;
                self.front = nil;
            }
            else
            {
                self.front = self.front!.next;
            }
            self.size -= 1;
        }
    }
    func isSize() -> Int
    {
        return self.size;
    }
    func isEmpty() -> Bool
    {
        if (self.isSize() == 0)
        {
            return true;
        }
        return false;
    }
    func peek() -> QNode?
    {
        if (self.isSize() == 0)
        {
            return nil;
        }
        else
        {
            return self.front;
        }
    }
}
class Jumping
{
    func JumpingSteps(_ num: Int)
    {
        if (num < 0)
        {
            return;
        }
        var v: Int = 0;
        if (num <= 10)
        {
            while (v <= num)
            {
                print("  ", v, terminator: "");
                v += 1;
            }
            return;
        }
        let record: MyQueue = MyQueue();
        var count: Int = 1;
        var digit: Int = 0;
        print("  0", terminator: "");
        while (count <= num || record.isEmpty() == false)
        {
            if (count <= num)
            {
                if (count <= 9)
                {
                    print("  ", count, terminator: "");
                    record.enqueue(count);
                    count += 1;
                }
                else
                {
                    // Get head value
                    v = record.peek()!.data;
                    // Remove head node
                    record.dequeue();
                    // Find last digit
                    digit = v % 10;
                    if (digit  != 0)
                    {
                        // Make new number
                        count = (v * 10) + (digit - 1);
                        if (count <= num)
                        {
                            print("  ", count, terminator: "");
                            record.enqueue(count);
                        }
                    }
                    if (digit  != 9 && count <= num)
                    {
                        // Make new number
                        count = (v * 10) + (digit + 1);
                        if (count <= num)
                        {
                            print("  ", count, terminator: "");
                            record.enqueue(count);
                        }
                    }
                }
            }
            else
            {
                record.dequeue();
            }
        }
    }
}
func main()
{
    let task: Jumping = Jumping();
    // 0..1400
    task.JumpingSteps(1400);
}
main();

Output

  0   1   2   3   4   5   6   7   8   9   10   12   21   23   32   34   43   45   54   56   65   67   76   78   87   89   98   101   121   123   210   212   232   234   321   323   343   345   432   434   454   456   543   545   565   567   654   656   676   678   765   767   787   789   876   878   898   987   989   1010   1012   1210   1212   1232   1234

/*
    Kotlin program
    Print all jumping numbers in ascending order by given limits
*/
class QNode
{
    var data: Int;
    var next: QNode ? ;
    constructor(data: Int)
    {
        this.data = data;
        this.next = null;
    }
}
// Define custom queue class
class MyQueue
{
    var front: QNode ? ;
    var rear: QNode ? ;
    var size: Int;
    constructor()
    {
        this.front = null;
        this.rear = null;
        this.size = 0;
    }
    // Add a new node at last of queue
    fun enqueue(data: Int): Unit
    {
        val node: QNode = QNode(data);
        if (this.front == null)
        {
            // When first node of queue
            this.front = node;
        }
        else
        {
            // Add node at last level
            this.rear?.next = node;
        }
        this.size += 1;
        this.rear = node;
    }
    // Delete front node of queue
    fun dequeue(): Unit
    {
        if (this.front != null)
        {
            if (this.rear == this.front)
            {
                this.rear = null;
                this.front = null;
            }
            else
            {
                this.front = this.front?.next;
            }
            this.size -= 1;
        }
    }
    fun isSize(): Int
    {
        return this.size;
    }
    fun isEmpty(): Boolean
    {
        if (this.isSize() == 0)
        {
            return true;
        }
        return false;
    }
    fun peek(): QNode ?
    {
        if (this.isSize() == 0)
        {
            return null;
        }
        else
        {
            return this.front;
        }
    }
}
class Jumping
{
    fun JumpingSteps(num: Int): Unit
    {
        if (num < 0)
        {
            return;
        }
        var v: Int = 0;
        if (num <= 10)
        {
            while (v <= num)
            {
                print("  " + v);
                v += 1;
            }
            return;
        }
        val record: MyQueue = MyQueue();
        var count: Int = 1;
        var digit: Int ;
        print("  0");
        while (count <= num || record.isEmpty() == false)
        {
            if (count <= num)
            {
                if (count <= 9)
                {
                    print("  " + count);
                    record.enqueue(count);
                    count += 1;
                }
                else
                {
                    // Get head value
                    v = record.peek()!!.data;
                    // Remove head node
                    record.dequeue();
                    // Find last digit
                    digit = v % 10;
                    if (digit != 0)
                    {
                        // Make new number
                        count = (v * 10) + (digit - 1);
                        if (count <= num)
                        {
                            print("  " + count);
                            record.enqueue(count);
                        }
                    }
                    if (digit != 9 && count <= num)
                    {
                        // Make new number
                        count = (v * 10) + (digit + 1);
                        if (count <= num)
                        {
                            print("  " + count);
                            record.enqueue(count);
                        }
                    }
                }
            }
            else
            {
                record.dequeue();
            }
        }
    }
}
fun main(args: Array < String > ): Unit
{
    val task: Jumping = Jumping();
    // 0..1400
    task.JumpingSteps(1400);
}

Output

  0  1  2  3  4  5  6  7  8  9  10  12  21  23  32  34  43  45  54  56  65  67  76  78  87  89  98  101  121  123  210  212  232  234  321  323  343  345  432  434  454  456  543  545  565  567  654  656  676  678  765  767  787  789  876  878  898  987  989  1010  1012  1210  1212  1232  1234

« Previous Next »

Queue

Implement queue using linked list

Implement queue using doubly linked list

Level order Tree Traversal

Flatten binary tree nodes in level order from

Print Levels of all nodes in a Binary Tree

Find average of levels in binary tree

Print binary tree level in sorted order

Print the nodes at odd levels of a tree

Print the nodes at even levels of a tree

Print all palindromic levels of a binary tree

Print all prime levels of a binary tree

Print all nodes between the given two levels of a binary tree

Print alternate nodes in level order of a binary tree

Print all K-sum levels in a Binary Tree

Reverse alternate levels of a binary tree

Check if all levels of two trees are anagrams or not

Invert the levels of binary tree

Delete entire nodes of a binary tree

Check whether a given binary tree is complete or not

Efficiently implement n queues in a single array

Print top view of a binary tree using level order traversal

Priority queue using doubly linked list

Deque implementation using doubly linked list

Reverse first k elements of queue

Huffman coding using priority queue

Hamming decoding example

Canonical Huffman Coding

Construct Diamond Tree

Append the elements of queue in mirror-inverse order

Sum of nodes in top view of binary tree

Print leftmost and rightmost nodes of a binary tree

Print the middle nodes of each level of a binary tree

Print node at corresponding level in binary tree

Level sum of bitwise and operation in binary tree

Generate all initial n numbers formed from 3 and 4

Generate all initial n numbers formed from 0 1 and 2

Iterative diagonal traversal of binary tree

Find kth node in diagonal traversal of binary tree

Print all diagonal path of binary tree with intervals

Print all jumping numbers in ascending order by given limits

Print the boundary nodes in each level of the binary tree using queue

Implement circular queue using linked list

Implement priority queue with pair

Implement queue using stack

Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment

Name