Dada una cadena de dígitos o un entero como entrada, tendrá que indexarlo.

Así es como se modifica la entrada. Usaremos 30043376111como ejemplo:

Primero, encuentre la suma de los índices de cada aparición de los dígitos respectivos:

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

Luego, construya un nuevo entero o cadena donde los dígitos anteriores vayan en el orden de las sumas de sus índices. En el caso de que varios dígitos produzcan la misma suma, el dígito más pequeño precede al más grande:

047631

Finalmente, elimine los ceros a la izquierda y devuelva o imprima el resultado:

47631

Debe escribir un programa o función que devuelva o imprima la entrada indexada.

Este es el código de golf , por lo que gana el código más corto en bytes.

_{Se pueden agregar más casos de prueba si se solicita.}

k, 7 bytes

.<+/'=$

respuesta en línea

  $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

La yuxtaposición de funciones es composición, por lo que no se requiere ningún parámetro explícito o entrada.

Haskell, 69 bytes

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

Toma una cadena, devuelve un número. Ejemplo de uso: f "30043376111"-> 47631. Pruébalo en línea!

Bastante sencillo: primero clasifique los dígitos de la cadena de entrada en la suma de sus índices y luego por el dígito en sí (-> pares de (suma ..., d)), elimine los duplicados y conviértalos en un número para eliminar los iniciales 0. Se 0+necesita para obtener los tipos correctos.

Apilado , 59 bytes

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

Pruébalo en línea!

Esto toma una cadena de caracteres (como $'1231231') como entrada desde la parte superior de la pila y deja una cadena en la pila.

Explicación

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

Ahora nos quedan pares de (chr, suma de índices).

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

-1 gracias a Riley

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

Pruébalo en línea!

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 bytes

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

Toma una cadena n, luego la convierte en un conjunto y luego en una matriz de dígitos distintos. Ordena estos dígitos en orden numérico, luego los ordena de nuevo según sumas de índices. Concatena la matriz ordenada en una cadena y finalmente la convierte en un número para eliminar los ceros a la izquierda.

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 bytes

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

Pruébalo en línea!

Establece una tabla hash vacía $a, luego convierte la entrada $argscomo una charmatriz y recorre cada elemento |%{...}. Establecemos el valor en "el elemento actual" $apara que se incremente $i++, para contar los índices de entrada. Por ejemplo, para la entrada 300433766111, se $a[3]obtiene el primer bucle +=0; el siguiente ciclo, $a[0]consigue +=1; etc.

A continuación, necesitamos Sortnuestra tabla hash. Desafortunadamente, debido a una peculiaridad interna del lenguaje, esto significa que debemos hacerlo $a.GetEnumerator()antes de que podamos hacer la clasificación real. Ordenamos por value, luego por name, para satisfacer el requisito de que los dígitos más pequeños se ordenen primero. Sacamos los .Names de los mismos (en orden ordenado), -joinlos juntamos en una cadena y los convertimos como int +para eliminar los ceros iniciales. Eso queda en la tubería y la salida es implícita.

Jalea , 10 bytes

Ġ’S$ÞịDFQḌ

Pruébalo en línea!

Toma y devuelve un entero.

¿Cómo?

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

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 bytes

¡Gracias a Ben Frankel por guardar 10 bytes!

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

Pruébalo en línea!

Toma la entrada como una cadena y genera un número entero. Utiliza un diccionario para almacenar la suma de índices, luego lo ordena por valor. Se convierte en un entero para quitar los ceros iniciales porque intes más corto que .lsplit('0').

Python 3.5, 86 85 bytes

Gracias @Ben Frankel por guardar un byte:

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

Código antiguo

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

Función anónima que toma una cadena de dígitos y devuelve un entero

Pip , 18 bytes

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

Toma el número como un argumento de línea de comandos. Pruébalo en línea!

Explicación

                    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 bytes

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

No estoy contento con cuánto tiempo terminó siendo y probablemente puede ser más corto, pero esto es con lo que terminé.

Perl 6 ,  65 61  52 bytes

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

Intentalo

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

Intentalo

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

Intentalo

Expandido

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

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

Ejemplo (usando 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

Bastante sencillo, usando tuplas como predicado de clasificación para la clasificación secundaria.

Pyth, 9 bytes

sosxNcQ1{

Pruébalo en línea

Toma una cadena de dígitos como entrada.

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.