एक शब्द की रैंक का पता लगाएं

23

परिभाषा

किसी शब्द की श्रेणी को शब्द की स्थिति के रूप में परिभाषित किया जाता है, जब इसके अक्षरों के सभी संभावित क्रमपरिवर्तन (या व्यवस्था) वर्णानुक्रम में व्यवस्थित होते हैं, जैसे शब्दकोष में, कोई फर्क नहीं पड़ता कि शब्द सार्थक हैं या नहीं।

आइए हम इन दो शब्दों पर विचार करें - "नीला" और "देखा"। शुरू करने के लिए, हम इन शब्दों के अक्षरों की सभी संभावित व्यवस्थाओं को वर्णमाला क्रम में लिखेंगे:

"blue": "belu","beul","bleu","blue","buel","bule","eblu","ebul","elub","elbu","eubl",
        "eulb","lbeu","lbue","lebu","leub","lube","lueb","ubel","uble","uebl","uelb",
        "ulbe","uleb"
"seen": "eens","eesn","enes","ense","esen","esne","nees","nese","nsee","seen",
        "sene","snee"

अब आइए बाईं ओर देखें और उन शब्दों की स्थिति ज्ञात करें जिनकी हमें आवश्यकता है। हम देखते हैं कि "ब्लू" शब्द 4 वें स्थान पर है और "देखा गया" 10 वें स्थान पर है। तो "ब्लू" शब्द की रैंक 4 है, और "देखा गया" 10 है। यह शब्द के रैंक की गणना करने का सामान्य तरीका है। सुनिश्चित करें कि आप केवल 1 से गिनती शुरू करते हैं।

कार्य

आपका कार्य किसी भी शब्द को इनपुट के रूप में लेने के लिए एक कोड लिखना है और उसकी रैंक प्रदर्शित करना है। रैंक आउटपुट होना चाहिए। बार-बार पत्र वाले शब्दों के बारे में सावधान रहें।

उदाहरण

"prime" -> 94

"super" -> 93

"bless" -> 4

"speech" -> 354

"earth" -> 28

"a" -> 1

"abcd" -> 1

"baa" -> 3

आप इनपुट को लोअरकेस में पूरी तरह से मान सकते हैं और इनपुट में केवल वर्णमाला अक्षर होंगे । यदि रिक्त स्थान या अमान्य स्ट्रिंग दर्ज किया गया है, तो भी आप कुछ भी वापस कर सकते हैं।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है!

code-golf  string  combinatorics  sorting  permutations 
— मनीष कुंडू
स्रोत
— मार्टिन एंडर
14
"सुनिश्चित करें कि आप केवल 1 से गिनती शुरू करते हैं।" - यह पूरी तरह से आपके पास है, इस आवश्यकता के लिए, लेकिन ध्यान दें कि ऐसी चुनौतियों के लिए 0 या 1 आधारित अनुक्रमण की अनुमति देना काफी सामान्य है।
— जोनाथन एलन
1
हाँ, लेकिन अगर आप 0 से शुरू करते हैं, तो आप वास्तव में मूल रैंक प्रदर्शित नहीं कर रहे हैं, यही कारण है कि मैंने इस आवश्यकता को जोड़ने का फैसला किया है।
— मनीष कुंडू
उपयोगी लिंक । यदि आपका कार्यक्रम समय पर O(n log n)या कम चलता है तो आपको एसी मिलेगा । (क्षमा करें, कोई पायथन) मेरा सबमिशन (C ++) टेस्ट 14. हल करने के लिए 2.53s लेता है।
— user202729
क्या मैं एक शब्द या उस शब्द के साथ एक सूची कर सकता हूं, जैसे ['h', 'e', 'l', 'l', 'o']कि विरोध 'hello'?
— 0WJYxW9FMN

जवाबों:

4

अजगर , 6 बाइट्स

hxS{.p

परीक्षण सूट।

व्याख्या

hxS {.p || पूरा कार्यक्रम।

    .p || इनपुट के सभी क्रमपरिवर्तन।
   {|| Deduplicate।
  एस || क्रमबद्ध करें।
 x || इस सूची में इनपुट का सूचकांक।
ज || बढ़ते क्रम में।
— मिस्टर एक्सकोडर
स्रोत
3

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

Œ!ṢQi

इसे ऑनलाइन आज़माएं! या परीक्षण सूट देखें

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

Œ!ṢQi - Main link. Argument: s (string)      e.g. 'baa'
Œ!    - All permutations                          ['baa', 'baa', 'aba', 'aab', 'aba', 'aab']
  Ṣ   - Sort                                      ['aab', 'aab', 'aba', 'aba', 'baa', 'baa']
   Q  - Deduplicate                               ['aab', 'aba', 'baa']
    i - 1-based index of s                        3
— केर्ड सिक्काहिरिंग
स्रोत
बार-बार अक्षरों वाले शब्दों के लिए विफल।
— मनीष कुंडू
@ मनिष्ककुंड और एक्सकोडर, निश्चित
— केयर्ड सिक्काहिरिंगहिंग
दुर्भाग्य से Œ¿काम नहीं करता है।
— user202729
ṢŒ¿काम करता है ?
— फलन
@EsolangingFruit नहीं, कि सिर्फ आउटपुट1
— caird coinheringaahing
3

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

lambda s:-~sorted(set(permutations(s))).index(tuple(s))
from itertools import*

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

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

lambda s:-~sorted({*permutations(s)}).index((*s,))
from itertools import*

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

— जोनाथन फ्रेच
स्रोत
3

सीजेएम , 8 बाइट्स

q_e!\a#)

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

1-अनुक्रमित आवश्यकता के कारण +1 बाइट।

— आउटगोल्फर को एरिक करें
स्रोत
ठीक उसी तरह का जवाब मिला :(
— Esolanging Fruit
@EsolangingFruit यदि आप चाहें तो आप इसे अभी भी पोस्ट कर सकते हैं :-)
— आउटगॉल्फर
2

जाप , 8 10 बाइट्स

0 अनुक्रमित। पॉक्सो, अनावश्यक 1-इंडेक्सिंग, मेरी बाइट गिनती को 25% तक बढ़ा रहा है!

á â n bU Ä

झसे आज़माओ

व्याख्या

áइनपुट के सभी क्रमांकन प्राप्त करता है, âडुप्लिकेट को हटाता है, nउन्हें सॉर्ट करता है और bइनपुट की पहली घटना का सूचकांक प्राप्त करता है U।

— झबरा
स्रोत
असामान्य (असामान्य) ध्यान दें "सुनिश्चित करें कि आप केवल 1 से गिनती शुरू करें" आवश्यकता। मैंने ओपी के तहत टिप्पणी की है कि 0-आधारित को भी अनुमति देना सामान्य होगा।
— जोनाथन एलन
1
आह, ईश्वरदत्त; स्थिर 1-अनुक्रमण। जल्द ही अपडेट होगा लेकिन यह मेरी बाइट की गिनती को 25% तक बढ़ा देगा।
— झबरा
2

जे , २tes २३ बाइट्स

-5 बाइट्स FrownyFrog के लिए धन्यवाद

1+/:~@~.@(A.~i.@!@#)i.]

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

                      ] - the argument
         (A.~      )    - permutations in the 
             i.@!@#     - range 0 to factorial of the arg. length
  /:~@~.@               - remove duplicates and sort
                    i.  - index of arg. in the sorted list
1+                      - add 1 (for 1-based indexing)

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

— गैलेन इवानोव
स्रोत
1
23:1+/:~@~.@(A.~i.@!@#)i.]
— फ्रॉन्फ्रोग
@FrownyFrog - i का अच्छा उपयोग। सूचकांक खोजने के लिए! धन्यवाद!
— गालेन इवानोव
TIO लिंक अभी भी पुराना संस्करण है :)
— कॉनर ओ'ब्रायन
@ कोरोन ओ'ब्रायन - निश्चित
— गैलेन इवानोव
जब तक मैं कश्मीर में एक समाधान प्राप्त नहीं करता हूं, तब तक मैं खुश नहीं हूं जब तक कि वह जे एक से कम न हो । उस ने कहा, क्या आप यहां एक ही चाल का उपयोग कर सकते हैं? सॉर्ट किए गए इनपुट स्ट्रिंग के क्रमपरिवर्तन उत्पन्न करें (इसलिए क्रमबद्ध सूची को क्रमबद्ध करने की आवश्यकता को हटा दें)?
— स्ट्रीटस्टर
2

Tcl, 196 बाइट्स

proc p {a p} {if {$a eq {}} {lappend ::p $p} {while {[incr n]<=[llength $a]} {p [lreplace $a $n-1 $n-1] $p[lindex $a $n-1]}}}
p [split $argv ""] ""
puts [expr [lsearch [lsort -unique $p] $argv]+1]

अगले lexicographic क्रमपरिवर्तन की गणना करने के लिए Tcl में कोई अंतर्निहित विधि नहीं है, इसलिए हमें इसे स्वयं करना होगा। लेकिन प्रतीक्षा करें ... यह एक सरल पुनरावर्ती फ़ंक्शन के साथ करना कम है जो किसी भी क्रम में सभी संभव क्रमपरिवर्तन की गणना करता है ।

Ungolfed:

# Compute all possible permutations of the argument list
# Puts the result in ::all_permutations
proc generate_all_permutations {xs {prefixes ""}} {
  if {$xs eq {}} {
    lappend ::all_permutations $prefixes
  } else {
    while {[incr n] <= [llength $xs]} {
      generate_all_permutations [lreplace $xs $n-1 $n-1] $prefixes[lindex $xs $n-1]
    } 
  }
}

# Get our input as command-line argument, turn it into a list of letters
generate_all_permutations [split $argv ""]

# Sort, remove duplicates, find the original argument, and print its 1-based index
puts [expr [lsearch [lsort -unique $all_permutations] $argv]+1]
— Dúthomhas
स्रोत
मैंने कुछ बाइट्स का मुंडन किया
— sergiol
अधिक शेविंग tio.run/…
— Sergiol
धन्यवाद। जब मुझे एक वास्तविक कंप्यूटर पर फिर से पहुंच मिलेगी तो मैं अपडेट करूंगा।
— दुओथोमस
2

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

समाधान:

1+*&x~/:?x@prm@<x:

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

उदाहरण:

1+*&x~/:?x@prm@<x:"seen"
10
1+*&x~/:?x@prm@<x:"blue"
4

स्पष्टीकरण:

सॉर्ट किए गए इनपुट स्ट्रिंग के सूचकांकों की अनुमति उत्पन्न करें, उन्हें इनपुट स्ट्रिंग में वापस इंडेक्स करने के लिए उपयोग करें, अलग-अलग लें, देखें कि मूल स्ट्रिंग कहां से मेल खाती है, और एक जोड़ें।

1+*&x~/:?x@prm@<x: / the solution
                x: / save input string as x
               <   / return indices when sorting x ascending
           prm@    / apply (@) function prm
         x@        / index into x with these permutations
        ?          / distinct (remove duplicates)
    x~/:           / apply match (~) between x and each-right (/:)
   &               / return indexes where true (ie the match)
  *                / take the first one
1+                 / add 1 due to 1-indexing requirement
— streetster
स्रोत
2

जावा 8, 211 बाइट्स

import java.util.*;TreeSet q=new TreeSet();s->{p("",s);return-~q.headSet(s).size();}void p(String p,String s){int l=s.length(),i=0;if(l<1)q.add(p);for(;i<l;p(p+s.charAt(i),s.substring(0,i)+s.substring(++i,l)));}

स्पष्टीकरण:

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

import java.util.*;        // Required import for TreeSet

TreeSet q=new TreeSet();   // Sorted Set on class-level

s->{                       // Method with String parameter and integer return-type
  p("",s);                 //  Save all unique permutations of the String in the sorted set
  return-~q.headSet(s).size();}
                           //  Return the 0-indexed index of the input in the set + 1

void p(String p,String s){ // Separated method with 2 String parameters and no return-type
  int l=s.length(),        //  The length of the String `s`
      i=0;                 //  Index integer, starting at 0
  if(l<1)                  //  If String `s` is empty
    q.add(p);              //   Add `p` to the set
  for(;i<l;                //  Loop from 0 to `l` (exclusive)
    p(                     //   Do a recursive call with:
      p+s.charAt(i),       //    `p` + the character at the current index of `s` as new `p`
      s.substring(0,i)+s.substring(++i,l)));}
                           //    And `s` minus this character as new `s`
— केविन क्रूज़सेन
स्रोत
2

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

पहला उत्तर जो बहुपदीय समय में चलता है!

a=[*map(ord,input())]
f=lambda x:x and x*f(x-1)or 1
c=[0]*98
for C in a:c[C]+=1
l=len(a)
F=f(l)
for i in c:F//=f(i)
r=1
for x in a:F//=l;l-=1;r+=sum(c[:x])*F;F*=c[x];c[x]-=1
print(r)

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

सभी ऊपरी-मामले होने के लिए इनपुट की आवश्यकता होती है, क्योंकि ... यह एक बाइट बचाता है।

पूर्ण कार्यक्रम, से इनपुट stdinऔर आउटपुट लेता है stdout।

परिवर्तनीय नाम: (असंगठित कोड का प्रकार)

a : permu
f : factorial
c : count_num
C : char
l : n_num_left
F : factor
r : result

दुर्भाग्य से, from math import factorial as fबिल्कुल 1 बाइट लेता है।

(असंबंधित नोट: मैंने Combinatorica`गणितज्ञ के पैकेज की जांच की , जिसमें कुछ भी उपयोगी नहीं है, जिसमें शामिल हैं RankPermutation)

— user202729
स्रोत
यह कोड वास्तव में अच्छा है।
— मनीष कुंडू
1

भूसी , 6 बाइट्स

S€(OuP

इसे ऑनलाइन आज़माएं! मुझे लगता है कि ड्रॉप करने का एक तरीका होना चाहिए (।

स्पष्टीकरण:

 €     -- return index of the input 
S (    -- in the list generated by applying the following functions to the input:
     P -- permutations
    u  -- remove duplicates
   O   -- sort
— Laikoni
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 106 100 बाइट्स

w=>(P=(a,s)=>a[0]?a.map((_,i)=>P(b=[...a],s+b.splice(i,1))):P[s]=P[s]||++k)[P([...w].sort(),k=''),w]

परीक्षण के मामलों

कोड स्निपेट दिखाएं

कैसे?

P () हमारा पुनरावर्ती क्रमचय कार्य है। लेकिन क्रमपरिवर्तन के रैंकों को संग्रहीत करने के लिए P की शामिल वस्तु का भी उपयोग किया जाता है।

P = (a, s) =>               // given an array of letters a[] and a string s
  a[0] ?                    // if a[] is not empty:
    a.map((_, i) =>         //   for each entry at position i in a[]:
      P(                    //     do a recursive call to P() with:
        b = [...a],         //       a copy b[] of a[], with a[i] removed
        s + b.splice(i, 1)  //       the extracted letter appended to s
      )                     //     end of recursive call
    )                       //   end of map()
  :                         // else:
    P[s] = P[s] || ++k      //   if P[s] is not already defined, set it to ++k

रैपिंग कोड अब इस प्रकार है:

w =>                        // given the input word w
  P[                        // return the permutation rank for w
    P(                      //   initial call to P() with:
      [...w].sort(),        //     the lexicographically sorted letters of w
      k = ''                //     s = k = '' (k is then coerced to a number)
    ),                      //   end of call
    w                       //   actual index used to read P[]
  ]                         // end of access to P[]
— Arnauld
स्रोत
1

सी ++, 230 बाइट्स

#include<algorithm>
#include<iostream>
#include<string>
using namespace std;void R(string s){int n=1;auto p=s;sort(begin(p),end(p));do if(p==s)cout<<n;while(++n,next_permutation(begin(p),end(p)));}int main(int n,char**a){R(a[1]);}

मेरे पूछने के अनुसार, कोड निश्चित रूप से निष्पादन योग्य होना चाहिए। फ़ंक्शन-केवल क्लॉज़ मूल रूप से बकवास है। : - @

उन लोगों का शुक्रिया, जिन्होंने मेरे सवाल का जवाब दिया। मान्य कोड के हित में , मैंने <बिट्स / stdc ++ h> सहित लोकप्रिय GCC-ism से परहेज किया है, जिसे मैंने हमेशा एक ख़राब लूपहोल धोखा माना है।

इस प्रकार मेरी मूल पोस्टिंग के अवशेष क्या हैं:

C और C ++ का उपयोग करते समय मैं हमेशा अनिश्चित रहता हूं कि बाइट कुल की क्या गिनती है। के अनुसार कार्यक्रम, समारोह, या स्निपेट? जवाब अभी भी अस्पष्ट है (जब तक यह स्निपेट नहीं है, मुझे लगता है)। इसलिए मैं दो संभावनाओं में से सबसे छोटा हूं।

यहाँ यह आवश्यक हेडर आदि के साथ अपराजित है :

#include <algorithm>
#include <iostream>
#include <string>
using namespace std;

void R( string s )
{
  int n = 1;
  auto p = s;
  sort( begin(p), end(p) );
  do if (p == s) cout << n;
  while (++n, next_permutation( begin(p), end(p) ));
}

int main( int n, char** a )
{
  R( a[1] );
}

यह 230 बाइट्स तक नीचे आता है, इसके लिए आवश्यक मानक बॉयलरप्लेट का एक तिहाई हर C ++ प्रोग्राम । (इसलिए, मुझे यह नहीं लगता कि इसे गिनना बुरा नहीं है, लेकिन जैसा कि मैंने कभी भी किसी भी तरह की शिकायत नहीं देखी है, ओपी को मुझे बताना होगा जो वह संतुष्ट करना पसंद करता है "किसी भी शब्द को इनपुट के रूप में लेने के लिए एक कोड लिखें" और इसकी रैंक प्रदर्शित करें। ”)

मैं भी अनिश्चित हूँ अगर यह संतुष्ट करता है "रैंक आउटपुट होना चाहिए।"

— Dúthomhas
स्रोत
1
उह ... AFAIK हमारे नियम आवश्यक हैं ( using namespace std, #include <algorithm> हेडर बाइट्स में फ़ंक्शन को परिभाषित करने के लिए उपयोग किया जाता है। और ... नहीं, main(){}8 बाइट्स में एक मान्य C ++ (g ++) प्रोग्राम है।
— user202729
मैं एक अड़ियल स्नॉट बनने की कोशिश नहीं कर रहा हूं, लेकिन मैं हर समय सी और सी ++ (साथ ही अन्य भाषाओं) के लिए सबमिशन देखता हूं जो केवल एक ही फ़ंक्शन हैं। मुझे एक निश्चित उत्तर चाहिए। मैं आमतौर पर इस कारण से सी-भाषाओं में गोल्फ नहीं करता हूं। (और मैं रेगुल्फ़ के लिए खुश हूं।)
— दुओथोमस
1
यहां तक ​​कि पायथन में, import mathअक्सर आवश्यक होता है। मुझे प्रासंगिक मेटा खोजने दें ...
— user202729
@ Dththomhas उन समाधानों में हेडर की आवश्यकता नहीं होती है। बेसिक अंकगणित को किसी हेडर की आवश्यकता नहीं होती है, और कुछ कार्यों को stdlib (जैसे putsऔर printf) के लिंकिंग द्वारा स्पष्ट रूप से घोषित और भरा जा सकता है । आपके कोड को मान्य होने के लिए सफलतापूर्वक-संकलित और चलाना होगा। देखें: codegolf.meta.stackexchange.com/a/10085/45941
— Mego
@Mego mainकार्यों की घोषणा के बिना के रूप में नहीं चलाया जा सकता है।
— user202729
0

पॉवरशेल , 275 बाइट्स

param($s)function n($a){if($a-eq1){return}0..($a-1)|%{n($a-1);if($a-eq2){$b.ToString()}$p=($j-$a);[char]$t=$b[$p];for($z=($p+1);$z-lt$j;$z++){$b[($z-1)]=$b[$z]}$b[($z-1)]=$t}}if($s.length-eq1){1;exit}$b=New-Object Text.StringBuilder $s;(n($j=$s.length)|sort -u).indexOf($s)+1

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

तो, यह एक खूनी गड़बड़ है।

PowerShell में अंतर्निहित कोई भी क्रमपरिवर्तन नहीं है, इसलिए यह कोड यहाँ से एल्गोरिदम का उपयोग करता है (भारी रूप से गोल्फ), जो Microsoft Limited Public License ( इस लाइसेंसिंग पृष्ठ पर एक्ज़िबिट B ) के तहत उपलब्ध है ।

कार्यक्रम $sएक स्ट्रिंग के रूप में इनपुट लेता है , फिर वास्तविक कार्यक्रम के साथ शुरू होता है $b=New-Object ...। हम एक नई StringBuilder वस्तु का निर्माण कर रहे हैं , जो (अनिवार्य रूप से) पात्रों का एक परस्पर स्ट्रिंग है। यह हमें अधिक आसानी से क्रमपरिवर्तन को संभालने की अनुमति देगा। हम तो फ़ंक्शन को कॉल n(स्थापित करने $jके रास्ते में इनपुट स्ट्रिंग की लंबाई होने के लिए), sortके साथ -uउत्पादन nique झंडा ले.indexOf() इनपुट स्ट्रिंग को खोजने के लिए, और जोड़ने 1क्योंकि PowerShell है शून्य अनुक्रमित।

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

क्रमपरिवर्तन फ़ंक्शन कैसे काम करता है, इस कारण if($s.length-eq1){1;exit}लंबाई 1के इनपुट स्ट्रिंग के लिए खाते में अतिरिक्त तर्क का एक बिट है ।

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