Wer muss die Groß- und Kleinschreibung unsensibel vergleichen, wenn Sie in der Lage sind, jede Permutation von Groß- und Kleinschreibung zu generieren? Niemand! _{Das ist die Antwort. Niemand tut.} Ihre Aufgabe ist es, dieses Kunststück zu erreichen; Generieren Sie alle möglichen Permutationen in Groß- / Kleinschreibung für eine bestimmte Eingabe.

Eingang

Eine Zeichenfolge aus druckbaren Standard-ASCII-Zeichen. Es sollte nicht davon ausgegangen werden, dass die Eingabe nur in Kleinbuchstaben erfolgt. Die Eingabe besteht immer aus mindestens einem Zeichen.

Ausgabe

Jede Permutation von Groß- und Kleinschreibung für die eingegebene Zeichenfolge (keine Duplikate). Dies sollte nur Zeichen mit einer kleinen und einer großen Version ändern (Zahlen bleiben gleich). Jede Permutation muss als Zeichenfolge oder Liste von Zeichen ausgegeben werden. Listen von Singleton-Strings sind nicht erlaubt.

Beispiele

a1a
['a1a', 'a1A', 'A1a', 'A1A']

abc
['abc', 'abC', 'aBc', 'aBC', 'Abc', 'AbC', 'ABc', 'ABC']

Hi!
['hi!', 'hI!', 'Hi!', 'HI!'] 

Wertung

Das ist Code-Golf , also gewinnt die kürzeste Antwort (in Bytes).

Sehen Sie sich zum Spaß an, wie viel zusätzlicher Aufwand erforderlich ist, um die erweiterten ASCII-Zeichen zu verarbeiten. Hier ist ein zusätzlicher Testfall:

ž1a -> ['ž1a', 'ž1A', 'Ž1a', 'Ž1A']

(Ihr Programm muss dies nicht unterstützen)

Pyth, 13 12 11

{msrVQd^U2l

1 Byte dank Leaky Nun!

Noch ein Byte dank Jakube!

Probieren Sie es hier aus oder führen Sie eine Test Suite aus

Wir erstellen eine Liste von Listen-Wahr / Falsch-Werten, indem wir das kartesische Produkt der Liste so [0, 1]oft mit sich führen, wie es der Länge der Eingabezeichenfolge entspricht. Jede der Unterlisten hat also die gleiche Länge wie die Eingabezeichenfolge. Dann wenden wir die rFunktion als Vektoroperation auf die Eingabe und die Liste an, sodass wir r letter valuefür jedes Unterelement erhalten. rmit dem zweiten Argument steht null für Kleinbuchstaben und mit eins für Großbuchstaben. Dies erzeugt Duplikate auf Nicht-Buchstaben, was bedeutet, dass wir Duplikate aus dem Ergebnis entfernen müssen.

Gelee , 6 Bytes

żŒsŒpQ

Dies ist eine monadische Verknüpfung (Funktion), die eine Zeichenfolge als linkes Argument erwartet und eine Liste von Zeichenfolgen zurückgibt.

Verarbeitet Nicht-ASCII-Zeichen. Probieren Sie es online!

Wie es funktioniert

żŒsŒpQ  Monadic link. Argument: s (string)

 Œs     Swapcase; change the case of all letters in s.
ż       Zipwith; pair each character with itself with changed case.
   Œp   Take the Cartesian product of all pairs.
     Q  Unique; deduplicate the Cartesian product.

Python, 74 71 Bytes

f=lambda s:s and{r[0]+t for r in{s,s.swapcase()}for t in f(s[1:])}or{s}

Verarbeitet Nicht-ASCII-Zeichen. Teste es auf Ideone .

Oracle SQL 11.2, 276 Byte

WITH v AS(SELECT SUBSTR(:1,LEVEL,1)c,ROWNUM p FROM DUAL CONNECT BY LEVEL<=LENGTH(:1))SELECT w FROM(SELECT REPLACE(SYS_CONNECT_BY_PATH(c,','),',','')w FROM(SELECT UPPER(c)c,p FROM v UNION SELECT LOWER(c),p FROM v)START WITH p=1CONNECT BY PRIOR p=p-1)WHERE LENGTH(:1)=LENGTH(w);

Nicht golfen

WITH v AS
( -- Split input into an array of characters 
  SELECT SUBSTR(:1,LEVEL,1)c,ROWNUM p FROM DUAL CONNECT BY LEVEL<=LENGTH(:1)
)
SELECT w 
FROM   ( -- Build every string combination
         SELECT REPLACE(SYS_CONNECT_BY_PATH(c,','),',','')w 
         FROM   ( -- Merge upper and lower arrays, keep same position for each character, it allows to mix cases
                  SELECT UPPER(c)c,p FROM v UNION SELECT LOWER(c),p FROM v
                )
         START WITH p=1          -- Start with first character (either lowercase or uppercase)
         CONNECT BY PRIOR p=p-1  -- Add the next character (either lowercase or uppercase)
       )
WHERE LENGTH(:1)=LENGTH(w); -- Keep only full strings

Hässlich wie die Hölle, muss mehr Golf sein.

05AB1E, 17 Bytes

Code:

vyDš‚N0Êiâvy˜J})Ù

Erklärt:

vy                     # for each character in input
  Dš‚                  # create a pair of different case, eg: ['ž', 'Ž']
     N0Êiâ             # for all pairs but the first, take cartesian product
                         result will be a list of layered lists eg: [['ž', '1'], 'a'] 
            vy         # for each such list
              ˜J}      # deep flatten and join as a string eg: ž1a
                 )Ù    # wrap in array and remove duplicates

Probieren Sie es online aus

Brachylog , 25 22 Bytes

:ef:1fd.
:2ac.
@u.|@l.

Dies funktioniert genauso wie die Prädikate in Klein- und Großbuchstaben von Prolog, daher auch für Nicht-ASCII-Buchstaben:

?- run("ž1a",Z).
Z = ["Ž1A", "Ž1a", "ž1A", "ž1a"] .

Erläuterung

Im Gegensatz zu allen anderen Antworten, die ich derzeit veröffentliche, wird der kartesische Produktansatz überhaupt nicht verwendet.

• Hauptprädikat

  :ef       Split the Input string into a list of 1-char strings
     :1f    Find all valid outputs of predicate 1 with the previous list
            of outputs as input
        d.  Unify the Output with that list excluding all duplicates
  

• Prädikat 1

Dies wird verwendet, um Groß- oder Kleinschreibung auf jedes Zeichen der Eingabe anzuwenden und so eine mögliche Permutation zu berechnen. Wenn Sie findall für dieses Prädikat im Hauptprädikat verwenden, können Sie alle möglichen Permutationen (mit einigen Duplikaten) berechnen.

    :2a       Apply predicate 2 on the each element of the Input
       c.     Unify the Output with the concatenation of the elements of
              the previous list

• Prädikat 2

Dies wird verwendet, um ein Zeichen der Zeichenfolge in Groß- oder Kleinbuchstaben umzuwandeln.

    @u.       Unify the Output with the uppercase version of the Input
       |      Or
        @l.   Unify the Output with the lowercase version of the input

Haskell, 69-58 Bytes

import Data.Char
mapM(\x->toLower x:[toUpper x|isAlpha x])

Probieren Sie es online!

Edit: @Angs hat 11 Bytes gespeichert. Vielen Dank!

MATL , 13 Bytes

tYov!Z}N$Z*Xu

Probieren Sie es online!

Erläuterung

t       % Implicit input string. Duplicate
Yo      % Change case of string
v       % Concatenate as a 2xN char array, where N is input length
!       % Transpose: Nx2 char array. Each row has different case, if letter
Z}      % Split into rows: gives N strings of 2 chars. Each char has different 
        % case if it's a letter, or is repeated otherwise
N$      % Specify N inputs for next function
Z*      % Cartesian product of the N strings. Each combination is a row.
        % Repeated chars (i.e. non-letters) give rise to duplicate rows.
Xu      % Remove duplicate rows. Implicit display

JavaScript (Firefox 30-57), 92 bis 90 Byte

f=([c,...s])=>c?[for(t of f(s))for(d of new Set(c.toUpperCase()+c.toLowerCase()))d+t]:['']

Bearbeiten: 2 Bytes gespeichert, da new Setdie eindeutigen Zeichen aus einer Zeichenfolge extrahiert werden.

Perl 6 , 37 Bytes

{[X~] '',|.comb.map:{unique .lc,.uc}}

Versuch es

Erläuterung:

{
  [X[~]]                     # cross combine using &infix:<~> operator
    '',                      # empty string so that 1 character strings work
    |                        # flatten the following into outer list
      .comb                  # get every character from input string
      .map:                  # and map it with:
        { unique .lc, .uc }
}

Prüfung:

#! /usr/bin/env perl6

use v6.c;
use Test;

my &case-permutation = {[X~] '',|.comb.map: {unique .lc,.uc}}

my @tests = (
  'a1a' => <a1a a1A A1a A1A>,
  'abc' => <abc abC aBc aBC Abc AbC ABc ABC>,
  'Hi!' => <hi! hI! Hi! HI!>,
  'ž1a' => <ž1a ž1A Ž1a Ž1A>,
);

plan +@tests;

for @tests -> $_ (:key($input),:value($expected)) {
  is case-permutation($input).sort, $expected.sort, .gist
}

1..4
ok 1 - a1a => (a1a a1A A1a A1A)
ok 2 - abc => (abc abC aBc aBC Abc AbC ABc ABC)
ok 3 - Hi! => (hi! hI! Hi! HI!)
ok 4 - ž1a => (ž1a ž1A Ž1a Ž1A)

Julia, 66 60 Bytes

!s=s>""?[~s[1:1]t for~=(ucfirst,lcfirst),t=!s[2:end]]∪[]:[s]

Probieren Sie es online!

Python, 69 Bytes

import itertools as i;f=lambda s:set(i.product(*zip(s,s.swapcase())))

Eigentlich 28 Bytes

;╗l2r∙`"'Ö*£"£M╜@Z"iƒ"£MΣ`M╔

Probieren Sie es online!

Dieses Programm kann dank der Magie von Python 3 auch Nicht-ASCII-Zeichen verarbeiten.

Erläuterung:

;╗l2r∙`"'Ö*£"£M╜@Z"iƒ"£MΣ`M╔
;╗                            save a copy of input to reg0
  l                           length of input
   2r                         [0,1]
     ∙                        Cartesian product with self (length of input) times
      `                  `M   map:
       "'Ö*£"£M                 push `Ö` (swapcase) if 1 else `` for each value in list
               ╜@Z              zip with input
                  "iƒ"£M        swap the case of those values
                        Σ       join string
                           ╔  unique elements

C 229 252 Bytes

i,n,j,k,l;f(char *s){l=strlen(s);for(i=0;i<l;i++)s[i]=tolower(s[i]);int v[l];for(i=0;i<l;i++)v[i]=0;for(i=0;i<pow(2,l);i++){n=i,k=0;for(;n;k++){v[k]=n;n/=2;}for(j=0;j<l;j++){v[j]%=2;if(v[j])s[j]=toupper(s[j]);else s[j]=tolower(s[j]);}printf("%s ",s);}}

Ungolfed-Version:

void f(char *s)
{
  int i,num,k,l=strlen(s);
  for(i=0;i<l;i++)
     s[i]=tolower(s[i]);

   int v[l];
   for(i=0;i<l;i++) 
     v[i]=0;   

   for(i=0;i<pow(2,l);i++)
   {
      num=i,k=0;
      for(;num;k++)
      {
         v[k]=num;
         num/=2;        
      } 

      for(int j=0;j<l;j++)
      {
        v[j]%=2;

        if(v[j])
         s[j]=toupper(s[j]);
        else
         s[j]=tolower(s[j]);

      }
      printf("%s \n",s);       

   } 
}

Erläuterung:

• Akzeptieren Sie die Zeichenfolge, konvertieren Sie die Zeichenfolge in Kleinbuchstaben.
• Deklarieren Sie ein ganzzahliges Array mit der Länge der Zeichenfolge. Fülle es mit Nullen.
• Speichern Sie die Zahlen von 0 bis 2^strlen(s)in binärer Form in einem intArray. (Für eine 3-Byte-Zeichenfolge: 000,001,010 ... 111)
• Abhängig davon, ob ein Bit an einer Position gesetzt ist oder, schalten Sie die Groß- / Kleinschreibung um.
• Geben Sie den String für jede mögliche Kombination aus.

Probieren Sie es online!

Hoon , 242 Bytes

|=
t/tape
=+
l=(reap (pow 2 (lent t)) t)
%+
roll
(gulf 0 (dec (lent l)))
|=
{a/@ b/(set tape)}
=+
%+
turn
(gulf 0 (dec (lent t)))
|=
n/@
=+
t=(snag n t)
=+
k=(trip t)
?:
=(0 (cut 0 n^1 a))
?:
=((cuss k) t)
(cass k)
(cuss k)
t
(~(put in b) -)

Ungolfed:

|=  t/tape
=+  l=(reap (pow 2 (lent t)) t)
%+  roll  (gulf 0 (dec (lent l)))
|=  {a/@ b/(set tape)}
    =+  %+  turn  (gulf 0 (dec (lent t)))
      |=  n/@
      =+  t=(snag n t)
      =+  k=(trip t)
      ?:  =(0 (cut 0 n^1 a))
        ?:  =((cuss k) t)
              (cass k)
        (cuss k)
      t
    (~(put in b) -)

Ich bin mir nicht sicher, wie viel kleiner das sein könnte, leider.

Zunächst setzen wir lgleich einer Liste mit 2 ^ (Länge t) Wiederholungen von t. Hoon hat keine facFunktion in der stdlib, aber 2 ^ n ist immer größer als n !, also ordnen wir einfach die größere Liste zu und verwenden eine set(Hashmap), um Einträge zu de-duplizieren.

Wir falten dann die Liste [0 .. (Länge l)] zusammen und addieren sie zu a (set tape). Wir müssen dies tun, anstatt es ldirekt abzubilden, weil wir auch wissen müssen, um welche Zahlenwiederholung es sich handelt ( a), aber wir können einen Akkumulator nicht einfach inkrementieren, da Hoon eine reine Sprache ist.

Wir bilden über [0 .. (Länge t)] ab (wieder haben wir den aktuellen Index), setzen ihn tauf das n-te Zeichen in der Zeichenkette, prüfen, ob das n-te Bye ader Groß- / Kleinschreibung vorliegt, und kehren ihn um (cuss oder cass, je nachdem, ob es sich ändert) oder nicht). Der Rückgabetyp dieser Map ist a tape.

Wir fügen dann die Zeichenkette in unsere Hashmap ein und geben die Hashmap aller Zeichenketten zurück.

C 216 Bytes

k,i,j,p,n,m;z(char *c){n=-1;m=0;while(c[++n])if(c[n]>64&c[n]<90)c[n]+=32;else if(c[n]<'a'|c[n]>'z')m++;k=1<<(n-m);for(j=0;j<k;j++){for(i=0;i<n;i++){p=1<<i;putc((j&p)==p?toupper(c[i]):c[i],stdout);}putc(0xa,stdout);}}

Dies ist ein anderer Ansatz , der gleiche Ansatz wie bei der anderen C-Antwort.

Sollte ich dies löschen und als Kommentar unter die andere Antwort setzen?

Lassen Sie mich mit der Ungolfed-Version erklären

k,i,j,p,n,m;
z(char * c) {
    int n=-1;       // We start at -1 because of forward incrementation
    int m=0;        // this will count the characters we don't have to manipulate
    while(c[++n])   // go until we reach '\0'
    {
        if(c[n]>='a'&c[n]<='z')c[n]-=32; // If we are lower case, then convert
        else if(c[n]<'A'|c[n]>'Z')m++;   // If we are neigther lower case
                                         // nor upper, then make a note
    }

    // get 2 ^ ("length" - "number of invonvertibles")
    k=1<<(n-m); 
    for(j=0;j<k;j++) {      // go through the combinations
        for(i=0;i<n;i++) {  // for each combination go though the characters
            p=1<<i;         // for each character get it's bit position
            putc(
                // if the bit position is set (==1) 
                (j&p)==p ?
                   tolower(c[i]) // convert
                   : c[i], // else: don't
                stdout);
        }
        putc(0xa, stdout);  // print a newline
    }
}

Python3, 96 Bytes

i=input().lower()
for l in{*__import__('itertools').product(*zip(i,i.upper()))}:print(*l,sep='')

Spät auf die Party, aber immer noch ausprobiert. Vielen Dank an DLosc, der mich an die Dinge erinnert hat, die ich verpasst habe. Er gab mir Golftipps und sparte mir ein paar Bytes. :)

Wolfram Language (Mathematica) , 55 Byte

""<>#&/@Union@Tuples[{#,ToUpperCase@#}]&@*Characters

Probieren Sie es online!

ist der transponierte Operator (und wird in Mathematica als hochgestelltes T angezeigt ).

Perl 5 , 52 + 1 ( -n) = 53 Bytes

@k{glob s/./lc("{$&,").uc"$&}"/ger}++;say for keys%k

Probieren Sie es online!

Tcl, 165.181 Bytes

set n -1
while {[incr n]<1<<[llength [set s [split $argv {}]]]} {puts [join [lmap c $s b [split [format %0[llength $s]b $n] {}] {string to[expr $b?{u}:{l}] $c}] ""]}

Verbesserungen dank Sergiol . Vorherige Antwort:

set s [split $argv {}]
set n -1
while {[incr n]<1<<[llength $s]} {set r ""
foreach c $s b [split [format %0[llength $s]b $n] {}] {set r $r[string [expr $b?{tou}:{tol}] $c]}
puts $r}

Verwendet eine Binärzahl, um beim Erstellen des Ausgabetexts zwischen Groß- und Kleinschreibung zu wählen.

Perl 5 , 30 Bytes

s/\pl/{\l$&,\u$&}/g;say<"$_ ">

Probieren Sie es online!

Gibt am Ende der Ausgabe ein zusätzliches Leerzeichen aus.

Attache , 39 Bytes

&Cross[Sum@V]##Unique@V#SwapCase=>Chars

Probieren Sie es online!

Ähnlich wie bei der Perl-Antwort. (Ich habe meine interessantere Alternative verloren, die sollte ich in den nächsten Stunden veröffentlichen.)

JavaScript (ES6), 103

Verarbeitet Nicht-ASCII-Zeichen

(a,r=new Set)=>a?f(a.slice(1)).map(v=>(C=o=>r.add(a[0][`to${o}erCase`]()+v),C`Upp`,C`Low`))&&[...r]:[a]

Prüfung

f=(a,r=new Set)=>a?f(a.slice(1)).map(v=>(C=o=>r.add(a[0][`to${o}erCase`]()+v),C`Upp`,C`Low`))&&[...r]:[a]

function test() { O.textContent = f(I.value).join('\n') }

test()

<input id=I oninput='test()' value='ž1a'>
<pre id=O></pre>