대문자와 소문자의 모든 순열을 생성 할 수있을 때 대소 문자를 구분하지 않고 비교해야하는 사람은 누구입니까? 아무도! _{그게 답입니다. 아무도 없습니다.} 당신의 임무는이 위업을 달성하는 것입니다; 주어진 입력에 대해 대문자 / 소문자의 가능한 모든 순열을 생성합니다.

입력

인쇄 가능한 표준 ASCII 문자 문자열입니다. 입력이 모두 소문자로 가정해서는 안됩니다. 입력은 항상 하나 이상의 문자입니다.

산출

입력 된 문자열에 대한 대문자와 소문자의 모든 순열 (중복 없음). 작고 큰 버전의 문자 만 변경해야합니다 (숫자는 동일하게 유지됨). 각 순열은 문자열 또는 문자 목록으로 출력되어야합니다. 싱글 톤 문자열 목록은 허용되지 않습니다.

예

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

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

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

채점

이것은 code-golf 이므로 가장 짧은 답변 (바이트)이 이깁니다.

재미있는 추가로 확장 ASCII 문자를 처리하는 데 얼마나 많은 노력이 필요한지 확인하십시오. 여기에는 추가 테스트 사례가 있습니다.

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

(귀하의 프로그램은 이것을 지원할 필요가 없습니다)

피스, 13 12 11

{msrVQd^U2l

Leaky Nun 덕분에 1 바이트!

Jakube 덕분에 또 다른 바이트!

여기에서 시도 하거나 테스트 스위트를 실행 하십시오.

[0, 1]입력 문자열의 길이와 같은 횟수만큼 목록의 직교 곱을 가져 와서 목록 True / False 값 목록을 만듭니다 . 따라서 각 서브리스트의 길이는 입력 문자열과 동일합니다. 그런 다음 r함수를 입력과 목록에 대한 벡터 연산으로 적용하여 r letter value각 하위 요소에 대해 얻 습니다. r두 번째 인수로 0은 소문자이고 하나는 대문자입니다. 이렇게하면 비 레터에서 중복이 생성되므로 결과에서 중복을 제거해야합니다.

젤리 , 6 바이트

żŒsŒpQ

이것은 문자열을 왼쪽 인수로 예상하고 문자열 목록을 반환하는 모나드 링크 (함수)입니다.

비 ASCII 문자를 처리합니다. 온라인으로 사용해보십시오!

작동 원리

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

파이썬, 74 71 바이트

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

비 ASCII 문자를 처리합니다. Ideone에서 테스트하십시오 .

Oracle SQL 11.2, 276 바이트

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

언 골프

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

못생긴 것처럼, 골프를 더 잘해야합니다.

05AB1E, 17 바이트

암호:

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

설명 :

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

온라인으로 사용해보십시오

Brachylog , 25 22 바이트

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

이것은 Prolog의 소문자 / 대문자 술어뿐만 아니라 작동하므로 ASCII가 아닌 문자에서도 작동합니다.

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

설명

내가 게시 한 현재의 다른 모든 답변과 달리 이것은 직교 곱 접근법을 전혀 사용하지 않습니다.

• 주요 술어

  :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

이것은 입력의 각 문자에 대문자 또는 소문자를 적용하여 하나의 가능한 순열을 계산하는 데 사용됩니다. 기본 술어에서이 술어에 대해 findall을 사용하면 가능한 모든 순열 (일부 중복)을 계산할 수 있습니다.

    :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

• 술어 2

문자열의 문자를 대문자 또는 소문자 버전으로 변환하는 데 사용됩니다.

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

하스켈, 69 58 바이트

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

온라인으로 사용해보십시오!

편집 : @ Angs는 11 바이트를 저장했습니다. 감사!

MATL , 13 바이트

tYov!Z}N$Z*Xu

온라인으로 사용해보십시오!

설명

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

자바 스크립트 (Firefox 30-57), 92 90 바이트

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

편집 : new Set문자열에서 고유 문자를 행복하게 추출 하기 때문에 2 바이트를 절약했습니다 .

펄 6 , 37 바이트

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

시도 해봐

설명:

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

테스트:

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

줄리아, 66 60 바이트

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

온라인으로 사용해보십시오!

파이썬, 69 바이트

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

실제로 28 바이트

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

온라인으로 사용해보십시오!

이 프로그램은 Python 3의 마술 덕분에 비 ASCII 문자를 처리 할 수 ​​있습니다.

설명:

;╗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 229252 바이트

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

언 골프 버전 :

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

   } 
}

설명:

• 문자열을 승인하고 문자열을 소문자로 변환하십시오.
• 문자열의 길이와 동일한 길이의 정수 배열을 선언하십시오. 0으로 채우십시오.
• 배열 2^strlen(s)에 0부터 이진 형식으로 숫자를 저장하십시오 int. (3 바이트 문자열의 경우 : 000,001,010 ... 111)
• 위치의 비트가 설정되어 있는지에 따라 또는 케이스를 토글하십시오.
• 가능한 모든 조합에 대해 문자열을 출력하십시오.

온라인으로 사용해보십시오!

Hoon , 242 바이트

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

언 골프 드 :

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

불행히도 이것이 얼마나 작은 지 잘 모르겠습니다.

먼저 l2 ^ (length t) 반복이있는 목록과 동일하게 설정했습니다 t. Hoon에는 facstdlib에 함수가 없지만 2 ^ n은 항상 n보다 큽니다! 따라서 더 큰 목록을 매핑하고 set(해시 맵)을 사용하여 항목을 중복 제거합니다.

그런 다음 목록 [0 .. (길이 l)]을 접어 a로 누적합니다 (set tape). l반복 횟수 ( a) 를 알아야하기 때문에 직접 매핑하는 대신이 작업을 수행 해야 하지만 Hoon이 순수한 언어이기 때문에 누적기를 증분시킬 수는 없습니다.

[0 .. (길이 t)] (다시 현재 색인이 있음)에 매핑 t하고 문자열에서 n 번째 문자로 설정 하고, n 번째 a바이어가 바뀌 었는지 확인하고 케이스의 변경 여부에 따라 (사례 나 상자) 또는 아닙니다). 이지도의 반환 유형은 tape입니다.

그런 다음 문자열을 해시 맵에 넣고 모든 문자열의 해시 맵을 반환합니다.

C, 216 바이트

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

이는 다른 접근 방식 의 같은 다른 C의 답변으로 접근.

이것을 삭제하고 주석으로 다른 답변 아래에 넣어야합니까?

Ungolfed 버전으로 설명하겠습니다

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 바이트

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

파티에 늦었지만 여전히 갔다. 내가 놓친 것들을 상기시켜주고 골프 팁을주고 많은 바이트를 절약 해 준 DLosc에게 감사합니다. :)

Wolfram Language (Mathematica) , 55 바이트

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

온라인으로 사용해보십시오!

전치 연산자입니다 ( Mathematica에서 위첨자 T 로 표시됨).

펄 5 , 52 + 1 ( -n) = 53 바이트

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

온라인으로 사용해보십시오!

Tcl, 165181 바이트

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 덕분에 개선 되었습니다 . 이전 답변 :

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}

출력 텍스트를 작성할 때 2 진 숫자를 사용하여 대소 문자를 선택하십시오.

펄 5 , 30 바이트

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

온라인으로 사용해보십시오!

출력 끝에 추가 공간을 출력합니다.

수행원 , 39 바이트

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

온라인으로 사용해보십시오!

펄 답변과 비슷합니다. (나는 더 흥미로운 대안을 잃어 버렸습니다. 앞으로 몇 시간 안에 게시해야합니다.)

자바 스크립트 (ES6), 103

비 ASCII 문자 처리

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

테스트

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>