Büyük ve küçük harflerin her permütasyonunu üretebildiğiniz zaman, olayları duyarsızca kim karşılaştırabilir? Hiç kimse! _{Cevap bu. Kimse yapmaz.} Görevin bu başarıya ulaşmak; Verilen bir giriş için olası tüm büyük harf / küçük harf izinlerini oluşturur.

Giriş

Yazdırılabilir standart ascii karakterleri dizesi. Girişin tümünün küçük harf olduğu varsayılmamalıdır. Giriş her zaman en az bir karakter olacaktır.

Çıktı

Girilen dize için her büyük ve küçük harf permütasyonu (kopya yok). Bu sadece küçük ve büyük versiyonlu karakterleri değiştirmelidir (sayılar aynı kalacaktır). Her permütasyon bir karakter dizisi veya bir karakter listesi olarak çıkarılmalıdır; tekil dizelerin listelerine izin verilmiyor.

Örnekler

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

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

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

puanlama

Bu kod-golf , bu yüzden en kısa cevap (bayt cinsinden) kazanır.

Eğlenceli bir ekstra olarak, genişletilmiş ascii karakterlerini kullanmak için ne kadar çaba sarf edileceğini görün, işte ekstra bir test durumu:

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

(programınızın bunu desteklemesi gerekmez)

Pyth, 13 12 11

{msrVQd^U2l

Leaky Nun'a 1 byte teşekkürler!

Jakube'ye bir bayt daha!

Burada deneyin veya bir Test Suite çalıştırın

Listenin kartezyen ürününü [0, 1], giriş dizesinin uzunluğuna eşit sayıda alarak alarak Gerçek / Yanlış değerlerin bir listesini oluştururuz . Böylece, alt listelerin her biri giriş dizesiyle aynı uzunluğa sahiptir. Sonra rişlevi giriş ve listeye bir vektör işlemi olarak uygularız , böylece r letter valueher bir alt öğe için elde ederiz. rikinci argümanla sıfır küçük harf olur ve bir büyük harf olur. Bu, harf olmayanlarda kopyalar oluşturur; sonuçta kopyaları çıkarmamız gerektiği anlamına gelir.

Jöle , 6 bayt

żŒsŒpQ

Bu, bir dizgiyi sol argüman olarak bekleyen ve dizelerin bir listesini döndüren tek yönlü bir bağlantıdır (işlev).

ASCII olmayan karakterleri işler. Çevrimiçi deneyin!

Nasıl çalışır

żŒ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 bayt

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

ASCII olmayan karakterleri işler. İdeone üzerinde test et .

Oracle SQL 11.2, 276 bayt

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);

Un-golfed

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

Cehennem kadar çirkin, daha çok golf oynamalısın.

05AB1E, 17 bayt

Kod:

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

Açıklaması:

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

Çevrimiçi deneyin

Brachylog , 25 22 bayt

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

Bu, Prolog'un küçük harf / büyük harf tahminlerinin yanı sıra ASCII olmayan harflerle de çalışır:

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

açıklama

Bunu gönderdiğim andan itibaren diğer tüm cevapların aksine, bu kartezyen ürün yaklaşımını hiç kullanmaz.

• Ana tahmin

  :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
  

• 1 tahmin et

Bu, girişin her bir karakterine büyük harf veya küçük harf uygulamak için kullanılır, böylece olası bir permütasyon hesaplanır. Bu yüklemede ana yüklemede findall kullanılması, tüm olası permütasyonları (bazı kopyalarla birlikte) hesaplamayı sağlar.

    :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

• Tahmin 2

Bu, dizenin bir karakterini büyük veya küçük harf sürümüne dönüştürmek için kullanılır.

    @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 bayt

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

Çevrimiçi deneyin!

Düzenleme: @Angs 11 bayt kaydetti. Teşekkürler!

MATL , 13 bayt

tYov!Z}N$Z*Xu

Çevrimiçi deneyin!

açıklama

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 90 bayt

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

Düzenleme: 2 bayt kaydedildi, çünkü new Setbenzersiz karakterleri bir dizeden mutlu bir şekilde çıkaracak.

Perl 6 , 37 bayt

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

Dene

Açıklama:

{
  [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 }
}

Ölçek:

#! /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 bayt

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

Çevrimiçi deneyin!

Python, 69 bayt

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

Aslında, 28 bayt

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

Çevrimiçi deneyin!

Bu program, Python 3'ün büyüsü sayesinde ASCII olmayan karakterleri idare edebilir.

Açıklama:

;╗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 bayt

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 versiyonu:

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);       

   } 
}

Açıklama:

• Karakter dizesini kabul edin, dizeyi küçük harfe dönüştürün.
• Tamsayı uzunluğunu, dizeninkine eşit olarak bildirir. Sıfırlarla doldurun.
• 0'dan 0'a kadar olan sayıları 2^strlen(s)bir intdizide ikili biçimde saklayın (3 baytlık bir dize için: 000,001,010 ... 111)
• Bir pozisyonda bir bitin ayarlanıp ayarlanmadığına bağlı olarak veya durumu değiştirin.
• Her olası kombinasyon için dizgiyi çıkar.

Çevrimiçi deneyin!

Hoon , 242 bayt

|=
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) -)

Maalesef bunun daha küçük olabileceğinden emin değilim.

İlk önce, l2 ^ (uzunluk t) tekrarı olan bir listeye eşitledik t. facHoon'un stdlib'de bir işlevi yoktur, ancak 2 ^ n her zaman n! 'Den daha büyüktür, bu yüzden daha büyük listeyi seteşleriz ve girişleri kopyalamak için bir (hashâf) kullanırız.

Daha sonra, [0 .. (l) boyunda] listesini bir a toplayarak katladık (set tape). lDoğrudan haritalamak yerine bunu yapmamız gerekiyor çünkü bunun ne kadar tekrar olduğunu biliyoruz ( a), ama Hoon'un saf bir dil olması nedeniyle bir akümülatörü artıramıyoruz.

[0 .. (uzunluk t)] üzerinde eşleriz (yine de geçerli dizine sahip oluruz), tdizedeki nth karakterine ayarlanır a, büyük / küçük harf değişkeni olup olmadığını kontrol eder (değişip değişmediğine bağlı olarak cuss veya cass) ya da değil). Bu haritanın dönüş tipi a tape.

Daha sonra ipi hashasamıza koyarız ve tüm iplerin hashasına döneriz.

C, 216 bayt

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);}}

Bu farklı bir yaklaşım , diğer C cevabı ile aynı yaklaşım.

Bunu silmeli ve yorum olarak diğer cevabın altına koymalı mıyım?

Ungolfed versiyonuyla açıklayayım

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 bayt

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

Partiye geç kaldı ama yine de gitti. Bana kaçırdığım şeyleri hatırlattığı, golfle ilgili ipuçları verdiği ve beni bir sürü baytı kurtardığı için DLosc'a teşekkürler. :)

Wolfram Dili (Mathematica) , 55 bayt

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

Çevrimiçi deneyin!

devrik işlecidir (ve Mathematica'da üst simge T olarak görüntülenir ).

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

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

Çevrimiçi deneyin!

Tcl, 165 181 bayt

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}] ""]}

Sergiol sayesinde iyileştirmeler . Önceki cevap:

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}

Çıktı metni oluştururken büyük / küçük harf arasında seçim yapmak için ikili bir sayı kullanır.

Perl 5 , 30 bayt

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

Çevrimiçi deneyin!

Çıktı sonunda ek bir boşluk çıkar.

Ataşesi , 39 bayt

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

Çevrimiçi deneyin!

Perl cevabına benzer. (Daha ilginç alternatifimi kaybettim, önümüzdeki birkaç saat içinde göndermeliyim.)

JavaScript (ES6), 103

ASCII olmayan karakterleri işler

(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]

Ölçek

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>