Dado un número no negativo n, clasifique los dígitos npor su primera aparición en pi .

La entrada puede tomarse a través de la función argumento de cli, o STDIN y como una cadena, char [] o entero. Puede enviar a través del valor de retorno, el estado de salida o STDOUT.

Pyth, 8 6 bytes

ox+.n0

Pruébalo aquí

-1 gracias a Leaky Nun : la entrada proporcionará 0si alguna vez se necesita.
Trivial -1 gracias a Jakube : Backtick no es necesario (ah, ¿cómo me perdí eso, ¿CÓMO?!?).

Python 3 , 40 39 bytes

1 byte gracias a Jonathan Allan.

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

Pruébalo en línea!

05AB1E , 10 9 7 bytes

Se guardó 1 byte gracias a Leaky Nun y señaló que no es necesario filtrar los duplicados.
Guardado 2 bytes gracias a Adnan .

žqRvy†J

Pruébalo en línea!

Explicación

ž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

Jalea , 10 bytes

“ṀSṪw’ṾiµÞ

Pruébalo en línea!

Toma la entrada como una cadena de dígitos.

-3 bytes gracias a @ETHproductions

Explicación

“Ṁ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 bytes

8 bytes de código, +1 para la -Pbandera.

–!bMP+U

Pruébalo en línea! Toma la entrada como una cadena.

Explicación

–!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 bytes

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

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

Utiliza cadenas para E / S.

Jalea ,  8  7 bytes

-1 byte gracias a Dennis (use cualquiera existente 0en la entrada, inteligente).

ØP;ṾiµÞ

Pruébalo en línea!

¿Cómo?

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

r{P`#c}$

Pruébalo en línea!

-3: Use una cadena basada en la Pvariable pi en lugar de un literal.
-2: Decidí que no necesito uniquificar en absoluto, ya que encontrar un índice toma la primera aparición de todos modos. -2: Gracias a jimmy23013 por un enfoque interesante usando x mod 65536.

Explicación:

r {P` # c} $ e # Toma un token de entrada
re # Toma el entero como una cadena
 {P` # c} e # Clave de clasificación:
  P e # Push P (el valor predeterminado es 3.141592653589793)
   `e # Convertir a representación de cadena
    # e # Encuentra el índice de char en la cadena que hicimos
         e # A '.' nunca se encontrará en un número entero, pero no importa, ya que el desplazamiento conserva la clasificación ideal.
         e # A '0' se indexará como -1.
     ce # Convertir índice a char
         e # Esto primero calcula el índice% 65536 y luego se convierte en char. Necesitamos esto porque de lo contrario 0 se indexaría como -1, es decir, el índice más pequeño.
         e # No necesitamos convertir de nuevo a entero, ya que podemos usar la clasificación lexicográfica.
       $ e # Ordenar con clave

PHP, 71 bytes

La solución regex es más corta

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

o

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

Versiones en linea

PHP, 78 bytes

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

PHP, 112 bytes

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

Versión en línea

C, 103 97 bytes

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

Pruébalo en línea

Ruby, 50 bytes.

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

MATL , 14 bytes

YP99Y$uj!y=sY"

Pruébalo en línea!

Explicación con un ejemplo

El símbolo ;se utiliza como separador de filas en matrices. Entonces, [1 2 3]es un vector de fila, [1; 2; 3]es un vector de columna y [1 2; 3 4]es una matriz cuadrada. Este último también se puede representar, para mayor claridad, como

[1 2;
 3 4]

Considere la entrada 2325como un ejemplo.

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 bytes

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

Pruébalo en línea!

C # interactivo, 37 36 bytes

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

En realidad, debe ejecutar esto en C # interactivo para obtener resultados adecuados, pero supongo que esto es lo que quiso decir con el estado de salida . La variable i realidad es la variable de entrada (puede ser, por ejemplo, una cadena), por lo que es básicamente el parámetro del método.

Creo que el código en sí es bastante sencillo.

05AB1E , 5 6 bytes (sin competencia)

Tenía que darse cuenta de que 0no está presente en la constante de longitud estándar pi.

Σтžsyk

Pruébalo en línea!

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

PHP, 66 65 bytes

Guardado 1 byte gracias a Titus.

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

Java 7, 110 bytes

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

Explicación:

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

Código de prueba:

Pruébalo aquí

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

Salida:

33311145599922688888770

Clojure, 38 bytes

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

Entrada en cadena, devuelve una secuencia de caracteres. zipmapcrea un objeto "diccionario", que también se puede utilizar en un contexto de función.

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

Si se garantiza que los dígitos de entrada sean únicos, entonces simplemente podría hacerlo #(filter(set %)"3145926870").

PHP, 69 68

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

Todavía golpeado por preg_filter pero pensé que era bastante bueno en sí mismo. Quizás alguien pueda jugar algunos bytes.

Perl 6 , 34 bytes

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

Intentalo

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

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

k, 19 bytes

{x@<"3145926870"?x}

Explicación:

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