Girdi olarak bir basamak dizesi veya bir tam sayı verildiğinde, dizini dizine eklemeniz gerekir.

Girişi bu şekilde değiştirirsiniz. 30043376111Örnek olarak kullanacağız :

İlk olarak, ilgili basamakların her bir oluşumunun endekslerinin toplamını bulun:

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

Ardından, yukarıdaki rakamların indekslerinin toplamı sırasına göre gittiği yeni bir tamsayı veya dize oluşturun. Birden fazla rakamın aynı toplamı vermesi durumunda, küçük rakam büyük rakamdan önce gelir:

047631

Son olarak, önde gelen sıfırları kaldırın ve sonucu döndürün veya yazdırın:

47631

Dizine alınan girişi döndüren veya yazdıran bir program veya işlev yazmalısınız.

Bu kod golf , bayt en kısa kod kazanır!

_{İstenirse daha fazla test örneği eklenebilir.}

k, 7 bayt

.<+/'=$

çevrimiçi yanıt

  $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

İşlevlerin yan yana diziliş kompozisyonudur, bu nedenle açık bir parametre veya giriş gerekmez.

Haskell, 69 bayt

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

Bir dize alır, bir sayı döndürür. Kullanım örneği: f "30043376111"-> 47631. Çevrimiçi deneyin!

Oldukça düz ileri: giriş dizesinin rakamlarını önce indekslerinin toplamına ve rakamın kendisine (-> çiftleri (toplam ..., d)) göre sıralayın, kopyaları kaldırın ve satır aralığını kaldırmak için bir sayıya dönüştürün 0. 0+Tipleri doğru almak için gereklidir.

Yığılmış , 59 bayt

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

Çevrimiçi deneyin!

Bu $'1231231', yığının üstünden girdi olarak bir karakter dizesi (gibi ) alır ve yığının üzerinde bir dize bırakır.

açıklama

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

Şimdi çiftler (chr, endekslerin toplamı) ile kaldık.

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

-1 sayesinde Riley

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

Çevrimiçi deneyin!

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 bayt

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

Bir dize alır n, sonra onu bir Kümeye ve sonra da farklı basamaklardan oluşan bir diziye dönüştürür. Bu rakamları sayısal sırada sıralar, ardından endekslerin toplamlarına göre tekrar sıralar. Sıralanan Diziyi bir Dizeye bitiştirir ve son olarak baştaki sıfırları kaldırmak için bir Sayıya dönüştürür.

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 bayt

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

Çevrimiçi deneyin!

Boş hashtable'a ayarlar $a, daha sonra giriş atan $argsbir şekilde charher bir unsur ile dizi ve döngüler |%{...}. Girdimizin endekslerini saymak için değeri $aartırılacak olan "mevcut eleman" olarak ayarladık $i++. Örneğin, giriş için 300433766111, birinci döngü $a[3]alır +=0; sonraki döngü, $a[0]alır +=1; vb.

Sonra Sorthashtable'ımıza ihtiyacımız var . Ne yazık ki, bir iç dil tuhaflığı nedeniyle, bu $a.GetEnumerator(), gerçek sıralamayı yapmadan önce yapmamız gerektiği anlamına gelir . Biz sırala value, o zamana kadar name, daha küçük basamak gereksinimi ilk sıralanmış almak karşılamak için. Bunları .Name(sıralı sırayla) -joinçıkarırız, birlikte bir dizeye ekleriz ve bu dizeyi +baştaki sıfırları kaldırmak için int olarak kullanırız. Boru hattında kalan ve çıktı örtük.

Jöle , 10 bayt

Ġ’S$ÞịDFQḌ

Çevrimiçi deneyin!

Bir tam sayı alır ve döndürür.

Nasıl?

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

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 bayt

10 bayt kazandığı için Ben Frankel'e teşekkürler!

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

Çevrimiçi deneyin!

Girdiyi dize olarak alır ve bir tamsayı çıkarır. Dizin toplamını saklamak için bir sözlük kullanır, sonra değere göre sıralar. Baştaki sıfırları ayırmak için tamsayıya dönüştürür, çünkü intdaha kısadır .lsplit('0').

Python 3,5, 86 85 bayt

Bay Frankel'e bir bayt kaydettiğiniz için teşekkürler:

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

Eski kod:

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

Bir rakam dizesi alan ve bir tamsayı döndüren anonim işlev

Pip , 18 bayt

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

Sayıyı komut satırı bağımsız değişkeni olarak alır. Çevrimiçi deneyin!

açıklama

                    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 bayt

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

Ne kadar sürdüğü ile memnun değil ve muhtemelen daha kısa olabilir ama bu ile sona erdi.

Perl 6 ,  65 61  52 bayt

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

Dene

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

Dene

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

Dene

Expanded

{      # 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, 123104 bayt

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

Örnek (Scala REPL kullanarak):

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

Sekonder sıralama için sıralama yüklemi olarak tuple kullanarak oldukça basittir.

Pyth, 9 bayt

sosxNcQ1{

Çevrimiçi deneyin

Girdi olarak bir basamak dizisi alır.

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.