count-almost-equal-pairs-ii

java

python

python3

mysql

mssql

oraclesql

csharp

javascript

typescript

bash

swift

kotlin

dart

golang

ruby

scala

rust

racket

erlang

elixir

pythondata

postgresql

cangjie

Algorithms

Attention: In this version, the number of operations that can be performed, has been increased to twice.

You are given an array <code>nums</code> consisting of positive integers.

We call two integers <code>x</code> and <code>y</code> almost equal if both integers can become equal after performing the following operation at most twice:

<ul>
	<li>Choose either <code>x</code> or <code>y</code> and swap any two digits within the chosen number.</li>
</ul>

Return the number of indices <code>i</code> and <code>j</code> in <code>nums</code> where <code>i &lt; j</code> such that <code>nums[i]</code> and <code>nums[j]</code> are almost equal.

Note that it is allowed for an integer to have leading zeros after performing an operation.

&nbsp;
Example 1:

<div class="example-block">
Input: nums = [1023,2310,2130,213]

Output: 4

Explanation:

The almost equal pairs of elements are:

<ul>
	<li>1023 and 2310. By swapping the digits 1 and 2, and then the digits 0 and 3 in 1023, you get 2310.</li>
	<li>1023 and 213. By swapping the digits 1 and 0, and then the digits 1 and 2 in 1023, you get 0213, which is 213.</li>
	<li>2310 and 213. By swapping the digits 2 and 0, and then the digits 3 and 2 in 2310, you get 0213, which is 213.</li>
	<li>2310 and 2130. By swapping the digits 3 and 1 in 2310, you get 2130.</li>
</ul>
</div>

Example 2:

<div class="example-block">
Input: nums = [1,10,100]

Output: 3

Explanation:

The almost equal pairs of elements are:

<ul>
	<li>1 and 10. By swapping the digits 1 and 0 in 10, you get 01 which is 1.</li>
	<li>1 and 100. By swapping the second 0 with the digit 1 in 100, you get 001, which is 1.</li>
	<li>10 and 100. By swapping the first 0 with the digit 1 in 100, you get 010, which is 10.</li>
</ul>
</div>

&nbsp;
Constraints:

<ul>
	<li><code>2 &lt;= nums.length &lt;= 5000</code></li>
	<li><code>1 &lt;= nums[i] &lt; 107</code></li>
</ul>

countPairs

Count Almost Equal Pairs II

Find the Occurrence of First Almost Equal Substring

find-the-occurrence-of-first-almost-equal-substring

第一个几乎相等子字符串的下标

Array

Hash Table

Counting

Enumeration

Sorting

注意：在这个问题中，操作次数增加为至多&nbsp;两次&nbsp;。

给你一个正整数数组&nbsp;<code>nums</code>&nbsp;。

如果我们执行以下操作 至多两次&nbsp;可以让两个整数&nbsp;<code>x</code> 和&nbsp;<code>y</code>&nbsp;相等，那么我们称这个数对是 近似相等&nbsp;的：

<ul>
	<li>选择&nbsp;<code>x</code> 或者&nbsp;<code>y</code> &nbsp;之一，将这个数字中的两个数位交换。</li>
</ul>

请你返回 <code>nums</code>&nbsp;中，下标 <code>i</code>&nbsp;和 <code>j</code>&nbsp;满足&nbsp;<code>i &lt; j</code>&nbsp;且&nbsp;<code>nums[i]</code> 和&nbsp;<code>nums[j]</code> 近似相等&nbsp;的数对数目。

注意&nbsp;，执行操作后得到的整数可以有前导 0 。

&nbsp;

示例 1：

<div class="example-block">
输入：nums = [1023,2310,2130,213]

输出：4

解释：

近似相等数对包括：

<ul>
	<li>1023 和 2310 。交换 1023 中数位 1 和 2 ，然后交换数位 0 和 3 ，得到 2310 。</li>
	<li>1023 和 213 。交换 1023 中数位 1 和 0 ，然后交换数位 1 和 2 ，得到 0213 ，也就是 213 。</li>
	<li>2310 和 213 。交换 2310 中数位 2 和 0 ，然后交换数位 3 和 2 ，得到 0213 ，也就是 213 。</li>
	<li>2310 和 2130 。交换 2310 中数位 3 和 1 ，得到 2130 。</li>
</ul>
</div>

示例 2：

<div class="example-block">
输入：nums = [1,10,100]

输出：3

解释：

近似相等数对包括：

<ul>
	<li>1 和 10 。交换 10 中数位 1 和 0&nbsp;，得到 01 ，也就是 1&nbsp;。</li>
	<li>1 和 100 。交换 100 中数位 1 和从左往右的第二个 0 ，得到 001 ，也就是 1 。</li>
	<li>10 和 100 。交换 100 中数位 1 和从左往右的第一个 0 ，得到 010 ，也就是 10 。</li>
</ul>
</div>

&nbsp;

提示：

<ul>
	<li><code>2 &lt;= nums.length &lt;= 5000</code></li>
	<li><code>1 &lt;= nums[i] &lt;&nbsp;107</code></li>
</ul>