Data una stringa di cifre o un numero intero come input, dovrai indicizzarlo.

Ecco come si modifica l'input. Useremo 30043376111come esempio:

Innanzitutto, trova la somma degli indici di ciascuna occorrenza delle rispettive cifre:

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

Quindi, costruisci un nuovo numero intero o stringa in cui le cifre sopra vanno nell'ordine delle somme dei loro indici. Nel caso in cui più cifre generino la stessa somma, la cifra più piccola precede quella più grande:

047631

Infine, rimuovi eventuali zeri iniziali e restituisci o stampa il risultato:

47631

È necessario scrivere un programma o una funzione che restituisce o stampa l'input indicizzato.

Questo è code-golf , quindi vince il codice più breve in byte!

_{Altri casi di test possono essere aggiunti su richiesta.}

k, 7 byte

.<+/'=$

sostituzione online

  $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 giustapposizione di funzioni è composizione, quindi non è richiesto alcun parametro o input esplicito.

Haskell, 69 byte

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

Prende una stringa, restituisce un numero. Esempio di utilizzo: f "30043376111"-> 47631. Provalo online!

Abbastanza semplice: ordina prima le cifre della stringa di input sulla somma dei loro indici e la per la stessa cifra (-> coppie di (somma ..., d)), rimuovi i duplicati e converti in un numero per rimuovere il comando iniziale 0. Il 0+è necessario per ottenere i tipi destra.

Impilato , 59 byte

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

Provalo online!

Questo prende una stringa di caratteri (come $'1231231') come input dalla parte superiore della pila e lascia una stringa nella pila.

Spiegazione

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

Ora ci rimangono coppie di (chr, somma degli indici).

[-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 grazie a Riley

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

Provalo online!

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

Prende una stringa n, quindi la converte in un set e quindi in una matrice di cifre distinte. Ordina queste cifre in ordine numerico, quindi ordina nuovamente in base alle somme di indici. Concatena la matrice ordinata in una stringa e infine converte in un numero per rimuovere gli zeri iniziali.

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)

Provalo online!

Imposta una tabella hash vuota $a, quindi lancia l'input $argscome un chararray e scorre in sequenza ogni elemento |%{...}. Impostiamo il valore su "l'elemento corrente" di $acui incrementare $i++, per contare gli indici dei nostri input. Ad esempio, per l'input 300433766111, il primo loop $a[3]ottiene +=0; il ciclo successivo, $a[0]ottiene +=1; eccetera.

Successivamente, abbiamo bisogno della Sortnostra tabella hash. Sfortunatamente, a causa di una stranezza del linguaggio interno, ciò significa che è necessario $a.GetEnumerator()prima di poter effettuare l'ordinamento effettivo. Ordiniamo per value, quindi per name, per soddisfare il requisito di cifre più piccole vengono ordinate per prime. Tiriamo fuori .Namei suoi s (in ordine ordinato), -joininsieme in una stringa e lanciamo quella stringa come int +per rimuovere gli zeri iniziali. Rimane in cantiere e l'output è implicito.

Gelatina , 10 byte

Ġ’S$ÞịDFQḌ

Provalo online!

Prende e restituisce un numero intero.

Come?

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

Grazie a Ben Frankel per aver salvato 10 byte!

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

Provalo online!

Accetta input come stringa e genera un numero intero. Utilizza un dizionario per memorizzare la somma degli indici, quindi ordina per valore. Converte in un numero intero per eliminare gli zeri iniziali perché intè più corto di .lsplit('0').

Python 3.5, 86 85 byte

Grazie @Ben Frankel per aver salvato un byte:

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

Vecchio codice:

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

Funzione anonima che accetta una stringa di cifre e restituisce un numero intero

Pip , 18 byte

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

Prende il numero come argomento della riga di comando. Provalo online!

Spiegazione

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

Non contento di quanto tempo è finito e probabilmente può essere più breve, ma questo è quello che ho finito.

Perl 6 ,  65 61  52 byte

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

Provalo

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

Provalo

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

Provalo

allargato

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

Esempio (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

Abbastanza semplice, usando la tupla come predicato di ordinamento per l'ordinamento secondario.

Pyth, 9 byte

sosxNcQ1{

Provalo online

Accetta una stringa di cifre come input.

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.