Cho một chuỗi các chữ số hoặc một số nguyên làm đầu vào, bạn sẽ phải lập chỉ mục nó.

Đây là cách bạn sửa đổi đầu vào. Chúng tôi sẽ sử dụng 30043376111làm ví dụ:

Đầu tiên, tìm tổng các chỉ số của mỗi lần xuất hiện của các chữ số tương ứng:

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

Sau đó, xây dựng một số nguyên hoặc chuỗi mới trong đó các chữ số ở trên đi theo thứ tự tổng của các chỉ số của chúng. Trong trường hợp nhiều chữ số mang lại cùng một tổng, chữ số nhỏ hơn xuất hiện trước chữ số lớn hơn:

047631

Cuối cùng, xóa mọi số 0 đứng đầu và trả về hoặc in kết quả:

47631

Bạn phải viết một chương trình hoặc hàm trả về hoặc in đầu vào được lập chỉ mục.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

_{Nhiều trường hợp thử nghiệm có thể được thêm vào nếu được yêu cầu.}

k, 7 byte

.<+/'=$

thay thế trực tuyến

  $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

Juxtap vị trí của các chức năng là thành phần, do đó không cần tham số rõ ràng hoặc đầu vào.

Haskell, 69 byte

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

Lấy một chuỗi, trả về một số. Ví dụ sử dụng: f "30043376111"-> 47631. Hãy thử trực tuyến!

Khá đơn giản: sắp xếp các chữ số của chuỗi đầu vào trước trên tổng các chỉ số của chúng và theo chính chữ số (-> cặp (tổng ..., d)), loại bỏ trùng lặp và chuyển đổi thành một số để loại bỏ hàng đầu 0. Điều 0+cần thiết để có được các loại đúng.

Xếp chồng lên nhau , 59 byte

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

Hãy thử trực tuyến!

Điều này lấy một chuỗi ký tự (như $'1231231') làm đầu vào từ đầu ngăn xếp và để lại một chuỗi trên ngăn xếp.

Giải trình

:@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'))

Bây giờ chúng ta còn lại với các cặp (chr, tổng các chỉ số).

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

05AB1E , 29 28 byte

-1 cảm ơn Riley

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

Hãy thử trực tuyến!

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.

JavaScript (ES6), 98 byte

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

Lấy một chuỗi n, sau đó chuyển đổi nó thành Tập hợp và sau đó thành một mảng gồm các chữ số riêng biệt. Sắp xếp các chữ số này theo thứ tự số, sau đó sắp xếp lại theo tổng chỉ số. Ghép mảng đã sắp xếp thành Chuỗi và cuối cùng chuyển đổi thành Số để loại bỏ các số 0 đứng đầu.

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

PowerShell , 88 byte

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

Hãy thử trực tuyến!

Đặt một hashtable trống $a, sau đó đưa đầu vào $argsthành một charmảng và lặp qua từng phần tử |%{...}. Chúng tôi đặt giá trị ở "phần tử hiện tại" $asẽ được tăng lên theo $i++, để đếm các chỉ số đầu vào của chúng tôi. Ví dụ, đối với đầu vào 300433766111, vòng lặp đầu tiên $a[3]được +=0; vòng lặp tiếp theo, $a[0]được+=1 ; Vân vân.

Tiếp theo, chúng ta cần Sorthashtable của chúng tôi. Thật không may, do một vấn đề ngôn ngữ nội bộ, điều này có nghĩa là chúng ta cần phải làm $a.GetEnumerator()trước khi chúng ta có thể thực hiện sắp xếp thực tế. Chúng tôi sắp xếp theo value, sau đó name, để đáp ứng yêu cầu của các chữ số nhỏ hơn được sắp xếp trước. Chúng ta kéo các chuỗi .Namecủa chúng (theo thứ tự được sắp xếp), -joinchúng lại với nhau thành một chuỗi và đúc chuỗi đó thành một số nguyên +để loại bỏ các số 0 đứng đầu. Đó là còn lại trên đường ống và đầu ra là ẩn.

Thạch , 10 byte

Ġ’S$ÞịDFQḌ

Hãy thử trực tuyến!

Lấy và trả về một số nguyên.

Làm sao?

Ġ’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

PHP, 103 byte

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

Python 2, 102 92 byte

Cảm ơn Ben Frankel vì đã tiết kiệm 10 byte!

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

Hãy thử trực tuyến!

Lấy đầu vào dưới dạng một chuỗi và xuất ra một số nguyên. Sử dụng một từ điển để lưu trữ tổng các chỉ mục, sau đó sắp xếp nó theo giá trị. Chuyển đổi thành một số nguyên để loại bỏ các số 0 đứng đầu vì intngắn hơn .lsplit('0').

Python 3.5, 86 85 byte

Cảm ơn @Ben Frankel vì đã lưu một byte:

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

Mã cũ:

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

Hàm ẩn danh lấy một chuỗi các chữ số và trả về một số nguyên

Pip , 18 byte

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

Lấy số làm đối số dòng lệnh. Hãy thử trực tuyến!

Giải trình

                    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)

C #, 245 byte

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

Không hài lòng với thời gian cuối cùng và nó có thể ngắn hơn nhưng đây là những gì tôi đã kết thúc.

Perl 6 ,  65 61  52 byte

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

Thử nó

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

Thử nó

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

Thử nó

Mở rộng

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

Scala, 123 104 byte

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

Ví dụ (sử dụng Scala REPL):

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

Khá đơn giản, sử dụng tuple làm vị ngữ sắp xếp cho sắp xếp thứ cấp.

Bình thường, 9 byte

sosxNcQ1{

Dùng thử trực tuyến

Lấy một chuỗi các chữ số làm đầu vào.

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.