Étant donné un nombre non négatif n, triez les chiffres de nleur première occurrence dans pi .

L'entrée peut être prise via l'argument de la fonction cli, ou STDIN et sous forme de chaîne, char [] ou entier. Vous pouvez sortir via la valeur de retour, l'état de sortie ou STDOUT.

Pyth, 8 6 octets

ox+.n0

Essayez-le ici.

-1 grâce à Leaky Nun : L'entrée fournira le 0si nécessaire.
Trivial -1 grâce à Jakube : Backtick pas nécessaire (ah, comment ai-je raté ça, COMMENT?!?).

Python 3 , 40 39 octets

1 octet merci à Jonathan Allan.

lambda s:sorted(s,key="145926870".find)

Essayez-le en ligne!

05AB1E , 10 9 7 octets

Enregistré 1 octet grâce à Leaky Nun notant que le filtrage des doublons n'est pas nécessaire.
Enregistré 2 octets grâce à Adnan .

žqRvy†J

Essayez-le en ligne!

Explication

žq       # push pi to 15 decimals (contains all digits but 0)
  R      # reverse
   vy    # for each char in pi
     †J  # move it's occurrences in the input to the front

Gelée , 10 octets

“ṀSṪw’ṾiµÞ

Essayez-le en ligne!

Prend l'entrée sous la forme d'une chaîne de chiffres.

-3 octets grâce à @ETHproductions

Explication

“ṀSṪw’ṾiµÞ
        µ  - Separate chain into function “ṀSṪw’Ṿi and sort atom Þ.
         Þ - Sort the input by
       i   - Each digit's index in: 
“ṀSṪw’     - the literal 3145926870 ...
      Ṿ    - transformed into the list 3,1,4,5,9,2,6,8,7,0

Japt , 10 9 octets

8 octets de code, +1 pour le -Pdrapeau.

–!bMP+U

Essayez-le en ligne! Prend l'entrée sous forme de chaîne.

Explication

–!bMP+'0  // Implicit input

¬          // Split the input into chars.
 ñ         // Sort each char in the resulting list by
  !b       //   its index in
    MP+U   //     Math.PI + the input.
-P         // Join the result back into a single string.
           // Implicit: output result of last expression

JavaScript (ES6), 54 octets

f=
s=>[...s].sort((a,b)=>k[a]-k[b],k=`9150236874`).join``

<input oninput=o.textContent=f(this.value)><pre id=o>

Utilise des chaînes pour les E / S.

Gelée ,  8  7 octets

-1 octet grâce à Dennis (utilisez tout existant 0dans l'entrée, intelligent.)

ØP;ṾiµÞ

Essayez-le en ligne!

Comment?

ØP;ṾiµÞ - Main link: string s (char list)
     µÞ - sort the characters, c, of s by:
    i   -   first index of c in:
ØP      -     pi yield: 3.141592653589793
  ;     -     concatenate with left: [3.141592653589793, c]
   Ṿ    -     un-evaluate: "3.141592653589793,c" (a char list with the digit character c)
                                if any c is 0 ^ it will then be to the right of all others

CJam , 15 12 10 8 octets

r{P`#c}$

Essayez-le en ligne!

-3: utilisez une chaîne basée sur la Pvariable pi au lieu d'un littéral.
-2: J'ai décidé que je n'avais pas besoin d'uniquifier du tout, car la recherche d'un index prend de toute façon la première occurrence. -2: Merci à jimmy23013 pour une approche intéressante en utilisant x mod 65536.

Explication:

r {P` # c} $ e # Prend un jeton d'entrée
re # Prenez l'entier comme une chaîne
 {P` # c} e # Clé de tri:
  P e # Push P (par défaut à 3,141592653589793)
   `e # Convertir en représentation sous forme de chaîne
    # e # Trouver l'index de char dans la chaîne que nous avons créée
         e # A '.' ne sera jamais trouvé dans un entier, mais cela n'a pas d'importance, car le décalage conserve le tri idéal.
         e # A '0' sera indexé comme -1.
     ce # Convertir l'index en char
         e # Cela calcule d'abord l'index% 65536, puis convertit en char. Nous en avons besoin car sinon 0 serait indexé comme -1, c'est-à-dire le plus petit indice.
         e # Nous n'avons pas besoin de reconvertir en entier, car nous pouvons utiliser le tri lexicographique.
       $ e # Trier avec la clé

PHP, 71 octets

La solution d'expression régulière est plus courte

for(;~$c=_3145926870[$i++];)echo str_repeat($c,substr_count($argn,$c));

ou

for(;~$c=_3145926870[$i++];)echo str_pad("",substr_count($argn,$c),$c);

Versions en ligne

PHP, 78 octets

for(;~$c=$argn[$i++];)$j[strpos("3145926870",$c)].=$c;ksort($j);echo join($j);

PHP, 112 octets

$a=str_split($argn);usort($a,function($x,$y){return strpos($d="3145926870",$x)<=>strpos($d,$y);});echo join($a);

Version en ligne

C, 103 97 octets

char*p="3145926870";s(*a,*b){return strchr(p,*a)-strchr(p,*b);}f(char*t){qsort(t,strlen(t),1,s);}

Essayez-le en ligne

Rubis, 50 octets

n=gets;"3145926870".each_char{|c|$><<c*n.count(c)}

MATL , 14 octets

YP99Y$uj!y=sY"

Essayez-le en ligne!

Explication avec un exemple

Le symbole ;est utilisé comme séparateur de lignes dans les matrices. Il en [1 2 3]va de même d'un vecteur ligne, d' [1; 2; 3]un vecteur colonne et d' [1 2; 3 4]une matrice carrée. Ces derniers peuvent également être représentés, par souci de clarté, comme

[1 2;
 3 4]

Considérez l'entrée 2325comme exemple.

YP     % Push approximation of pi as a double (predefined literal)
       % 3.14159265358979
99Y$   % Variable-precision arithmetic with 99 digits. Gives a string.
       % The input 3.14159265358979 is recognized as representing pi
       % STACK: '3.141592653589793238462 ··· 707'
u      % Unique entries, keeping order of their first appearance
       % STACK: '3.145926870'
j      % Input line as a string
       % STACK: '3.145926870', '2352'
!      % Transpose
       % STACK: '3.145926870', ['2'; '3';'5'; '2']
y      % Duplicate the second-top element in the stack
       % STACK: '3.145926870', ['2'; '3';'5'; '2'], '3.145926870'
=      % Test for equality, with broadcast. This gives a matrix with
       % all pairwise comparisons)
       % STACK: '3.145926870', [0 0 0 0 0 0 1 0 0 0 0;
       %                        1 0 0 0 0 0 0 0 0 0 0;
       %                        0 0 0 0 1 0 0 0 0 0 0;
       %                        0 0 0 0 0 0 1 0 0 0 0]
s      % Sum of each column
       % STACK: '3.145926870', [1 0 0 0 1 0 2 0 0 0 0]
Y"     % Run-length decoding. Implicitly display
       % STACK: '3522'

C (gcc) , 78 octets

f(char*s){for(char*d="3145926870",*p;*d;d++)for(p=s;*p;)*p++-*d||putchar(*d);}

Essayez-le en ligne!

C # Interactive, 37 36 octets

i.OrderBy(c=>"145926870".IndexOf(c))

En fait, vous devez exécuter cela dans le C # interactif pour de bons résultats, mais je suppose que c'est ce que vous vouliez dire avec le statut de sortie . La variable i est en fait la variable d'entrée (il peut s'agir par exemple d'une chaîne), il s'agit donc essentiellement du paramètre de méthode.

Je pense que le code lui-même est assez simple.

05AB1E , 5 6 octets (sans concurrence)

J'ai dû réaliser que ce 0n'est pas présent dans la constante pi de longueur standard.

Σтžsyk

Essayez-le en ligne!

Σтžsyk
Σ      Sort by the result of code
 тžs   Push 100 digits of pi
   yk  Index of digit in pi

PHP, 66 65 octets

Enregistré 1 octet grâce à Titus.

while(~$d=_3145926870[++$i])echo preg_filter("/[^$d]/",'',$argn);

Java 7, 110 octets

String c(String s){String r="";for(char i:"3145926870".toCharArray())r+=s.replaceAll("[^"+i+"]","");return r;}

Explication:

String c(String s){                       // Method with String parameter and String return-type
  String r="";                            //  Result String
  for(char i:"3145926870".toCharArray())  //  Loop over the characters of "3145926870"
    r+=s.replaceAll("[^"+i+"]","");       //   Append the result-String with all the occurrences of the current character
                                          //  End of loop (implicit / single-line body)
  return r;                               //  Return the result-String
}                                         // End of method

Code de test:

Essayez-le ici.

class M{
  static String c(String s){String r="";for(char i:"3145926870".toCharArray())r+=s.replaceAll("[^"+i+"]","");return r;}

  public static void main(String[] a){
    System.out.println(c("12345678908395817288391"));
  }
}

Production:

33311145599922688888770

Clojure, 38 octets

#(sort-by(zipmap"3145926870"(range))%)

Saisie en chaîne, renvoie une séquence de caractères. zipmapcrée un objet "dictionnaire", qui peut également être utilisé dans un contexte de fonction.

(f "1234")
(\3 \1 \4 \2)

S'il était garanti que les chiffres saisis soient uniques, vous pouvez simplement le faire #(filter(set %)"3145926870").

PHP, 69 68

for(;(~$d=$argn[$j++])||~$c=_3145926870[$i+++$j=0];)$c==$d&&print$d;

Toujours battu par preg_filter mais je pensais que c'était assez sympa en soi. Peut-être que quelqu'un peut jouer au golf sur quelques octets.

Perl 6 , 34 octets

*.comb.sort:{3145926870.index: $_}

Essayez-le

*\       # WhateverCode lambda (this is the parameter)
.comb    # split into digits
.sort: { # sort by

  3145926870.index: $_ # its index in this number
}

k, 19 octets

{x@<"3145926870"?x}

Explication:

{                 } /function(x)
    "3145926870"?x  /for each x: "3145926870".index(x)
   <                /get indices with which to sort
 x@                 /sort x by those indices