Dado um número não negativo n, classifique os dígitos npela primeira ocorrência em pi .

A entrada pode ser obtida via argumento da função cli ou STDIN e como uma string, char [] ou inteiro. Você pode enviar via valor de retorno, status de saída ou STDOUT.

Pitão, 8 6 bytes

ox+.n0

Experimente aqui.

-1 graças a Leaky Nun : A entrada fornecerá o 0que for necessário.
Trivial -1 graças a Jakube : Backtick não é necessário (ah, como eu perdi isso, COMO?!?).

Python 3 , 40 39 bytes

1 byte graças a Jonathan Allan.

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

Experimente online!

05AB1E , 10 9 7 bytes

Economizou 1 byte graças a Leaky Nun, observando que não é necessário filtrar duplicatas.
Economizou 2 bytes graças a Adnan .

žqRvy†J

Experimente online!

Explicação

ž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

Gelatina , 10 bytes

“ṀSṪw’ṾiµÞ

Experimente online!

Recebe a entrada como uma sequência de dígitos.

-3 bytes graças a @ETHproductions

Explicação

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

Japonês , 10 9 bytes

8 bytes de código, +1 para o -Psinalizador.

–!bMP+U

Experimente online! Recebe a entrada como uma sequência.

Explicação

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

Usa cadeias de caracteres para E / S.

Geléia ,  8  7 bytes

-1 byte graças a Dennis (use qualquer um existente 0na entrada, inteligente.)

ØP;ṾiµÞ

Experimente online!

Quão?

Ø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}$

Experimente online!

-3: use uma cadeia de caracteres baseada na Pvariável pi em vez de em um literal.
-2: Decidi que não preciso unificar, pois encontrar um índice leva a primeira ocorrência de qualquer maneira. -2: Obrigado a jimmy23013 por uma abordagem interessante usando o x mod 65536.

Explicação:

r {P` # c} $ e # Toma um token de entrada
re # Pegue o número inteiro como uma string
 {P` # c} e # Chave de classificação:
  P e # Push P (o padrão é 3.141592653589793)
   `e # Converter em representação de string
    # e # Encontre o índice de char na string que criamos
         e # A '.' nunca será encontrado em um número inteiro, mas isso não importa, pois a mudança preserva a classificação ideal.
         e # A '0' será indexado como -1.
     ce # Converter índice em char
         e # Primeiro calcula o índice% 65536 e depois converte em char. Precisamos disso porque, caso contrário, 0 seria indexado como -1, ou seja, o menor índice.
         e # Não precisamos converter de volta para número inteiro, pois podemos usar a classificação lexicográfica.
       $ e # Classificar com chave

PHP, 71 bytes

A solução regex é mais curta

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

Versões Online

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

Versão Online

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

Experimente online

Ruby, 50 bytes

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

MATL , 14 bytes

YP99Y$uj!y=sY"

Experimente online!

Explicação com um exemplo

O símbolo ;é usado como separador de linhas em matrizes. Assim, [1 2 3]é um vetor de linha, [1; 2; 3]é um vetor de coluna e [1 2; 3 4]é uma matriz quadrada. Este último também pode ser representado, para maior clareza, como

[1 2;
 3 4]

Considere a entrada 2325como um exemplo.

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

Experimente online!

C # interativo, 37 36 bytes

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

Na verdade, você deve executar isso no C # interativo para obter resultados adequados, mas acho que foi isso que você quis dizer com status de saída . A variável i é realmente a variável de entrada (pode ser, por exemplo, uma string), então é basicamente o parâmetro method.

Eu acho que o código em si é bastante direto.

05AB1E , 5 6 bytes (não competitivo)

Tinha que perceber que 0não está presente no comprimento padrão pi constante.

Σтžsyk

Experimente online!

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

PHP, 66 65 bytes

Guardou 1 byte graças 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;}

Explicação:

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 do teste:

Experimente aqui.

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

Resultado:

33311145599922688888770

Clojure, 38 bytes

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

Entrada em string, retorna uma sequência de caracteres. zipmapcria um objeto "dicionário", que também pode ser usado em um contexto de função.

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

Se os dígitos de entrada foram garantidos como únicos, você poderia simplesmente fazer #(filter(set %)"3145926870").

PHP, 69 68

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

Ainda derrotado por preg_filter, mas eu pensei que era bastante agradável. Talvez alguém possa jogar fora alguns bytes.

Perl 6 , 34 bytes

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

Tente

*\       # 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}

Explicação:

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