जब आप अपरकेस और लोअरकेस के प्रत्येक क्रमांकन को उत्पन्न करने में सक्षम होते हैं, तो असंवेदनशील चीजों की तुलना करने की आवश्यकता किसे है? कोई नहीं! _{यही जवाब है। कोई नहीं करता।}आपका कार्य इस उपलब्धि को प्राप्त करना है; किसी दिए गए इनपुट के लिए अपरकेस / लोअरकेस के सभी संभावित क्रमांक उत्पन्न करें।

इनपुट

मुद्रण योग्य मानक एससीआई वर्णों की एक स्ट्रिंग। इनपुट को सभी लोअरकेस नहीं माना जाना चाहिए। इनपुट हमेशा कम से कम एक वर्ण का होगा।

उत्पादन

इनपुट स्ट्रिंग (कोई डुप्लिकेट नहीं) के लिए अपरकेस और लोअरकेस का प्रत्येक क्रमांकन। इसे केवल छोटे और बड़े संस्करण के साथ वर्ण बदलना चाहिए (संख्या समान रहेगी)। प्रत्येक क्रमपरिवर्तन एक स्ट्रिंग या वर्णों की सूची के रूप में आउटपुट होना चाहिए; एकल तार की सूचियों की अनुमति नहीं है।

उदाहरण

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

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

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

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

एक अतिरिक्त मज़े के रूप में देखें कि विस्तारित अस्की पात्रों को संभालने के लिए कितना अतिरिक्त प्रयास करना होगा, यहाँ एक अतिरिक्त परीक्षण मामला है:

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

(आपके कार्यक्रम को इसका समर्थन करने की आवश्यकता नहीं है)

code-golf string combinatorics

— प्रहार
स्रोत

10

दिलचस्प यूनिकोड परीक्षण मामला: Σ→['Σ', 'σ', 'ς']

— n̴̖̋h̷̭̿a̸̡̅ẗ̵̨́h̷̰̀ĥ̷̳d

क्या हम एक स्ट्रिंग के बजाय वर्णों की सूची का उपयोग कर सकते हैं? उदाहरण के लिए, यदि Hi!दिया गया तो {('H', 'i', '!'), ('h', 'I', '!'), ('h', 'i', '!'), ('H', 'I', '!')}क्या वह स्वीकार्य होगा?

— DJMcMayhem

@DrGreenEggsandHamDJ की सूची पात्रों अनुमति दी जाती है डिफ़ॉल्ट रूप से । पाइथन में, हालांकि वे सिंगलटन स्ट्रिंग्स हैं, जो अलग है।

— डेनिस

1

@ n @h interestinga̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ और भी दिलचस्प यह है कि Σकिसी शब्द की शुरुआत में अपरकेस संस्करण है, σशुरुआत में या बीच में लोअरकेस संस्करण है, लेकिन एक शब्द के अंत में नहीं है, और ςकेवल एक शब्द के अंत में सबसे छोटा संस्करण है।

— FantaC

1

@DomHastings जैसा कि आपके पास एक सूची है और आप उत्पादन को केवल अंतरिक्ष-परिसीमन कर रहे हैं? जो मुझे उचित लगता है।

— प्रहार

11

Pyth, 13 12 1 1

{msrVQd^U2l

1 बाइट लेके नन को धन्यवाद!

Jakube के लिए एक और बाइट धन्यवाद!

इसे यहां आज़माएं या टेस्ट सूट चलाएं

हम सूची के कार्टेशियन उत्पाद [0, 1]को इनपुट स्ट्रिंग की लंबाई के बराबर कई बार लेकर सही / गलत मूल्यों की सूची बनाते हैं । इसलिए प्रत्येक सब्लिस्ट की लंबाई इनपुट स्ट्रिंग के समान होती है। फिर हम rफ़ंक्शन को इनपुट और सूची पर वेक्टर ऑपरेशन के रूप में लागू करते हैं , इसलिए हम r letter valueप्रत्येक उप तत्व के लिए प्राप्त करते हैं। rदूसरे तर्क के साथ शून्य को कम करना है और एक को ऊपरी मामले में रखना है। यह गैर-अक्षरों पर डुप्लिकेट बनाता है, जिसका अर्थ है कि हमें परिणाम से डुप्लिकेट को निकालने की आवश्यकता है।

— FryAmTheEggman
स्रोत

pyth.herokuapp.com/…

— लीक नन

@LeakyNun आह, मैंने कोशिश की थी लेकिन किसी कारण से मैंने सोचा कि Mदोनों का उपयोग कर रहा हूं sऔर .nसमान लंबाई थी। मुझे गिनती अच्छी लगती है। वैसे भी, अब संपादन, धन्यवाद!

— फ्राईअमईएगमैन

हां वे एक ही लंबाई के हैं, मैंने बस आखिरी भाग को बदल दिया है

— लीक नून

{msrVQd^U2lथोड़ा छोटा है।

— जकूबे

@Jakube धन्यवाद! का उपयोग करना Vबहुत डरपोक है, मुझे नहीं लगता कि मैंने कभी यहां सोचा होगा।

— FryAmTheEggman 13

8

जेली , 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.

— डेनिस
स्रोत

3

अन्य भाषाओं को पुनः प्राप्त करें: p

— अदनान

2

यहां तक कि कोड-पेज को देखने के बाद भी, मैं लगातार जेली को कोड-गोल्फ चुनौतियों पर सबसे कम बाइट की गिनती के साथ देखता हूं।

— प्रहार

5

पायथन, 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 पर इसका परीक्षण करें ।

— डेनिस
स्रोत

5

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

संयुक्त राष्ट्र के 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

नरक के रूप में बदसूरत, अधिक गोल्फ होना चाहिए।

— Jeto
स्रोत

4

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

इसे ऑनलाइन आज़माएं

— Emigna
स्रोत

4

ब्रेकीलॉग , 25 22 बाइट्स

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

यह प्रोलॉग के निचलेकेस / अपरकेस के रूप में अच्छी तरह से काम करता है, इसलिए यह गैर- ASCII अक्षरों पर भी काम करता है:

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

व्याख्या

जिस समय मैं यह पोस्ट कर रहा हूं, सभी अन्य उत्तरों के विपरीत, यह कार्टेशियन उत्पाद दृष्टिकोण का उपयोग नहीं करता है।

मुख्य Predicate

: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

समर्पित करना १

इसका उपयोग इनपुट के प्रत्येक चार्ट पर अपरकेसिंग या लोअरस्किंग लागू करने के लिए किया जाता है, इस प्रकार एक संभावित क्रमांकन की गणना की जाती है। मुख्य विधेय में इस विधेय पर खोज का उपयोग करना सभी संभावित क्रमपरिवर्तन (कुछ डुप्लिकेट के साथ) की गणना करने की अनुमति देता है।

    :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

२ समर्पित करें

इसका उपयोग स्ट्रिंग के एक चरित्र को उसके अपरकेस या उसके निचले संस्करण में बदलने के लिए किया जाता है।

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

— Fatalize
स्रोत

4

हास्केल, 69 58 बाइट्स

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

इसे ऑनलाइन आज़माएं!

संपादित करें: @Angs ने 11 बाइट्स बचाए। धन्यवाद!

— nimi
स्रोत

mapM(\x->toLower x:[toUpper x|isAlpha x])अन्य आयात से छुटकारा चाहिए?

— आंग

3

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

— लुइस मेंडो
स्रोत

3

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 92 90 बाइट्स

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

संपादित करें: सहेजे गए 2 बाइट्स क्योंकि new Setख़ुशी से एक स्ट्रिंग से अनूठे वर्णों को निकाला जाएगा।

— नील
स्रोत

जब !c sभी []ऐसा हो तो आप [s]इसके बजाय लौट सकते हैं

— l4m2

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

— l4m2

3

पर्ल 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)

— ब्रैड गिल्बर्ट b2gills
स्रोत

आप एक बाइट बचा सकते हैं जो मुझे लगता है: {[X~] '',|.comb.map:{unique .lc,.uc}}(अंतरिक्ष को बाद में हटाएं map:)

— कॉनर ओ'ब्रायन

2

जूलिया, 66 60 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

2

पायथन, 69 बाइट्स

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

— RootTwo
स्रोत

यह तार के बजाय सिंगलटन स्ट्रिंग्स के टुपल्स लौटाता है। मुझे यकीन नहीं है कि अगर इसकी अनुमति है।

— डेनिस

1 बाइट का उपयोग करके बचाएं from itertools import*;और छोड़ देंi.

— बाइट कमांडर

ओपी ने कहा है कि सिंगलटन स्ट्रिंग्स की अनुमति नहीं है। आपको इस उत्तर को अपडेट करना चाहिए।

— DJMcMayhem

आउटपुट आवश्यकता अस्पष्ट (अभी भी है)। मैंने इसे पोस्ट करने के बाद, ओपी ने टिप्पणियों में स्पष्ट किया। क्या मुझे यह उत्तर हटा देना चाहिए? उचित प्रोटोकॉल क्या है?

— रूटट्वो

2

दरअसल, 28 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह कार्यक्रम गैर-एएससीआईआई पात्रों को संभाल सकता है, पायथन 3 के जादू के लिए धन्यवाद।

स्पष्टीकरण:

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

— मै जाऊं
स्रोत

2

सी 229 252 बाइट्स

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 संस्करण:

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

   } 
}

स्पष्टीकरण:

चरित्र स्ट्रिंग को स्वीकार करें, स्ट्रिंग को लोअरकेस में बदलें।
स्ट्रिंग के बराबर लंबाई का पूर्णांक सरणी घोषित करें। इसे जीरो से भरें।
2^strlen(s)किसी intसरणी में 0 से बाइनरी फॉर्म में संख्याओं को संग्रहीत करें। (एक 3 बाइट स्ट्रिंग के लिए: 000,001,010 ... 111)
इस स्थिति पर निर्भर करता है कि स्थिति में थोड़ा सेट है या मामले को टॉगल करें।
स्ट्रिंग को हर संभव संयोजन के लिए आउटपुट करें।

इसे ऑनलाइन आज़माएं!

— हाबिल टॉम
स्रोत

जब मैंने मूल रूप से vb6 में 10 साल पहले ऐसा किया था तो मेरा मानना है कि मेरा समाधान भी इसी के समान था। आप कुछ यादों को वापस लाए;)

— प्रहार

@ मुझे खुशी है कि मैं कर सकता था! :)

— एबेल टॉम

गोल्फ के लिए कुछ चीजें: i++फॉर-लूप्स ++को हटा दें और सीधे उपयोग करें, साथ ही जहां-जहां संभव हो वहां कोष्ठक और अर्ध-स्तंभों को हटाने के लिए फॉर-लूप के अंदर कुछ हिस्सों को रखें। इसके अलावा, आप पैरामीटर में स्थान को हटा सकते हैं और अंत में एक टर्नरी-अगर असाइनमेंट का उपयोग कर सकते हैं। कुल में:

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

( -20 बाइट्स / 232 बाइट्स )

— केविन क्रूज़सेन

1

हून , 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) -)

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

मुझे यकीन नहीं है कि यह कितना छोटा हो सकता है, दुर्भाग्य से।

सबसे पहले, हम l2 ^ (लंबाई टी) दोहराव के साथ एक सूची के बराबर सेट करते हैं t। facहड का स्टडलिब में कोई फंक्शन नहीं है , लेकिन 2 ^ n हमेशा n से बड़ा होता है!, इसलिए हम केवल बड़ी सूची पर मैप करते हैं और setडी-डुप्लिकेट प्रविष्टियों के लिए (हैशमैप) का उपयोग करते हैं।

हम फिर सूची में गुना [0 .. (लंबाई एल)], एक में जमा (set tape)। हमें lसीधे तौर पर मैप करने के बजाय ऐसा करने की आवश्यकता है क्योंकि हमें यह भी जानना होगा कि यह किस संख्या में पुनरावृत्ति है ( a), लेकिन हून के शुद्ध भाषा होने के कारण केवल एक संचायक को नहीं बढ़ाया जा सकता है।

हम [0 .. (लंबाई टी)] पर मानचित्र tबनाते हैं (फिर से हमारे पास वर्तमान सूचकांक है), स्ट्रिंग में एनटी चरित्र के लिए सेटिंग , यह जांचना कि क्या एनएच बाय aऔर मामले को उलट रहा है (cuss या cass, अगर यह बदलता है तो निर्भर करता है) या नहीं)। इस मानचित्र का रिटर्न प्रकार एक है tape।

फिर हम स्ट्रिंग को अपने हैशमैप में डालते हैं, और सभी स्ट्रिंग्स के हैशमैप को वापस करते हैं।

— RenderSettings
स्रोत

"2 ^ n हमेशा n से बड़ा होता है!"। वास्तव में n! > 2^n, बशर्ते कि nकम से कम हो 4। (आधार मामले के साथ प्रेरण द्वारा साबित करें n=4।) en.wikipedia.org/wiki/…

— मैथमेटंदन

1

सी, 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);}}

यह ~~एक अलग दृष्टिकोण है~~ , अन्य सी उत्तर के समान दृष्टिकोण है।

क्या मुझे इसे हटा देना चाहिए, और टिप्पणी के रूप में अन्य उत्तर के तहत डाल देना चाहिए?

मुझे 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
    }
}

— MrPaulch
स्रोत

1

पायथन 3, 96 बाइट्स

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

पार्टी में देर से ही सही लेकिन फिर भी जाना पड़ा। मेरे द्वारा याद किए गए सामान की याद दिलाने के लिए, मुझे गोल्फिंग टिप्स देने और मुझे बाइट्स का एक गुच्छा बचाने के लिए DLosc का धन्यवाद। :)

— ब्लाकों
स्रोत

@DLosc सुझावों के लिए धन्यवाद! मैं उन सुविधाओं को जोड़ दूंगा। :)

— ब्लॉक करें

सुझावों के लिए धन्यवाद। यह वास्तव में मदद की। यद्यपि यदि मैं सेट के बजाय {} का उपयोग करता हूं, तो लूप उत्पादों के बजाय सेट से गुजरता है (मुझे आशा है कि समझ में आता है)। कम से कम मेरे कार्यान्वयन पर (मैं एंड्रॉइड पर QPython का उपयोग कर रहा हूं), {} बस सूची को सेट में बदलने के बजाय सूची के अंदर सेट करता है।

— ब्लॉक

मैंने दोनों तरह से कोशिश की है और {* expr} करने से मुझे सिंटेक्स ईयर्रर मिलता है।

— ब्लॉक

Ahhhh। इसीलिए। QPython का नवीनतम संस्करण 3.3 या कुछ और है।

— ब्लॉक

यहाँ तुम जाओ: यह ऑनलाइन कोशिश करो! (एक बग भी तय किया है और एक स्थान को गढ़ा है।)

— डीएलोस्क

1

वोल्फ्राम भाषा (गणितज्ञ) , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्थानान्तरण संचालक है (और गणितज्ञ टी में सुपरस्क्रिप्ट के रूप में प्रदर्शित होता है )।

— मार्टिन एंडर
स्रोत

1

पर्ल 5 , 52 + 1 ( `-n`) = 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

1

टीईसीएल, 165 181 बाइट्स

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

सुधार सेरगिओल के लिए धन्यवाद । पिछला उत्तर:

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}

आउटपुट टेक्स्ट बनाते समय ऊपरी / निचले मामले के बीच चयन करने के लिए एक बाइनरी नंबर का उपयोग करता है।

— Dúthomhas
स्रोत

165

— सर्गियोल

@sergiol यह खदान से काफी अलग है कि आपको इसे अपने उत्तर के रूप में पोस्ट करना चाहिए और भयानक होने के लिए अच्छा श्रेय प्राप्त करना चाहिए।

— दुथोमास

नहीं, मैंने केवल आपके उत्तर के मामूली हिस्सों को बदल दिया है, मैंने दृष्टिकोण को नहीं बदला है और न ही आवश्यक एल्गोरिदम को, इसलिए, मेरे दृष्टिकोण में मुझे लगा कि मैं एक नया उत्तर बनाने के लायक नहीं था! और मुझे शक है कि मैं एक ही उद्देश्य के लिए अपने मूल के रूप में एक एल्गोरिथ्म कम प्राप्त कर सकता हूं!

— सर्गियोल

1

पर्ल 5 , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आउटपुट के अंत में एक अतिरिक्त स्थान आउटपुट करता है।

— डोम हेस्टिंग्स
स्रोत

1

अटैची , 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पर्ल उत्तर के समान। (मैंने अपना अधिक दिलचस्प विकल्प खो दिया है, मुझे अगले कुछ घंटों में पोस्ट करना चाहिए।)

— कोनोर ओ ब्रायन
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 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>

स्निपेट का विस्तार करें

— edc65
स्रोत

केस का परमीशन

इनपुट

उत्पादन

उदाहरण

स्कोरिंग

Pyth, 13 12 1 1

जेली , 6 बाइट्स

यह काम किस प्रकार करता है

पायथन, 74 71 बाइट्स

Oracle SQL 11.2, 276 बाइट्स

05AB1E, 17 बाइट्स

ब्रेकीलॉग , 25 22 बाइट्स

व्याख्या

हास्केल, 69 58 बाइट्स

MATL , 13 बाइट्स

व्याख्या

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 92 90 बाइट्स

पर्ल 6 , 37 बाइट्स

स्पष्टीकरण:

परीक्षा:

जूलिया, 66 60 बाइट्स

पायथन, 69 बाइट्स

दरअसल, 28 बाइट्स

सी 229 252 बाइट्स

हून , 242 बाइट्स

सी, 216 बाइट्स

पायथन 3, 96 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 55 बाइट्स

पर्ल 5 , 52 + 1 ( -n) = 53 बाइट्स

टीईसीएल, 165 181 बाइट्स

पर्ल 5 , 30 बाइट्स

अटैची , 39 बाइट्स

जावास्क्रिप्ट (ईएस 6), 103

पर्ल 5 , 52 + 1 ( `-n`) = 53 बाइट्स