Data una stringa x, emetti i caratteri in xordine secondo l'ordine di apparizione nel tuo codice sorgente.

Esempi

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:

Regole

Si applicano scappatoie standard e regole di I / O
L'input e l'output possono essere una stringa, un elenco di caratteri o un elenco di byte.
Se un personaggio viene usato più volte nella fonte, usa la prima occorrenza.
Se uno o più personaggi non compaiono nella fonte, dovrebbero essere alla fine; il loro ordine non ha importanza, né deve essere coerente.
L'origine deve essere non vuota
Le newline sono trattate come gli altri personaggi.
L'ordine in cui viene eseguito il codice non ha importanza; solo la stringa grezza.
L'input ha la stessa codifica del codice.
L'input è ordinato per caratteri, non per byte.
L'ordinamento fa distinzione tra maiuscole e minuscole
Questo è code-golf , quindi vince la risposta più breve in byte per ogni lingua!

Mostra snippet di codice

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>

Expand snippet

code-golf quine sorting

— tjjfvi
fonte

2

@negativeseven È necessario tenere conto di tutti i caratteri della codifica del codice sorgente, incluso lo spazio bianco.

— tjjfvi,

2

correlati

— Rod

3

Probabilmente dovresti fare esplicito riferimento nelle specifiche che la corrispondenza fa distinzione tra maiuscole e minuscole.

— Shaggy,

1

Possiamo essere xcodificati in UTF-8 o UTF-16 se la nostra soluzione non è affatto codificata in Unicode e i caratteri Unicode in xrappresentano i caratteri nella tabella codici della soluzione? Ad esempio, alcuni linguaggi del golf utilizzano tabelle codici personalizzate per ridurre il numero di byte ma essere comunque leggibili a occhio nudo.

— Erik the Outgolfer,

1

@tjjfvi Non sto parlando di no-ops qui (che sarebbe certamente non valido); almeno alcune delle risposte di seguito, invece di prendere l'input in byte semplici (0x00-0xFF), prendono l'input come stringa UTF-8 che la sequenza di byte rappresenterebbe (ad esempio quando pubblichiamo una risposta, di solito pubblichiamo l'UTF -8 versione del nostro codice, non hexdump), quindi utilizzare la rappresentazione UTF-8 del codice sorgente per ordinare l'input. È permesso? Sento che dovrebbe essere anche un'opzione (insieme al semplice flusso di byte), perché altrimenti le soluzioni nei linguaggi del golf con tabelle di codici personalizzate sarebbero ostacolate notevolmente.

— Erik the Outgolfer,

13

Python 3.8 (pre-release) , 102 100 96 85 79 76 68 61 59 60 byte

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

Provalo online!

-2 byte usando questo

-4 byte realizzando che <0== ==-1e rimuovendo il superfluo+1

-11 byte grazie a Neil

-6 byte grazie a dzaima

-3 byte grazie allo stelo

-8 byte grazie ai sette negativi che sottolineano che il programma può generare un elenco di caratteri

-7 byte a causa della realizzazione dell'ignoranza che ritorna a Python 3.8 e utilizza :=

-2 byte a causa di Jo King che cambia il nome della variabile s per c, quindi potremmo tralasciare il ;c

+1 byte perché sette negativi hanno indicato che non stava filtrando ;correttamente

— MilkyWay90
fonte

('s=%r;exec(s)'%s+x).find(x)?

— Neil,

@Neil La soluzione corrente non è valida e la sostituzione ('s=%r;exec(s)'%s).find(x)con il codice la renderebbe valida?

— MilkyWay90

@Neil Oh, aspetta, vedo il tuo golf

— MilkyWay90,

È possibile passare a input()e salvare 4 byte

— Rod

4

;non viene ordinato correttamente nella versione corrente

— negativo sette

7

APL (Dyalog Unicode) , ^{SBCS da} 14 byte

Funzione prefisso tacito anonimo.

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

⊂ allegare argomento (per agire su di esso nel suo insieme)

... ⊃¨ da questo, scegli un carattere per ciascuno dei seguenti indici:

∘⍋ gli indici che ordinerebbero l'argomento nell'ordine dato dalla seguente stringa (tutti i non membri vanno in ordine di apparizione alla fine):

'''∘⍋⊃¨⊂' i personaggi '∘⍋⊃¨⊂

Provalo online!

— Adamo
fonte

6

C # (compilatore interattivo Visual C #) , 48 byte

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

Provalo online!

— Incarnazione dell'ignoranza
fonte

5

JavaScript (Node.js) , 60 58 56 byte

-2 byte da Jo King

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

Provalo online!

— Luis Felipe De Jesus Munoz
fonte

Il tuo codice sembra funzionare solo quando la fonte è f=.... In tal caso, si prega di includerlo nella richiesta e nel conteggio dei byte.

— tjjfvi,

4

Perl 6 , 56 byte

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

Provalo online!

— Jo King
fonte

3

Rubino , 57 byte

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

Provalo online!

Abbastanza semplice, supponendo che non abbia perso un trucco da golf. Prendi un elenco di caratteri e ordina in base al loro indice in una stringa composta da tutti i caratteri uniq nel codice in ordine di aspetto. Spesso la loro prima apparizione è in quella stessa stringa, ma ciò non cambia l'ordine.

— histocrat
fonte

3

05AB1E , 24 22 21 byte

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

Provalo online!

Spiegazione:

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

La prima volta che provo cose in 05AB1E quindi probabilmente molto da salvare

— Dati scaduti
fonte

Sei sicuro che sia corretto? La stringa su cui ora ordina è }krR«'«. NOTA: 'è un singolo carattere, quindi '"è sufficiente (a differenza di C # dove ha bisogno di un trascinamento aggiuntivo '). Attualmente il tuo codice spinge prima la stringa Σ, quindi la stringa ", quindi la stringa «, quindi la stringa '«Rrk}e quindi esegue append, reverse, reverse stack, index. Uso intelligente del retro della stringa e alla fine, però! Vedrò se riesco a trovare una soluzione per la tua risposta e cancellerò la mia in seguito.

— Kevin Cruijssen

@kevincruijssen Quindi non posso proprio liberarmi del secondo '

— Data scaduta

1

Sì, puoi davvero. :) Quindi si ordina correttamente }krR«'"Σ. PS: A volte tendo a utilizzare =(stampa senza popping) per scopi di debug. Puoi anche aggiungere --debug-stackcome argomento, ma è un po 'strano nella nuova versione 05AB1E imho.

— Kevin Cruijssen,

3

Jelly , 16 14 byte (Jelly Code page), 25 byte (UTF8)

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

Provalo online!

Un programma completo che accetta un singolo argomento, la stringa da ordinare.

Grazie a @JonathanAllan per aver segnalato un bug!

Come per @EriktheOutgolfer, sebbene il codice possa essere inserito usando la code page Jelly, i caratteri ordinati sono quelli UTF-8 equivalenti piuttosto che i byte della sorgente. Come tale, ho incluso il punteggio anche nei byte UTF-8. Si noti che lo stesso vale probabilmente per tutte le lingue con codepage personalizzate.

Spiegazione

“Ṿ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 stringa sopra valuta come:

Ṿ          | 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` è una no-op efficace qui, ma esiste per garantire che tutti i personaggi siano rappresentati.

— Nick Kennedy
fonte

Quindi ... ho pubblicato la mia risposta Jelly, e poi mi ha cliccato: l'interprete converte il bytecode in UTF-8 prima di eseguirlo , quindi il byte deve essere aumentato o il codice deve essere modificato per adattarsi alla tabella codici.

— Erik the Outgolfer,

@EriktheOutgolfer Non capisco cosa stai ottenendo qui. In che modo differisce da qualsiasi altra sfida di codegolf in questo senso?

— Nick Kennedy,

L'aspetto autoreferenziale è diverso, quindi, in effetti, il codice ordina i caratteri UTF-8 e non i byte che dovrebbe.

— Erik the Outgolfer,

3

Gelatina , 14 byte

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

Un programma completo che accetta una stringa (formattata in Python) (della tabella codici Jelly ) che stampa l'output.
(come collegamento monadico produce un elenco di elenchi di caratteri)

Provalo online!

Come?

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

— Jonathan Allan
fonte

Quindi ... ho pubblicato la mia risposta Jelly, e poi mi ha cliccato: l'interprete converte il bytecode in UTF-8 prima di eseguirlo , quindi il byte deve essere aumentato o il codice deve essere modificato per adattarsi alla tabella codici.

— Erik the Outgolfer,

@EriktheOutgolfer Penso che questo sia sicuro sotto questo aspetto poiché questo metodo non utilizza alcun ordinamento e soddisfa l'I / O essendo nello stesso criterio di codifica (Jelly's code page).

— Jonathan Allan,

Eh ... penso fche ḟfunzioni sui caratteri Unicode, perché questo è il tipo di caratteri che la stringa ha effettivamente all'interno. Ad esempio, ”ĿOritorna 319se testato codificato localmente in JELLY, quindi vede Ŀil C7 e non.

— Erik the Outgolfer,

Penso fe ḟlavoro anche su Unicode, ma è un problema qui? Passo nel set limitato di caratteri Unicode che compaiono sulla codepage di Jelly (ovvero byte codificati usando quella codifica, soddisfacendo "L'input è nella stessa codifica del codice"); filtrarli correttamente (poiché questi byte immessi sono stati codificati come Unicode) e quindi generarli correttamente. Quello che poi conto sono i byte del codice (soddisfacendo "L'input è ordinato per caratteri, non per byte" e "la risposta più breve in byte per ogni lingua vince").

— Jonathan Allan,

1

@JonathanAllan Sento che "sono stato codificato in alcuni personaggi usando la tabella codici di Jelly" è ciò a cui mi riferisco nel mio commento precedente. Dato che la codifica del codice è composta da singoli byte da 0x00 a 0xFF, questo dovrebbe essere anche la codifica dell'argomento, invece l'argomento viene passato dopo essere stato mappato da JELLY a UTF-8, quindi ognuno dei suoi caratteri non è necessariamente un singolo byte più. Fondamentalmente, il codice è in JELLY mentre l'argomento è in UTF-8, anche se è stato mappato a quello da JELLY. Mentre viene restituita l'uscita UTF-8 corretta, dovrebbe sempre essere JELLY.

— Erik the Outgolfer,

2

Carbone , 37 byte

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

Provalo online! Spiegazione:

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

Esistono due modi per citare i personaggi in Charcoal; ´cita qualsiasi carattere singolo mentre ”y... ”cita qualsiasi carattere tranne ”e conta anche come una stringa separata. Si scopre che il sovraccarico nel dover affrontare ”significa che non finisce per giocare a golfista.

ＦηΦθ⁼ικ

Passa sopra i personaggi a turno, producendo tutti i caratteri corrispondenti dall'input. Questo ordina l'ingresso.

Φθ¬№ηι

Emette caratteri ineguagliati nell'input.

— Neil
fonte

2

J , 14 byte

Funzione prefisso tacito anonimo.

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

Provalo online!

] l'argomento

...i: ultima occorrenza (i non membri ottengono l'indice oltre la fine della stringa di ricerca) di ciascun carattere in:

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

... /: usalo per ordinare:

] l'argomento

— Adamo
fonte

I quattro spazi iniziali sono il risultato dell'eco o del codice?

— tjjfvi

1

@tjjfvi È come è configurato TIO. Riparato ora.

— Adám,

2

Java 10, 129 100 byte

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

-29 byte eseguendo il porting di +c da @EmbodimentOfIgnorance C # risposta s' .

Provalo online.

Spiegazione:

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: di solito è più economico da usare s.sort((a,b)->Long.compare(a,b)) invece di s.sort(java.util.Comparator.comparing(c->c), ma in questo caso sarebbe più lungo di 11 byte:

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

Provalo online.

— Kevin Cruijssen
fonte

2

05AB1E , 31 26 19 byte

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

-7 byte prendendo ispirazione dall'approccio di @ EmbodimentOfIgnorance nella sua risposta C # di aggiungere il carattere corrente prima dell'indicizzazione.

Provalo online o provalo con la linea di debug aggiunta per vedere le stringhe in cui viene indicizzato .

Spiegazione:

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

— Kevin Cruijssen
fonte

Sembra che ci sia un refuso nella spiegazione ("y" invece di "s")

— ArBo

@ArBo Risolto, grazie

— Kevin Cruijssen il

1

A rigor di termini ho avuto l'ispirazione più di 12 ore prima quando ho giocato a golf 11 byte della risposta di @ MilkyWay90 ...

— Neil

Questo è buono! L'ho visto, ma non riuscivo a vedere un modo per trasformare il mio in questo mentre risparmiavo byte

— dati scaduti il

2

PowerShell , 68 byte

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

Provalo online!

— Andrei Odegov
fonte

2

1) sortinvece sort-objectfunziona anche. 2) la variabile $bdefinita al di fuori del proprio codice. il Standard loopholesrichiede una risposta completa . Per Powershell significa: qualsiasi persona può instradare il codice in un file come uno script PowerShell ed eseguirlo in un terminale. Il tuo codice non funziona dal file di script. Scusate.

— mazzy

1

@mazzy, grazie mille. 1) l' sortalias non funziona in pwsh su Ubuntu 18.04 2) sì, questa è colpa mia, ma ho corretto me stesso e, di conseguenza, il codice è diventato più lungo, ovviamente :)

— Andrei Odegov

(oO)! Ho creato un alias di ordinamento per Powershell . code became longer- questa è la sfida :)

— mazzy,

1

Si hai ragione. Ogni singolo carattere di $pviene aggiunto alla fine della stringa con il codice sorgente e ottiene un indice uguale a $src.Length, ma poiché "il loro ordine non ha importanza e non dovrebbe essere coerente", non importa. In questa risposta , l'intera stringa di input viene aggiunta alla fine della stringa con il codice sorgente.

— Andrei Odegov,

1

@dfeuer, non capisco la tua domanda. Scusate.

— follemente il

2

Python 2 , 62 byte

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

Stesso concetto della mia risposta C #.

Provalo online!

— Incarnazione dell'ignoranza
fonte

\\\'dovrebbe essere \'\\. Bel approccio però! Ho salvato 23 byte nella mia risposta Java.

— Kevin Cruijssen il

1

@KevinCruijssen Risolto

— Embodiment of Ignorance

2

Japt , 18 byte

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

Provalo

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

— ispido
fonte

1

Gelatina , 26 byte (UTF-8 *)

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

Provalo online!

Accetta l'input come stringa formattata in Python nel 1 ° argomento della riga di comando.

Personaggi unici :

“®³nÞṾ©V”

* Nota: ho scoperto che questo non funziona quando è codificato in JELLY, poiché ordina i caratteri UTF-8 anziché i suoi byte.

— Erik the Outgolfer
fonte

Una specie di sorta

Esempi

Regole

Python 3.8 (pre-release) , 102 100 96 85 79 76 68 61 59 60 byte

APL (Dyalog Unicode) , SBCS da 14 byte

C # (compilatore interattivo Visual C #) , 48 byte

JavaScript (Node.js) , 60 58 56 byte

Perl 6 , 56 byte

Rubino , 57 byte

05AB1E , 24 22 21 byte

Jelly , 16 14 byte (Jelly Code page), 25 byte (UTF8)

Spiegazione

Gelatina , 14 byte

Come?

Carbone , 37 byte

J , 14 byte

Java 10, 129 100 byte

05AB1E , 31 26 19 byte

PowerShell , 68 byte

Python 2 , 62 byte

Japt , 18 byte

Gelatina , 26 byte (UTF-8 *)

APL (Dyalog Unicode) , ^{SBCS da} 14 byte