247. Strobogrammatic Number II

leetcode medium

#array#csharp#leetcode#medium#recursion#search#string

Task

Дано целое число n, верните все стробограмматические числа длины n. Ответ можно возвращать в любом порядке.

Стробограмматическое число — это число, которое выглядит одинаково при повороте на 180 градусов (если посмотреть вверх ногами).

Пример

Input: n = 2

Output: ["11","69","88","96"]

C# solution

matched/original

using System;
using System.Collections.Generic;
using System.Text;
public class Solution {
    private List<List<char>> reversiblePairs = new List<List<char>> {
        new List<char>{'0', '0'}, new List<char>{'1', '1'}, 
        new List<char>{'6', '9'}, new List<char>{'8', '8'}, new List<char>{'9', '6'}
    };
    
    public List<string> GenerateStroboNumbers(int n, int finalLength) {
        if (n == 0) {
            return new List<string> { "" };
        }
        
        if (n == 1) {
            return new List<string> { "0", "1", "8" };
        }
        
        List<string> prevStroboNums = GenerateStroboNumbers(n - 2, finalLength);
        List<string> currStroboNums = new List<string>();
        
        foreach (string prevStroboNum in prevStroboNums) {
            foreach (List<char> pair in reversiblePairs) {
                if (pair[0] != '0' || n != finalLength) {
                    currStroboNums.Add(pair[0] + prevStroboNum + pair[1]);
                }
            }
        }
        
        return currStroboNums;
    }
    
    public List<string> FindStrobogrammatic(int n) {
        return GenerateStroboNumbers(n, n);
    }
}

C++ solution

auto-draft, review before submit

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    private List<List<char>> reversiblePairs = new List<List<char>> {
        new List<char>{'0', '0'}, new List<char>{'1', '1'}, 
        new List<char>{'6', '9'}, new List<char>{'8', '8'}, new List<char>{'9', '6'}
    };
    
    public List<string> GenerateStroboNumbers(int n, int finalLength) {
        if (n == 0) {
            return new List<string> { "" };
        }
        
        if (n == 1) {
            return new List<string> { "0", "1", "8" };
        }
        
        List<string> prevStroboNums = GenerateStroboNumbers(n - 2, finalLength);
        List<string> currStroboNums = new List<string>();
        
        foreach (string prevStroboNum in prevStroboNums) {
            foreach (List<char> pair in reversiblePairs) {
                if (pair[0] != '0' || n != finalLength) {
                    currStroboNums.push_back(pair[0] + prevStroboNum + pair[1]);
                }
            }
        }
        
        return currStroboNums;
    }
    
    public List<string> FindStrobogrammatic(int n) {
        return GenerateStroboNumbers(n, n);
    }
}

Java solution

matched/original

import java.util.*;

class Solution {
    List<List<Character>> reversiblePairs = Arrays.asList(
        Arrays.asList('0', '0'), Arrays.asList('1', '1'), 
        Arrays.asList('6', '9'), Arrays.asList('8', '8'), Arrays.asList('9', '6')
    );
    
    public List<String> generateStroboNumbers(int n, int finalLength) {
        if (n == 0) {
            return Arrays.asList("");
        }
        
        if (n == 1) {
            return Arrays.asList("0", "1", "8");
        }
        
        List<String> prevStroboNums = generateStroboNumbers(n - 2, finalLength);
        List<String> currStroboNums = new ArrayList<>();
        
        for (String prevStroboNum : prevStroboNums) {
            for (List<Character> pair : reversiblePairs) {
                if (pair.get(0) != '0' || n != finalLength) {
                    currStroboNums.add(pair.get(0) + prevStroboNum + pair.get(1));
                }
            }
        }
        
        return currStroboNums;
    }
    
    public List<String> findStrobogrammatic(int n) {
        return generateStroboNumbers(n, n);
    }
}

JavaScript solution

matched/original

class Solution {
    constructor() {
        this.reversiblePairs = [
            ['0', '0'], ['1', '1'],
            ['6', '9'], ['8', '8'], ['9', '6']
        ];
    }

    generateStroboNumbers(n, finalLength) {
        if (n === 0) {
            return [""];
        }

        if (n === 1) {
            return ["0", "1", "8"];
        }

        const prevStroboNums = this.generateStroboNumbers(n - 2, finalLength);
        const currStroboNums = [];

        for (const prevStroboNum of prevStroboNums) {
            for (const pair of this.reversiblePairs) {
                if (pair[0] !== '0' || n !== finalLength) {
                    currStroboNums.push(pair[0] + prevStroboNum + pair[1]);
                }
            }
        }

        return currStroboNums;
    }

    findStrobogrammatic(n) {
        return this.generateStroboNumbers(n, n);
    }
}

Python solution

matched/original

class Solution:
    def __init__(self):
        self.reversiblePairs = [
            ('0', '0'), ('1', '1'), 
            ('6', '9'), ('8', '8'), ('9', '6')
        ]

    def generateStroboNumbers(self, n, finalLength):
        if n == 0:
            return [""]
        
        if n == 1:
            return ["0", "1", "8"]
        
        prevStroboNums = self.generateStroboNumbers(n - 2, finalLength)
        currStroboNums = []
        
        for prevStroboNum in prevStroboNums:
            for a, b in self.reversiblePairs:
                if a != '0' or n != finalLength:
                    currStroboNums.append(a + prevStroboNum + b)
        
        return currStroboNums

    def findStrobogrammatic(self, n):
        return self.generateStroboNumbers(n, n)

Go solution

matched/original

package main

func findStrobogrammatic(n int) []string {
  reversiblePairs := [][]string{
    {"0", "0"}, {"1", "1"},
    {"6", "9"}, {"8", "8"}, {"9", "6"},
  }

  var generateStroboNumbers func(int, int) []string
  generateStroboNumbers = func(n int, finalLength int) []string {
    if n == 0 {
      return []string{""}
    }

    if n == 1 {
      return []string{"0", "1", "8"}
    }

    prevStroboNums := generateStroboNumbers(n-2, finalLength)
    var currStroboNums []string

    for _, prevStroboNum := range prevStroboNums {
      for _, pair := range reversiblePairs {
        if pair[0] != "0" || n != finalLength {
          currStroboNums = append(currStroboNums, pair[0]+prevStroboNum+pair[1])
        }
      }
    }

    return currStroboNums
  }

  return generateStroboNumbers(n, n)
}

Explanation

Algorithm

1️⃣

Инициализируйте структуру данных reversiblePairs, которая содержит все пары обратимых цифр. Вызовите и верните результат рекурсивной функции generateStroboNumbers(n, finalLength), где первый аргумент указывает, что текущий вызов создаст все стробограмматические числа длиной n, а второй аргумент указывает длину конечных стробограмматических чисел, которые мы будем генерировать, и будет использоваться для проверки возможности добавления '0' в начало и конец числа.

2️⃣

Создайте функцию generateStroboNumbers(n, finalLength), которая вернет все стробограмматические числа длиной n:

Проверьте базовые случаи: если n == 0, верните массив с пустой строкой [""]; если n == 1, верните ["0", "1", "8"].

Вызовите generateStroboNumbers(n - 2, finalLength), чтобы получить все стробограмматические числа длиной (n-2), и сохраните их в subAns.

Инициализируйте пустой массив currStroboNums для хранения стробограмматических чисел длиной n.

3️⃣

Для каждого числа в subAns добавьте все reversiblePairs в начало и конец, за исключением случая, когда текущая пара '00' и n == finalLength (потому что нельзя добавить '0' в начало числа), и добавьте это новое число в currStroboNums. В конце функции верните все стробограмматические числа, т.е. currStroboNums.

😎