Dada uma sequência x, produza os caracteres xclassificados de acordo com a ordem de aparência no seu código-fonte.

Exemplos

Source: ThisIs A Test
 Input: Is it a Test?
Output: TissI   etta?

Source: Harry - yer a wizard.
 Input: I'm a what?
Output: aa  wh'?Imt

Source: Mr. H. Potter, The Floor, Hut-on-the-Rock, The Sea
 Input: 
Output:

Regras

• Aplicam-se brechas padrão e regras de E / S
• Entrada e saída podem ser uma sequência, uma lista de caracteres ou uma lista de bytes.
• Se um caractere for usado várias vezes na fonte, use a primeira ocorrência.
• Se um ou mais caracteres não aparecer na fonte, eles deverão estar no final; sua ordem não importa, nem precisa ser consistente.
• A origem não deve estar vazia
• Novas linhas são tratadas da mesma forma que outros caracteres.
• A ordem na qual o código é executado não importa; apenas a sequência crua.
• A entrada está na mesma codificação que o código.
• A entrada é classificada por caracteres, não por bytes.
• A classificação diferencia maiúsculas de minúsculas
• Isso é código-golfe , então a resposta mais curta em bytes para cada idioma vence!

let f = (s, i, o) => o.split("").map(x => [x, s.indexOf(x) == -1 ? s.length + 100 : s.indexOf(x)]).sort(([, a], [, b]) => a - b).map(([x]) => x).join("") === o && i.split("").sort().join("") === o.split("").sort().join("");let g = (s, i) => i.split("").map(x => [x, s.indexOf(x) == -1 ? s.length + 100 + Math.random() : s.indexOf(x)]).sort(([, a], [, b]) => a - b).map(([a]) => a).join("");$(() => $("button").click(() => $("#result").text(f($("#source").val(), $("#input").val(), $("#output").val()) ? "Valid" : `Invalid; example output: \`${g($("#source").val(), $("#input").val())}\``)));

body,label{display: flex;flex-direction: column;}*{white-space: pre;font-family: Inconsolata, Consolas, mono-space;font-size: 14px;}

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script><label>Source: <textarea id="source">ThisIs A Test</textarea></label><label>Input: <textarea id="input">Is it a Test?</textarea></label><label>Output: <textarea id="output">TissI   etta?</textarea></label><div><button>Validate</button> <span id="result"></span></div>

Python 3.8 (pré-lançamento) , 102 100 96 85 79 76 68 61 59 60 bytes

c="print(sorted(x:=input(),key=('c=%r;'%c+x).find))";exec(c)

Experimente online!

-2 bytes usando este

-4 bytes, percebendo que <0== ==-1e removendo o desnecessário+1

-11 bytes graças a Neil

-6 bytes graças a dzaima

-3 bytes graças ao rod

-8 bytes graças a sete negativos, indicando que o programa pode gerar uma lista de caracteres

-7 bytes devido à incorporação da ignorância voltando ao Python 3.8 e usando :=

-2 bytes devido a Jo King mudar o nome da variável s para c, para que possamos deixar de fora o ;c

+1 bytes porque sete negativos indicaram que não estava filtrando ;corretamente

APL (Dyalog Unicode) , ^{SBCS de} 14 bytes

Função de prefixo tácito anônimo.

'''∘⍋⊃¨⊂'∘⍋⊃¨⊂

⊂ inclua argumento (para agir sobre ele como um todo)

… A ⊃¨ partir disso, escolha um caractere para cada um dos seguintes índices:

∘⍋ os índices que classificariam o argumento na ordem dada pela seguinte sequência (todos os não membros terão a ordem de aparência no final):

'''∘⍋⊃¨⊂' os personagens '∘⍋⊃¨⊂

Experimente online!

C # (compilador interativo do Visual C #) , 48 bytes

n=>n.OrderBy((@"n=>.OrdeBy(@""+)Ixf"+n).IndexOf)

Experimente online!

JavaScript (Node.js) , 60 58 56 bytes

-2 bytes de Jo King

f=_=>_.sort((a,b)=>(p=g=>`f=${f+g}`.indexOf(g))(a)-p(b))

Experimente online!

Perl 6 , 56 bytes

<slurp.comb.sort({"<$_>~EVAL$^a".index($a)}).say>~~.EVAL

Experimente online!

Ruby , 57 bytes

->s{s.sort_by{|o|%{->s{.ort_by|%}index()9}.index(o)||99}}

Experimente online!

Bastante direto, supondo que eu não tenha perdido um truque de golfe. Pegue uma lista de caracteres e classifique por seu índice em uma sequência que consiste em todos os caracteres uniq no código em ordem de aparência. Muitas vezes, sua primeira aparição é nessa mesma sequência, mas isso não muda a ordem.

05AB1E , 24 22 21 bytes

Σ"Σ"'"«"'«Rrk}"«Rrk}R

Experimente online!

Explicação:

Σ                    }               # Sort
 "Σ"                                 # Σ string literal
    '"                               # " string literal
       «                             # Concatenate last two literals
        "'«Rrk}"                     # '«Rrk} another literal
                «                    # Concat again
                 R                   # Reverse literal (so: }krR'«'"Σ)
                  r                  # reverse stack 
                   k                 # find the current sorting index in our code string 
                     R               # reverse our sorted string

Primeira tentativa de coisas no 05AB1E, provavelmente muito a ser salvo

Jelly , 16 14 bytes (página Jelly Code), 25 bytes (UTF8)

“Ṿv`Ṿ;³³i@Þ”v`

Experimente online!

Um programa completo que utiliza um único argumento, a sequência a ser classificada.

Obrigado a @ JonathanAllan por apontar um bug!

Conforme @EriktheOutgolfer, embora o código possa ser inserido usando a página de código Jelly, os caracteres classificados são os UTF-8 equivalentes, em vez dos bytes da fonte. Como tal, incluí a pontuação nos bytes UTF-8 também. Observe que o mesmo provavelmente se aplica a todos os idiomas com páginas de códigos personalizadas.

Explicação

“Ṿv`Ṿ;³³i@Þ”   | The string "Ṿv`Ṿ;³³i@Þ", referred to below as S
            v` | Evaluate this string as Jelly code using the string itself as the argument

A string acima é avaliada como:

Ṿ          | Uneval the string S (effectively wraps it in “”)
 v`        | Eval it (effectively removes the “”)
   Ṿ       | Uneval it again, adding back in the “”
    ;³     | Concatenate the input to this
      ³i@Þ | Sort the input with respect to the first occurence of each character in the “”-wrapped string S concatenated to the input

Ṿv` é um no-op efetivamente aqui, mas existe para garantir que todos os caracteres sejam representados.

Gelatina , 14 bytes

“;fɓḟṾⱮ”ṾɓfⱮ;ḟ

Um programa completo que aceita uma string (formatada em Python) (de caracteres da página de código Jelly ) que imprime a saída.
(como um link monádico, ele gera uma lista de listas de caracteres)

Experimente online!

Quão?

“;fɓḟṾⱮ”ṾɓfⱮ;ḟ - Main Link: list of characters, S
“;fɓḟṾⱮ”       - list of characters = [';', 'f', 'ɓ', 'ḟ', 'Ṿ', 'Ɱ']
        Ṿ      - un-evaluate = ['“', ';', 'f', 'ɓ', 'ḟ', 'Ṿ', 'Ɱ', '”']
         ɓ     - start a new dyadic chain, F(S, T=that):
           Ɱ   - for each character, t, in T:
          f    -   (S) filter keep any of (the single character, t)
             ḟ - (S) filter discard any of (the characters in T)
            ;  - concatenate

Carvão , 37 bytes

≔´≔´´´η´Ｆ´Φ´θ´⁼´ι´κ´¬´№ηＦηΦθ⁼ικΦθ¬№ηι

Experimente online! Explicação:

≔´≔´´´η´Ｆ´Φ´θ´⁼´ι´κ´¬´№η

Existem duas maneiras de citar caracteres no Charcoal; ´cita qualquer caractere único enquanto ”y... ”cita qualquer caractere, exceto ”e também conta como uma sequência separada. Acontece que a sobrecarga em ter que lidar com ”isso significa que ele não acaba com nenhum golfista.

ＦηΦθ⁼ικ

Faça um loop sobre os caracteres por vez, produzindo quaisquer caracteres correspondentes da entrada Isso classifica a entrada.

Φθ¬№ηι

Saída quaisquer caracteres não correspondentes na entrada.

J , 14 bytes

Função de prefixo tácito anônimo.

]/:']/:''i'i:]

Experimente online!

] o argumento

… i: Última ocorrência (não membros obtêm o índice além do final da cadeia de pesquisa) de cada caractere em:

']/:''i' os personagens ]/:'i

... /: use isso para classificar:

] o argumento

Java 10, 129 100 bytes

s->{s.sort(java.util.Comparator.comparing(c->("s->{.ort(javuilCmpcng\"\\+)dexOf;}"+c).indexOf(c)));}

-29 bytes, portando a resposta C #+c de @EmbodimentOfIgnorance .

Experimente online.

Explicação:

s->{                 // Method with char-List parameter and no return-type
  s.sort(java.util.Comparator.comparing(c->
    ("s->{.ort(javuilCmpcng\"\\+)dexOf;}"
                     //  Push a String containing the characters in the code
     +c)             //  Append the current character
        .indexOf(c)  //  And get the first index of the current character in the String

NOTA: Geralmente, é mais barato usar em s.sort((a,b)->Long.compare(a,b))vez de s.sort(java.util.Comparator.comparing(c->c), mas nesse caso seria 11 bytes a mais:

s->{var v="s->{var =\"\\;.ot(,)Lngcmpe+idxOf}";s.sort((a,r)->Long.compare((v+a).indexOf(a),(v+r).indexOf(r)));}

Experimente online.

05AB1E , 31 26 19 bytes

Σ'"'ÿs"Σ'ÿÿsìyk"ìyk

-7 bytes, inspirando- se na abordagem de @ EmbodimentOfIgnorance em sua resposta em C # de anexar o caractere atual antes da indexação.

Experimente online ou tente com a linha de depuração adicionada para ver as strings que estão sendo indexadas .

Explicação:

Σ                 # Sort the (implicit) input-string by:
 '"              '#  Push string '"'
   'ÿ            '#  Push string "ÿ"
     s            #  Swap the order of these two strings on the stack
      "Σ'ÿÿsìyk"  #  Push string "Σ'ÿÿsìyk", where the `ÿ` are automatically filled with
                  #  the previous strings we created: `Σ'"ÿsìyk`
                  #  (top to bottom from stack; left to right in string)
       ì          #  Prepend this string in front of the character we're sorting
        yk        #  And then get the index of the character we're sorting in this string
                  # (after the sorting the resulting string is output implicitly)

PowerShell , 68 bytes

$p=$args
&($t={$p|sort-object{"`$p=`$args
&(`$t={$t})$_"|% i*f $_}})

Experimente online!

Python 2 , 62 bytes

lambda a:sorted(a,key=('lambd :sorted(,ky=\'\\+).fin'+a).find)

Mesmo conceito que minha resposta em C #.

Experimente online!

Japonês , 18 bytes

ñÈi"ñÈi\"\\ bX" bX

Tente

ñÈi"ñÈi\"\\ bX" bX     :Implicit input of string or character array
ñ                      :Sort by
 È                     :Passing each X through the following function
  i                    :  Prepend X with
   "ñÈi\"\\ bX"        :    Literal string (The \s are annoying me!)
                bX     :  First index of X

Gelatina , 26 bytes (UTF-8 *)

“®³nÞṾ©V”Ṿ©VV

Experimente online!

Recebe entrada como uma string formatada em Python no 1º argumento da linha de comando.

Caracteres únicos :

“®³nÞṾ©V”

* Nota: Descobri que isso não funciona quando codificado em JELLY, pois classifica os caracteres UTF-8 em vez de seus próprios bytes.