Étant donné une chaîne de chiffres ou un entier en entrée, vous devrez l'indexer.

C'est ainsi que vous modifiez l'entrée. Nous utiliserons 30043376111comme exemple:

Tout d'abord, trouvez la somme des indices de chaque occurrence des chiffres respectifs:

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

Ensuite, construisez un nouvel entier ou une nouvelle chaîne où les chiffres ci-dessus vont dans l'ordre des sommes de leurs indices. Dans le cas où plusieurs chiffres donnent la même somme, le plus petit chiffre précède le plus grand:

047631

Enfin, supprimez les zéros non significatifs et retournez ou imprimez le résultat:

47631

Vous devez écrire un programme ou une fonction qui renvoie ou imprime l'entrée indexée.

C'est du code-golf , donc le code le plus court en octets gagne!

_{D'autres cas de test peuvent être ajoutés sur demande.}

k, 7 octets

.<+/'=$

repl en ligne

  $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 juxtaposition des fonctions est la composition, donc aucun paramètre ou entrée explicite n'est requis.

Haskell, 69 octets

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

Prend une chaîne, renvoie un nombre. Exemple d'utilisation: f "30043376111"-> 47631. Essayez-le en ligne!

Assez simple: triez d'abord les chiffres de la chaîne d'entrée sur la somme de leurs indices et par le chiffre lui-même (-> paires de (somme ..., d)), supprimez les doublons et convertissez-les en un nombre pour supprimer l'interligne 0. Le 0+est nécessaire pour obtenir les bons types.

Empilé , 59 octets

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

Essayez-le en ligne!

Cela prend une chaîne de caractères (comme $'1231231') en entrée du haut de la pile et laisse une chaîne sur la pile.

Explication

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

Il nous reste maintenant des paires de (chr, somme des indices).

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

-1 merci à Riley

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

Essayez-le en ligne!

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 octets

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

Prend une chaîne n, puis la convertit en un ensemble, puis en un tableau de chiffres distincts. Trie ces chiffres dans l'ordre numérique, puis les trie à nouveau en fonction des sommes des indices. Concatène le tableau trié en chaîne et convertit finalement en nombre pour supprimer les zéros non significatifs.

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 octets

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

Essayez-le en ligne!

Définit une table de hachage vide $a, puis convertit l'entrée $argsen chartableau et parcourt chaque élément |%{...}. Nous fixons la valeur à "l'élément courant" $apour être incrémenté de $i++, pour compter les indices de nos entrées. Par exemple, pour l'entrée 300433766111, la première boucle $a[3]obtient +=0; la boucle suivante, $a[0]obtient +=1; etc.

Ensuite, nous avons besoin de Sortnotre table de hachage. Malheureusement, en raison d'une bizarrerie du langage interne, cela signifie que nous devons le faire $a.GetEnumerator()avant de pouvoir effectuer le tri réel. Nous trions par value, puis par name, pour satisfaire l'exigence de chiffres plus petits, trions d'abord. Nous retirons les .Names de ceux-ci (dans l'ordre trié), -joinles ensemble dans une chaîne, et castons cette chaîne comme un entier +pour supprimer les zéros de tête. Cela reste sur le pipeline et la sortie est implicite.

Gelée , 10 octets

Ġ’S$ÞịDFQḌ

Essayez-le en ligne!

Prend et retourne un entier.

Comment?

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

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 octets

Merci à Ben Frankel d'avoir économisé 10 octets!

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

Essayez-le en ligne!

Prend l'entrée sous forme de chaîne et génère un entier. Utilise un dictionnaire pour stocker la somme des index, puis la trie par valeur. Convertit en entier pour supprimer les zéros non significatifs car il intest plus court que .lsplit('0').

Python 3.5, 86 85 octets

Merci @Ben Frankel d'avoir enregistré un octet:

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

Ancien code:

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

Fonction anonyme prenant une chaîne de chiffres et renvoyant un entier

Pip , 18 octets

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

Prend le nombre comme argument de ligne de commande. Essayez-le en ligne!

Explication

                    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 octets

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

Pas content de combien de temps cela a fini par être et ça peut probablement être plus court mais c'est ce que j'ai fini avec.

Perl 6 ,  65 61  52 octets

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

Essayez-le

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

Essayez-le

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

Essayez-le

Étendu

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

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

Exemple (avec 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

Assez simple, en utilisant le tuple comme prédicat de tri pour le tri secondaire.

Pyth, 9 octets

sosxNcQ1{

Essayez-le en ligne

Prend une chaîne de chiffres comme entrée.

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.