किसी नंबर को अनुक्रमित करें

Question

इनपुट के रूप में अंकों की एक स्ट्रिंग या एक पूर्णांक को देखते हुए, आपको इसे अनुक्रमित करना होगा।

इस तरह आप इनपुट को संशोधित करते हैं। हम 30043376111एक उदाहरण के रूप में उपयोग करेंगे:

सबसे पहले, संबंधित अंकों की प्रत्येक घटना के सूचकांकों का योग खोजें:

0: 1 + 2 = 3
1: 8 + 9 + 10 = 27
3: 0 + 4 + 5 = 9
4: 3
6: 7
7: 6

फिर, एक नए पूर्णांक या स्ट्रिंग का निर्माण करें जहाँ ऊपर दिए गए अंक उनके सूचकांकों के क्रम में चलते हैं। इस मामले में कि कई अंक एक ही राशि का उत्पादन करते हैं, छोटा अंक बड़े से पहले आता है:

047631

अंत में, किसी भी अग्रणी शून्य को निकालें, और परिणाम को वापस करें या प्रिंट करें:

47631

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो रिटर्न करता है या इनपुट किए गए इनपुट को प्रिंट करता है।

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

_{अनुरोध किए जाने पर अधिक परीक्षण मामले जोड़े जा सकते हैं।}

Comments

कार्यों के लिए, क्या एक स्ट्रिंग ठीक है? कैसे एक तर्क के रूप में एक स्ट्रिंग लेने के बारे में?

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

@ ConorO'Brien अंकों या एक पूर्णांक की एक स्ट्रिंग को देखते हुए

— AdmBorkBork

@AdmBorkBork खैर, कि इनपुट सवाल का जवाब> _>

— Conor O'Brien

@ ConorO'Brien इसके अलावा, एक नए पूर्णांक या स्ट्रिंग का निर्माण करें , जो लगता है कि स्ट्रिंग वापस करना ठीक है, भी।

— AdmBorkBork

Answer 1

k, 7 बाइट्स

.<+/'=$

ऑनलाइन उत्तर

  $30043376111 / convert to string($)
"30043376111"
  =$30043376111 / group(=) - return a mapping (dict) from unique chars to indices
"304761"!(0 4 5
 1 2
 ,3
 ,6
 ,7
 8 9 10)
  +/'=$30043376111 / sum(+/) each(') value in the dict
"304761"!9 3 3 6 7 27
  <+/'=$30043376111 / grade(<) ascending values - return keys from the dict
"047631"
  .<+/'=$30043376111 / execute(.) the string - convert it to a number
47631

कार्यों का Juxtaposition संरचना है, इसलिए कोई स्पष्ट पैरामीटर या इनपुट की आवश्यकता नहीं है।

Answer 2

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

import Data.List
f x=0+read(nub$sortOn(\d->(sum$elemIndices d x,d))x)

एक स्ट्रिंग लेता है, एक नंबर देता है। प्रयोग उदाहरण: f "30043376111"-> 47631। इसे ऑनलाइन आज़माएं!

बहुत सीधे आगे: इनपुट स्ट्रिंग के अंकों को पहले उनके सूचकांकों के योग पर और अंकों के आधार पर ही (-> जोड़े (योग ..., d)) के आधार पर, डुप्लिकेट को हटा दें और अग्रणी को हटाने के लिए एक संख्या में परिवर्तित करें 0। 0+प्रकार सही पाने के लिए की जरूरत है।

Answer 3

ढेर , 59 बाइट्स

:@q uniq[:q\eq q size:>*sum,]map[-1#]sortby[0#]map''#`'^0'-

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

यह $'1231231'स्टैक के शीर्ष से इनपुट के रूप में एक वर्ण स्ट्रिंग (जैसे ) लेता है , और स्टैक पर एक स्ट्रिंग छोड़ देता है।

व्याख्या

:@q uniq[:q\eq q size:>*sum,]map        stack: (str)
:                                       stack: (str str)
 @q                                     stack: (str)        ; store as `q`
    uniq                                stack: (str')       ; de-duplicate
        [                   ]map        map the inner over each element
         :                              stack: (chr chr)
          q\eq                          stack: (chr q')     ; `q'` is where equality occurs
               q size:>                 stack: (chr, q', k) ; `k` is range from 0, size(q')
                       *sum             stack: (chr, k')    ; `k'` is sum of indices
                           ,            stack: ((chr, k'))

अब हम (chr, योग की राशि) के जोड़े से बचे हैं।

[-1#]sortby[0#]map''#`'^0'-
[   ]sortby                    sort by the inner function
 -                             vectorized subtraction of two pairs
  1#                           use the second element as the comparison
           [0#]map             get the first element of each row
                  ''#`         join by the empty string
                      '^0'-    remove all leading zeroes

Answer 4

05AB1E , 29 28 बाइट्स

-1 रिले के लिए धन्यवाद

TFN¹SQDg<ÝsÏON‚}){vyD0å_i1è,

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

TFN            }             # Loop from 0 to 9.
   ¹SQ                       # Push 1 if index is same as `y`.
      Dg<ÝsÏ                 # Push index of the number instead of 1.
            ON‚              # Sum, combine with current `y`.
                ){           # Collect, sort 'em.
                  vyD0å_i1è, # Only print the ones with a count above 0.

Comments

आप स्थानापन्न कर सकते हैं TFNके लिए9Ývy

— रिले

@ रिले 05AB1E एक अजीब भाषा है ... ऐसा लगता है कि आप इसे जितनी अधिक बार उपयोग करने की कोशिश कर रहे हैं उतना ही अधिक जटिल हो जाएगा ... धन्यवाद, हाँ, यह ठीक काम करने लगता है।

— मैजिक ऑक्टोपस अर्ने

Answer 5

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

n=>+[...new Set(n)].sort().sort((a,b)=>(s=d=>[...n].reduce((S,D,i)=>S+i*(d==D),0))(a)-s(b)).join``

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

f=
n=>+[...new Set(n)].sort().sort((a,b)=>(s=d=>[...n].reduce((S,D,i)=>S+i*(d==D),0))(a)-s(b)).join``

console.log(f('30043376111'))

Comments

क्या बार-बार आवश्यक है?

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

हां, "इस मामले में कि कई अंक समान राशि प्राप्त करते हैं, छोटा अंक बड़े से पहले आता है"। पहले के बिना .sort(), 1332 का इनपुट 123 के बजाय 132 पैदावार देता है।

— darrylyeo

आह, ठीक है, मैं देखता हूं

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

Answer 6

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

$a=@{};[char[]]"$args"|%{$a[$_]+=$i++};+-join(($a.GetEnumerator()|Sort value,name).Name)

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

एक खाली हैशटेबल सेट करता है $a, फिर इनपुट $argsको एक charसरणी के रूप में रखता है, और प्रत्येक तत्व के माध्यम से लूप करता है |%{...}। हमने "वर्तमान तत्व" का मान निर्धारित किया है$a$i++ अपने इनपुट के सूचकांकों को गिनने लिए बढ़ाते हैं । उदाहरण के लिए, इनपुट के लिए, 300433766111पहला लूप $a[3]मिलता है +=0; अगला लूप, $a[0]मिलता है +=1; आदि।

इसके बाद, हमें Sortअपने हैशटेबल की जरूरत है । दुर्भाग्य से, एक आंतरिक भाषा क्विक के कारण, इसका मतलब $a.GetEnumerator()है कि वास्तविक छँटाई करने से पहले हमें इसकी आवश्यकता होगी । हम valueतब nameछोटे अंकों की आवश्यकता को पूरा करने के लिए पहले के अनुसार क्रमबद्ध करते हैं। हम .Nameउसके (क्रमबद्ध क्रम में) तत्संबंधी -joinस्ट्रिंग में एक साथ खींचते हैं , और उस स्ट्रिंग को एक इंट के रूप में डालते हैं+ अग्रणी ज़िलों को हटाने के लिए डालते हैं। यह पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

Answer 7

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

Ġ’S$ÞịDFQḌ

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

पूर्णांक बनाता है और लौटाता है।

कैसे?

Ġ’S$ÞịDFQḌ - Main link: n            e.g. 30043376111
Ġ          - group indices of n by value  [[2,3],[9,10,11],[1,5,6],[4],[8],[7]] (implicitly treats the number as a decimal list)
    Þ      - sort that by:
   $       -     last two links as a monad:
 ’         -         decrement (since Jelly is 1-indexed)
  S        -         sum                  [[2,3],[4],[7],[8],[1,5,6],[9,10,11]] (this leaves those indices of lower value to the left as required)
      D    - decimal list of n            [3,0,0,4,3,3,7,6,1,1,1]
     ị     - index into                   [[0,0],[4],[7],[6],[3,3,3],[1,1,1]]
       F   - flatten                      [0,0,4,7,6,3,3,3,1,1,1]
        Q  - unique                       [0,4,7,6,3,1]
         Ḍ - cast to a decimal number     47631

Answer 8

PHP, 103 बाइट्स

for(;$i<strlen($a="$argv[1]");)$r[$a[$i]]+=$i++;ksort($r);asort($r);echo ltrim(join(array_keys($r)),0);

Answer 9

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

10 बाइट बचाने के लिए बेन फ्रैंकल को धन्यवाद!

a={}
for i,j in enumerate(input()):a[j]=a.get(j,0)+i
print int(''.join(sorted(a,key=a.get)))

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

एक स्ट्रिंग के रूप में इनपुट लेता है और एक पूर्णांक आउटपुट करता है। इंडेक्स के योग को संग्रहीत करने के लिए एक शब्दकोश का उपयोग करता है, फिर इसे मूल्य के अनुसार क्रमबद्ध करता है। एक पूर्णांक में धर्मान्तरित करने के लिए अग्रणी शून्य से दूर है क्योंकि intकी तुलना में कम है .lsplit('0')।

Comments

a[j]=a.get(j,0)+i10 बाइट्स बचाता है।

— बेन फ्रेंकल

Answer 10

पायथन 3.5, 86 85 बाइट्स

धन्यवाद @ बाइट को बचाने के लिए फ्रेंकेल:

f=lambda s:int(''.join(sorted({*s},key=lambda d:sum(i*(c==d)for i,c in enumerate(s)))))

पुराना कोड:

lambda s:int(''.join(sorted({*s},key=lambda d:sum(i for i,c in enumerate(s)if c==d))))

बेनामी फ़ंक्शन अंकों की एक स्ट्रिंग ले रहा है और एक पूर्णांक वापस कर रहा है

Comments

sum(i*(c==d)for1 बाइट बचाता है।

— बेन फ्रेंकल

Answer 11

पिप , 18 बाइट्स

+J:$+(a@*_)SKSNUQa

कमांड-लाइन तर्क के रूप में संख्या लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

                    a is 1st cmdline arg (implicit)
               UQa  Get unique digits in a
             SN     Sort (numerically)
           SK       Then sort with this key function:
      a@*_           Find all indices of argument in a
   $+(    )          and sum them
 J:                 Join the resulting list back into a string (: is used to lower the
                    precedence of J)
+                   Convert to number (eliminates leading 0)
                    Print (implicit)

Answer 12

सी #, 245 बाइट्स

using System.Linq;s=>{var a=new int[10];for(int i=0,l=0;i<10;i++){a[i]=-1;while((l=s.IndexOf(i+"",l+1))!=-1)a[i]+=l;}return string.Concat(a.Select((c,i)=>new{c,i}).OrderBy(o=>o.c).ThenBy(o=>o.i).Where(o=>o.c>-1).Select(o=>o.i)).TrimStart('0');};

खुश नहीं है कि यह कब तक खत्म हो रहा है और यह शायद कम हो सकता है लेकिन यह वही है जो मैंने खत्म किया है।

Answer 13

पर्ल 6 ,  65 61  52 बाइट्स

{+[~] {}.push(.comb.map:{$_=>$++}).sort({.value.sum,.key})».key}

कोशिश करो

{+[~] {}.push(.comb.antipairs).sort({.value.sum,.key})».key}

कोशिश करो

{+[~] .comb.antipairs.Bag.sort({.value,.key})».key}

कोशिश करो

विस्तारित

{      # bare block lambda with implicit parameter ｢$_｣

  +    # turn the following into a Numeric
  [~]  # reduce the following using &infix:<~> (join)

    .comb              # list of digits from ｢$_｣ (implicit method call)
    .antipairs         # get a list of ｢value => index｣ pairs from above list
    .Bag               # combine them together (does the sum)
    .sort(
      { .value, .key } # sort it by the sum of indexes, then by the digit
    )».key             # get the list of digits from that
}

Answer 14

स्काला, 123 104 बाइट्स

(_:String).zipWithIndex.groupBy(_._1).toSeq.sortBy(c=>c._2.map(_._2).sum->c._1).map(_._1).mkString.toInt

उदाहरण (स्काला आरईपीएल का उपयोग करके):

scala> (_:String).zipWithIndex.groupBy(_._1).toSeq.sortBy(c=>c._2.map(_._2).sum->c._1).map(_._1).mkString.toInt
res0: String => Int = <function1>

scala> res0("30043376111")
res1: Int = 47631

बहुत सीधा है, द्वितीयक प्रकार के लिए विधेय छँटाई के रूप में टपल का उपयोग करना।

Answer 15

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

sosxNcQ1{

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

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

sosxNcQ1{
sosxNcQ1{Q    Implicit variable introduction
        {Q    Unique digits
 o            Order by
     cQ1      Chop input into list of individual characters.
   xN         Find all indexes of the digit in question in the list.
  s           Sum
s             Convert string to integer.