Find All Upper, Lower and Mixed Case Combinations of a String

import itertools

s = 'Fox'
map(''.join, itertools.product(*zip(s.upper(), s.lower())))
>>> ['FOX', 'FOx', 'FoX', 'Fox', 'fOX', 'fOx', 'foX', 'fox']

import itertools
string = 'abc12@abc.com'
x = map(''.join, itertools.product(*(set((c.upper(), c.lower())) for c in string)))
assert len(list(x)) == 512

0000 | word
1000 | Word
0100 | wOrd
1100 | WOrd
...
1111 | WORD

// Used to display the results
const write = (msg) => {
  document.body.appendChild(document.createElement('div')).innerHTML = msg;
};

const input = "word";
const letters = input.split("");
const permCount = 1 << input.length;

for (let perm = 0; perm < permCount; perm++) {
  // Update the capitalization depending on the current permutation
  letters.reduce((perm, letter, i) => {
    letters[i] = (perm & 1) ? letter.toUpperCase() : letter.toLowerCase();
    return perm >> 1;
  }, perm);

  const result = letters.join("");
  write(result);
}

import itertools

chars = "abc"
results = list(map(''.join, itertools.product(*zip(chars.upper(), chars.lower()))))

print(results)
>>>['ABC', 'ABc', 'AbC', 'Abc', 'aBC', 'aBc', 'abC', 'abc']

1. Create axes	2. Take Cartesian product

Find all upper,lower combinations of string in Python

There are a few ways of achieving that. Here they are:

1. Changing the case of the string you are searching into:

line[i].lower().find(string.lower())

or

line[i].upper().find(string.upper())

Here we're abusing of the immutability of the original strings, since they won't be changed although we apply .upper() to them, since we're not doing any assignment.

2. using the re module would also be helpful:

import re
re.search('all', line[0], re.IGNORECASE)

or

re.search('(?i)all',line[0])

Find all upper/lower/mixed combinations of a string

You can use recursive generator. The first parameter contains left part of the string generated so far, and the second parameter is the remaining right part of the original string.

function combinations(s1, s2)
        if s2:len() > 0 then
                local c = s2:sub(1, 1)
                local l = c:lower()
                local u = c:upper()
                if l == u then
                        combinations(s1 .. c, s2:sub(2))
                else
                        combinations(s1 .. l, s2:sub(2))
                        combinations(s1 .. u, s2:sub(2))
                end
        else
                print(s1)
        end
end

So the function is called in this way.

combinations("", "ABC_-123")

You only have to store intermediate results instead of printing them.

PHP - all combination upper and lower case characters of string

A bit of a code dump with some comments thrown in for good measure. This was converted from the Java implementation - https://stackoverflow.com/a/6785649/296555

http://sandbox.onlinephpfunctions.com/code/aadefa26561a0e33c48fd1d147434db715c8fc59

November 2020 - This answer has was updated in 2 places. See the revision history for details.

<?php

function calculatePermutations($text) {

    $permutations = array();
    $chars = str_split($text);
    
    // Count the number of possible permutations and loop over each group 
    for ($i = 0; $i < 2 ** strlen($text); $i++) {
        
        // Loop over each letter [a,b,c] for each group and switch its case
        for ($j = 0; $j < strlen($text); $j++) {
            
            // isBitSet checks to see if this letter in this group has been checked before
            // read more about it here: http://php.net/manual/en/language.operators.bitwise.php
            $permutations[$i][] = (isBitSet($i, $j)) 
                ? strtoupper($chars[$j]) 
                : $chars[$j];
        }
    }
    
    return $permutations;
}

function isBitSet($n, $offset) {
  return ($n >> $offset & 1) != 0;
}

print_r(calculatePermutations('abc'));

Finding all possible case permutations in Python

def all_casings(input_string):
    if not input_string:
        yield ""
    else:
        first = input_string[:1]
        if first.lower() == first.upper():
            for sub_casing in all_casings(input_string[1:]):
                yield first + sub_casing
        else:
            for sub_casing in all_casings(input_string[1:]):
                yield first.lower() + sub_casing
                yield first.upper() + sub_casing

---

>>> [x for x in all_casings("foo")]
['foo', 'Foo', 'fOo', 'FOo', 'foO', 'FoO', 'fOO', 'FOO']
>>> list(all_casings("foo"))
['foo', 'Foo', 'fOo', 'FOo', 'foO', 'FoO', 'fOO', 'FOO']

How to get every combination of a string?

You can use binary combinations 01110, 00011 etc. with itertools.product() to get every combination of cases with a string. This means setting the 1's as uppercase and the 0's as lowercase. So 01110 -> hOUSe, 00011 -> houSE etc.

from itertools import product

def get_all_cases(string):
    return [
        "".join(
            letter.upper() if binary == 1 else letter
            for letter, binary in zip(string.lower(), binary_comb)
        )
        for binary_comb in product([0, 1], repeat=len(string))
    ]

Output:

>>> get_all_cases("House")
>>> ['house', 'housE', 'houSe', 'houSE', 'hoUse', 'hoUsE', 'hoUSe', 'hoUSE', 'hOuse', 'hOusE', 'hOuSe', 'hOuSE', 'hOUse', 'hOUsE', 'hOUSe', 'hOUSE', 'House', 'HousE', 'HouSe', 'HouSE', 'HoUse', 'HoUsE', 'HoUSe', 'HoUSE', 'HOuse', 'HOusE', 'HOuSe', 'HOuSE', 'HOUse', 'HOUsE', 'HOUSe', 'HOUSE']

You can also just map to True and False boolean values instead of 1 and 0.

from itertools import product

def get_all_cases(string):
    return [
        "".join(
            letter.upper() if is_upper else letter
            for letter, is_upper in zip(string.lower(), comb)
        )
        for comb in product([False, True], repeat=len(string))
    ]

---

Related Topics