Dada una cadena x, muestre los caracteres xordenados según el orden de aparición en su código fuente.

Ejemplos

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:

Reglas

• Se aplican las lagunas estándar y las reglas de E / S
• La entrada y salida puede ser una cadena, una lista de caracteres o una lista de bytes.
• Si un personaje se usa varias veces en la fuente, use la primera aparición.
• Si uno o más caracteres no aparecen en la fuente, deberían estar al final; su orden no importa, ni tiene que ser consistente.
• La fuente no debe estar vacía
• Las líneas nuevas se tratan igual que otros caracteres.
• El orden en que se ejecuta el código no importa; solo la cuerda cruda.
• La entrada está en la misma codificación que el código.
• La entrada se ordena por caracteres, no por bytes.
• La clasificación distingue entre mayúsculas y minúsculas
• Este es el código de golf , por lo que gana la respuesta más corta en bytes para cada idioma.

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 (pre-release) , 102 100 96 85 79 76 68 61 59 60 bytes

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

Pruébalo en línea!

-2 bytes al usar esto

-4 bytes al darse cuenta de que <0== ==-1y eliminar lo innecesario+1

-11 bytes gracias a Neil

-6 bytes gracias a dzaima

-3 bytes gracias a la barra

-8 bytes gracias a siete negativos que señalan que el programa puede generar una lista de caracteres

-7 bytes debido a la Realización de la Ignorancia al volver a Python 3.8 y usar :=

-2 bytes debido a que Jo King cambió el nombre de la variable s por c, por lo que podríamos omitir el ;c

+1 bytes porque siete negativos señalaron que no se estaba filtrando ;correctamente

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

Función de prefijo tácito anónimo.

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

⊂ adjuntar argumento (para actuar en su conjunto)

...⊃¨  de eso, elige un personaje para cada uno de los siguientes índices:

∘⍋ los índices que ordenarían el argumento en el orden dado por la siguiente cadena (todos los no miembros van en orden de aparición al final):

'''∘⍋⊃¨⊂' los caracteres '∘⍋⊃¨⊂

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 48 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Perl 6 , 56 bytes

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

Pruébalo en línea!

Ruby , 57 bytes

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

Pruébalo en línea!

Bastante sencillo, suponiendo que no me haya perdido un truco de golf. Tome una lista de caracteres y ordénelos por su índice en una cadena que contenga todos los caracteres uniq en el código en orden de aparición. A menudo, su primera aparición es en esa misma cadena, pero eso no cambia el orden.

05AB1E , 24 22 21 bytes

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

Pruébalo en línea!

Explicación:

Σ                    }               # 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

Primera vez que intenta cosas en 05AB1E, así que probablemente haya mucho que guardar

Jelly , 16 14 bytes (página de códigos Jelly), 25 bytes (UTF8)

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

Pruébalo en línea!

Un programa completo que toma un solo argumento, la cadena que se ordenará.

¡Gracias a @JonathanAllan por señalar un error!

Según @EriktheOutgolfer, aunque el código se puede ingresar utilizando la página de códigos Jelly, los caracteres ordenados son los UTF-8 equivalentes en lugar de los bytes de la fuente. Como tal, también he incluido la puntuación en bytes UTF-8. Tenga en cuenta que lo mismo probablemente se aplica a todos los idiomas con páginas de códigos personalizados.

Explicación

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

La cadena anterior se evalúa 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` es un no-op efectivamente aquí, pero existe para garantizar que todos los personajes estén representados.

Jalea , 14 bytes

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

Un programa completo que acepta una cadena (formateada en Python) (de caracteres de página de códigos Jelly ) que imprime la salida.
(como enlace monádico produce una lista de listas de caracteres)

Pruébalo en línea!

¿Cómo?

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

Carbón , 37 bytes

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

Pruébalo en línea!Explicación:

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

Hay dos formas de citar personajes en Carbón; ´cita cualquier carácter individual mientras que ”y... ”cita cualquier carácter excepto ”y también cuenta como una cadena separada. Resulta que la sobrecarga en tener que lidiar con” significa que no termina ningún golfista.

ＦηΦθ⁼ικ

Pase el cursor sobre los caracteres a su vez, generando los caracteres coincidentes de la entrada. Esto ordena la entrada.

Φθ¬№ηι

Salida de caracteres no coincidentes en la entrada.

J , 14 bytes

Función de prefijo tácito anónimo.

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

Pruébalo en línea!

] el argumento

...i:  última aparición (los no miembros obtienen el índice más allá del final de la cadena de búsqueda) de cada carácter en:

']/:''i' los caracteres ]/:'i

.../:  usa eso para ordenar:

] el argumento

Java 10, 129100 bytes

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

-29 bytes al portar la respuesta C #+c de @EmbodimentOfIgnorance .

Pruébalo en línea.

Explicación:

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: Por lo general, es más barato de usar en s.sort((a,b)->Long.compare(a,b))lugar de s.sort(java.util.Comparator.comparing(c->c), pero en este caso sería 11 bytes más largo:

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

Pruébalo en línea.

05AB1E , 31 26 19 bytes

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

-7 bytes inspirándose en el enfoque de @ EmbodimentOfIgnorance en su respuesta C # de agregar el carácter actual antes de la indexación.

Pruébelo en línea o con la línea de depuración agregada para ver las cadenas que se están indexando .

Explicación:

Σ                 # 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)

Potencia Shell , 68 bytes

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

Pruébalo en línea!

Python 2 , 62 bytes

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

El mismo concepto que mi respuesta C #.

Pruébalo en línea!

Japt , 18 bytes

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

Intentalo

ñÈ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

Pruébalo en línea!

Toma datos como una cadena con formato Python en el primer argumento de la línea de comandos.

Personajes únicos :

“®³nÞṾ©V”

* Nota: descubrí que esto no funciona cuando se codifica en JELLY, ya que ordena los caracteres UTF-8 en lugar de sus propios bytes.