एक शब्द में पत्र के सभी संभावित अद्वितीय संयोजन की गणना करें

12

आपको एक स्ट्रिंग दी जाती है, जिसमें साधारण az अक्षर होंगे। (आप मान सकते हैं कि यह हमेशा किसी भी परीक्षण में मामला होगा, और यह मान लें कि सभी पत्र नीचे भी होंगे)। आपको यह निर्धारित करना होगा कि स्ट्रिंग में अलग-अलग पात्रों के कितने अद्वितीय संयोजन हो सकते हैं, और उस नंबर को प्रिंट करें।

हालांकि, संभावित संयोजनों की गिनती में डुप्लिकेट पत्रों को अनदेखा किया जा सकता है। दूसरे शब्दों में, यदि दिया गया स्ट्रिंग "हैलो" है, तो बस दो lएस के पदों को बदलना एक अद्वितीय वाक्यांश के रूप में नहीं गिना जाता है, और इसलिए इसे कुल की ओर गिना नहीं जा सकता है।

सबसे छोटी बाइट गिनती जीत, गैर-गोल्फिंग भाषाओं में कुछ रचनात्मक समाधान देखने के लिए उत्सुक!

उदाहरण:

hello -> 60
aaaaa -> 1
abcde -> 120
code-golf  string 
— SimpleGeek
स्रोत
4
— Giuseppe
4
@Giuseppe मुझे नहीं लगता कि यह उस की नकल है; इस सवाल की बारीकियों को बहुत कम कार्यान्वयन के लिए अनुमति देते हैं
— ArBo
4
कुछ टेस्टेसिस जोड़ने से मदद मिल सकती है।
— tsh
1
@JonathanAllan अच्छा सुझाव! उसके अनुसार शीर्षक बदल गया।
— सिंपल गीक

जवाबों:

29

पायथन 2 , 50 48 बाइट्स

f=lambda s:s==''or len(s)*f(s[1:])/s.count(s[0])

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

कोई बोरिंग बिल्ट-इन नहीं! मेरे आश्चर्य के लिए, यह जानवर बल दृष्टिकोण से भी छोटा है, सभी क्रमपरिवर्तन की गणना करता हैitertools लंबाई के ।

यह फ़ंक्शन सूत्र का उपयोग करता है

# अनूठे क्रमपरिवर्तन का=(# तत्वों का)!Πअद्वितीय तत्व(# उस तत्व के होने का)!

और यह मक्खी पर गणना करता है। अंश में भाज्य की गणना len(s)प्रत्येक फ़ंक्शन कॉल में गुणा करके की जाती है। भाजक थोड़ा अधिक सूक्ष्म है; प्रत्येक कॉल में, हम उस तत्व के आवृत्तियों की संख्या से विभाजित करते हैं जो स्ट्रिंग में बचे हैं, यह सुनिश्चित करते हैं कि प्रत्येक वर्ण के लिए c, 1 के बीच की सभी संख्याएं और c(समावेशी) होने वाली राशि को एक बार में विभाजित किया जाएगा। चूंकि हम केवल बहुत ही अंत में विभाजित होते हैं, इसलिए हमें पायथन 2 के डिफ़ॉल्ट फ्लोर डिवीजन के साथ कोई समस्या नहीं होने की गारंटी है।

— अरबो
स्रोत
itertools अपने क्रिया नामों में बहुत क्रिया है
— qwr
7

CJam , 4 बाइट्स

le!,

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

व्याख्या

एक स्ट्रिंग के रूप में लाइन पढ़ें ( l), स्ट्रिंग्स की एक सरणी के रूप में अद्वितीय क्रमपरिवर्तन ( e!), लंबाई ( ,), अंतर्निहित प्रदर्शन।

— लुइस मेंडो
स्रोत
4
"लील" जैसा दिखता है, +1! : डी
— कीवियूएसआर
5

आर , 69 65 बाइट्स

function(s,`!`=factorial)(!nchar(s))/prod(!table(strsplit(s,"")))

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

4 बाइट्स ने दोनों जवाबों में ज़ाहिरो मोर को धन्यवाद दिया ।

सीधे बहुराष्ट्रीय गुणांक की गणना करता है।

आर , 72 68 बाइट्स

function(s,x=table(strsplit(s,"")))dmultinom(x,,!!x)*sum(1|x)^sum(x)

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

dmultinomबहुराष्ट्रीय गुणांक निकालने के लिए प्रदान किए गए बहुराष्ट्रीय वितरण समारोह का उपयोग करता है ।

ध्यान दें कि सामान्य (गोल्फ खिलाड़ी) किसी अज्ञात कारण x<-table(strsplit(s,""))से dmultinomकॉल के अंदर काम नहीं करता है ।

— ग्यूसेप
स्रोत
2
function(s,! =factorial)(!nchar(s))/prod(!table(strsplit(s,""))) काम करेगा। एल () निरर्थक है - तालिका तत्वों की तलाश करना जानती है ....
— ज़ाहिरो मोर
1
@ZahiroMor आह, बिल्कुल। मैंने इसका परीक्षण करने का इरादा किया था, लेकिन इसके आसपास कभी नहीं पहुंचा।
— ग्यूसेप
5

जावास्क्रिप्ट (Node.js) , 49 बाइट्स

t=t*t*=राउंडिंग एरर ( |tसंख्या के राउंड डाउन) से बचने के बजाय इसका उपयोग किया जाता है , यह t=t*गारंटी देता है कि सभी इंटरमीडिएट (ऑपरेटर-वार) परिणाम पूरे नंबर हैं।

a=>[...a].map(g=x=>t=t*y++/(g[x]=-~g[x]),t=y=1)|t

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

a=>
 [...a].map(        // Loop over the characters
  g=x=>
   t=t*             // using t*= instead may result in rounding error 
    y++             // (Length of string)!
    /(g[x]=-~g[x])  // divided by product of (Count of character)!
  ,t=y=1            // Initialization
 )
 |t
— शायरु असकोतो
स्रोत
2
(संभावित फ़्लोटिंग-पॉइंट राउंडिंग त्रुटि; t=t*यदि आप
— नील
@Neil हाँ यह तब विफल हुआ जब aaadegfbbbcccफ्लोटिंग-पॉइंट राउंडिंग त्रुटि के कारण इनपुट ठीक है
— शियरु असकोतो
हुह, आपको वह टेस्ट केस कैसा लगा?
— नील
@ नील तार को तब तक जोड़ते रहें जब तक कि ऐसी
— गोलमटोल
@ शायरुअसाकोतो शीर्षक बदल दिया गया है; गिनती ज्यादा बेहतर है। धन्यवाद, और अच्छा जवाब!
— सिंपलगीक
4

जाप , 5 3 बाइट्स

-2 बाइट्स @ शुग्गी को धन्यवाद

á l

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत
TIO, Japt का एक पुराना संस्करण चला रहा है, जिससे आप खाई खोद सकते हैं â।
— झबरा
@ शैगी लोल, मैंने उस पर गौर नहीं किया। धन्यवाद!
— लुइस फेलिप डी जीसस मुनोज
2

पायथन 2 , 57 बाइट्स

lambda s:len(set(permutations(s)))
from itertools import*

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

स्व-दस्तावेजीकरण: इनपुट स्ट्रिंग के अनूठे क्रमपरिवर्तन के सेट की लंबाई लौटाएं।

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

इस पर क्रेडिट ArBo को जाता है :

lambda s:len({*permutations(s)})
from itertools import*

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

— स्क्वीड
स्रोत
2

एपीएल (डायलॉग यूनिकोड) , 24 बाइट्स

⎕CY'dfns'
{≢∪↓⍵[pmat≢⍵]}

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

सरल डीएफएन, तर्क के रूप में एक स्ट्रिंग लेता है।

किस तरह:

⎕CY'dfns'      ⍝ Copies the 'dfns' namespace.
{≢∪↓⍵[pmat≢⍵]} ⍝ Main function
          ≢⍵   ⍝ Number of elements in the argument (⍵)
      pmat     ⍝ Permutation Matrix of the range [1..≢⍵]
    ⍵[      ]  ⍝ Index the argument with that matrix, which generates all permutations of ⍵
   ↓           ⍝ Convert the matrix into a vector of strings
  ∪            ⍝ Keep only the unique elements
 ≢             ⍝ Tally the number of elements
— जे। सल्ल
स्रोत
2

रूबी , 41 बाइट्स

f=->s{s.chars.permutation.to_a.uniq.size}

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

— thowawayacc89023489
स्रोत
1
मुझे नहीं लगता कि आपको जरूरत हैto_a
— ArBo
1
और अनाम फ़ंक्शंस / लैम्ब्डा स्वीकार्य हैं, ताकि आप f=भाग को हटा सकें । (TIO में इसे हैडर के पास ले जाने के लिए नहीं।)
— मैनटवर्क
2

पर्ल 6 , 33 30 चार्ट ( 34 31 बाइट्स)

एकदम सीधे आगे का Whateverब्लॉक। combस्ट्रिंग को अक्षरों में विभाजित करता है, permutationsसभी संभव संयोजनों को प्राप्त करता है। जिस तरह से पहले एड करने की Setआवश्यकता के लिए जबरदस्ती join( सूची में प्रत्येक तत्व »पर लागू होती joinहै)।

+*.comb.permutations».join.Set

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

(पिछले उत्तर का इस्तेमाल किया गया था, .uniqueलेकिन Setविशिष्टता की गारंटी है, और उसी को सुन्न करता है, इसलिए यह 3 बचाता है)।

— user0721090601
स्रोत
2

के (ओके) , 12 बाइट्स

समाधान:

#?x@prm@!#x:

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

स्पष्टीकरण:

OK में निर्मित का उपयोग करता है prm:

{[x]{[x]$[x;,/x ,''o'x ^/:x;,x]}@$[-8>@x;!x;x]}

... जो, x^/:xमूल रूप से "helo"नहीं की क्रमपरिवर्तन उत्पन्न करता है "hello", इसलिए हमें के क्रमपरिवर्तन उत्पन्न करने की आवश्यकता है 0 1 2 3 4, उन्हें अनुक्रमित करने के लिए उपयोग करें "hello"और फिर अद्वितीय की गिनती करें।

#?x@prm@!#x: / the solution
          x: / store input as x
         #   / count (#) length
        !    / range (!) 0..n
    prm@     / apply (@) to function prm
  x@         / apply permutations to input x
 ?           / take the distinct (?)
#            / count (#)
— streetster
स्रोत
Prm एक ठीक विशिष्ट ऑपरेटर है? मुझे नहीं लगता कि वेनिला के पास है?
— हेनरी हेनरिंस
Yup - केवल मैनुअल
— oK
@HenryHenrinson afaik यह k4 में नहीं है। जल्दी k5 में यह था !-n। देर से k5 और k6 में यह बन गयाprm । k7 (shakti) में prmभी है।
— नवंबर
2

जावा 8, 103 102 बाइट्स

s->{int r=1,i=s.length();for(;i>0;)r=r*i/~-s.substring(--i).split(s.charAt(i)+"",-1).length;return r;}

पोर्ट ऑफ @ अर्बो पायथन 2 उत्तर ।
-1 बाइट की बदौलत @ OlivierGrégoire को पुनरावर्ती के बजाय इसे पुनरावृत्त बनाकर।

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

वास्तव में एक सेट में सभी अद्वितीय क्रमपरिवर्तन उत्पन्न करना और उसका आकार प्राप्त करना 221 बाइट्स होगा :

import java.util.*;s->{Set S=new HashSet();p(s,S,0,s.length()-1);return S.size();}void p(String s,Set S,int l,int r){for(int i=l;i<=r;p(s.replaceAll("(.{"+l+"})(.)(.{"+(i++-l)+"})(.)(.*)","$1$4$3$2$5"),S,l+1,r))S.add(s);}

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

— केविन क्रूज़सेन
स्रोत
ठीक है, मैं पुनरावृत्ति के बजाय इसे पुनरावृत्त बनाकर एक बाइट को गोल्फ कर सकता हूं s->{int r=1,i=s.length();for(;i>0;)r=r*i/~-s.substring(--i).split(s.charAt(i)+"",-1).length;return r;}:।
— ओलिवियर ग्रेजायर
@ OlivierGrégoire धन्यवाद! Btw, क्या आप दूसरे दृष्टिकोण को बनाने के लिए कुछ देखते हैं (एक सेट में सभी अद्वितीय क्रमपरिवर्तन उत्पन्न करते हुए) छोटा? मुझे लगता है कि कुछ बाइट्स को बचाया जा सकता है, लेकिन कुछ चीजों की कोशिश की गई और अधिकांश को छोटे की बजाय थोड़ा लंबा कर दिया गया। लेकिन यह अभी भी बहुत लंबा tbh दिखता है।
— केविन क्रूज़सेन
मैं इस पर काम कर रहा हूं, इस तरह से धाराओं और गिनती का उपयोग करने की कोशिश कर रहा हूं: s->{long r=1,i=s.length();for(;i>0;)r=r*i/(s.chars().skip(--i).filter(c -> c==s.charAt(i)).count()+1);return r;}लेकिन सफलता के बिना अब तक ...
— ओलिवियर ग्रेजायर
1

MATL , 9 बाइट्स

jY@XuZy1)

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

स्पष्टीकरण:

j input as string
Y@ get permutations
Xu unique members
Zy size matrix
1) first member of size matrix
— OrangeCherries
स्रोत
2
आप उद्धरणों के साथ इनपुट ले सकते हैं, इसलिए jबन जाता है i, जिसे निहित किया जा सकता है। इसके अलावा, tio.run/##y00syfn/P9IholQtr@L/f/WM1JycfHUA&nx पर एक बाइट बचाता हैZy1)
— लुइस
1

ऑक्टेव / MATLAB, 35 बाइट्स

@(s)size(unique(perms(s),'rows'),1)

अनाम फ़ंक्शन जो एक वर्ण वेक्टर लेता है और एक संख्या पैदा करता है।

MATLAB में इसे size(unique(perms(s),'ro'),1)(33 बाइट्स) छोटा किया जा सकता है ।

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

व्याख्या

@(s)                                  % Anonymous function with input s
                perms(s)              % Permutations. Gives a char matrix
         unique(        ,'rows')      % Deduplicate rows
    size(                       ,1)   % Number of rows
— लुइस मेंडो
स्रोत
1
मैंने सोचा था कि uniqueअद्वितीय पंक्तियाँ पहले ही लौट चुकी हैं? या कि केवल tableएस के लिए है?
— ग्यूसेप
@Giuseppe संख्यात्मक / char 2D सरणियों के uniqueलिए पहले रैखिक होगा। तालिकाओं के लिए मुझे लगता है कि आप सही हैं; मुझे नहीं पता था कि!
— लुइस मेंडो
1
आह, मुझे पता है कि मुझे यह विचार कहां से मिला - uniqueMATLAB के लिए पंक्तियों को लेना चाहिए tables; R unique, मैट्रिसेस या डेटा फ़्रेम की अद्वितीय पंक्तियाँ लेता है। समान कमांड वाली बहुत सारी सरणी वाली भाषाएं जो थोड़ा अलग काम करती हैं ...
— Giuseppe
1

रेटिना 0.8.2 , 73 बाइट्स

(.)(?=(.*?\1)*)
/1$#2$*1x1$.'$*
^
1
+`1(?=1*/(1+)x(\1)+$)|/1+x1+$
$#2$*
1

इसे ऑनलाइन आज़माएं! @ ArBo के सूत्र का उपयोग करता है, लेकिन दाएं-से-बाएं से मूल्यांकन करता है क्योंकि यह पूर्णांक अंकगणित में किया जा सकता है, जबकि अभी भी शामिल किए गए मानों के आकार को कम करता है। स्पष्टीकरण:

(.)(?=(.*?\1)*)
/1$#2$*1x1$.'$*

प्रत्येक वर्ण के लिए, गिनती करें कि कितने शेष डुप्लिकेट हैं और कितने आगे वर्ण हैं, वर्तमान वर्ण को ध्यान में रखने के लिए प्रत्येक को एक में जोड़ें, और मानों को अलग करें ताकि हम जानें कि कौन से विभाजित होने हैं और जिन्हें गुणा करना है ।

^
1

एक पूर्ण अभिव्यक्ति का उत्पादन करने के लिए एक उपसर्ग।

+`1(?=1*/(1+)x(\1)+$)|/1+x1+$
$#2$*

दूसरे अंतिम नंबर से विभाजित करते हुए बार-बार अंतिम और तीसरे नंबर को गुणा करें। यह पिछले तीन नंबरों की जगह लेता है।

1

दशमलव में परिवर्तित करें।

— नील
स्रोत
1

के, 27 बाइट्स

*/[1+!#:x]%*/{*/1+!x}'#:'x:

के, 16 बाइट्स - एक वास्तविक जवाब नहीं

#?(999999#0N)?\:

इनपुट स्ट्रिंग के 999999 यादृच्छिक क्रमांकन लें, उनमें से अद्वितीय सेट लें और लंबाई की गणना करें। ज्यादातर समय यह सही उत्तर देगा, छोटे तारों के लिए।

@Srichilism O'Zaic, @Selcuk के लिए बेहतर धन्यवाद

— हेनरी हेनरिंसन
स्रोत
2
साइट पर आपका स्वागत है! यह वास्तव में कोई बात नहीं है क्योंकि यह अमान्य है लेकिन क्या आप 999999इसके बजाय का उपयोग करके अपने अमान्य उत्तर को अधिक सटीक बना सकते हैं 100000?
— तदर्थ गार्फ हंटर
हाँ, अच्छा विचार, धन्यवाद।
— हेनरी हेनरिंस
1
और शायद उस बदलाव को प्रतिबिंबित करने के लिए स्पष्टीकरण को संपादित करें?
— सेल्कुक
1

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

Characters/*Permutations/*Length

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

स्पष्टीकरण: राइट-कंपोज़िशन /*इन तीन ऑपरेटरों को फ़ंक्शन तर्क के लिए एक के बाद एक, बाएं से दाएं पर लागू होता है:

  • Characters इनपुट स्ट्रिंग को वर्णों की सूची में परिवर्तित करता है।

  • Permutations इस चरित्र सूची के सभी अद्वितीय क्रमपरिवर्तन की सूची बनाता है।

  • Length अद्वितीय क्रमपरिवर्तन की इस सूची की लंबाई लौटाता है।

यह विधि लंबी स्ट्रिंग के लिए बहुत बेकार है: अद्वितीय क्रमपरिवर्तन वास्तव में सूचीबद्ध हैं और गिने जाते हैं, बजाय Multinomialलिस्टिंग के बिना उनकी संख्या की गणना करने के लिए।

— रोमन
स्रोत
1

पायथ , 5 4 बाइट्स

l{.p

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

यह मानता है कि इनपुट एक अजगर स्ट्रिंग शाब्दिक है। यदि इनपुट कच्चा पाठ होना चाहिए, तो यह 5-बाइट संस्करण काम करेगा:

l{.pz

किसी भी तरह से, यह एक सूची के रूप में इनपुट के सभी क्रमपरिवर्तन की गणना करता है, इसे काटता है और इसमें तत्वों की संख्या प्राप्त करता है, और स्पष्ट रूप से उस संख्या को प्रिंट करता है।

-1 बाइट थैंक्यू @ hakr14

— randomdude999
स्रोत
{से कम बाइट के लिए एक सूची में कटौती करता है .{।
— 15:14 बजे hakr14
1

PHP , 77 बाइट्स

function f($s){return!$s?:strlen($s)*f(substr($s,1))/substr_count($s,$s[0]);}

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

यह मूल रूप से @ ArBo के जीतने वाले पायथन जवाब का केवल एक PHP पोर्ट है जो कि मेरे द्वारा किए गए पुनरावर्ती उत्तर की तुलना में हास्यास्पद रूप से अधिक चतुर है। वाहवाही!

— 640KB
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.