Benvenuto al tuo primo giorno in PPCG Inc. In qualità di nuovo selezionatore di documenti per assistenti junior, sei responsabile di assicurarti che tutti i documenti che ti abbiamo inviato siano archiviati in ordine alfabetico. È così facile che una scimmia possa farlo. Beh, metaforicamente parlando, dato che abbiamo assunto una scimmia per farlo. Indovina un po? Risulta che le scimmie non hanno una comprensione del nostro alfabeto. Ad ogni modo, non c'è tempo per risolvere il casino che c'è in questo momento, quindi cerca solo di non peggiorare la situazione, ok? Allora arriva! Se hai fame, ci sono banane sopra il refrigeratore d'acqua. In bocca al lupo!

Descrizione del lavoro

Ingresso

• Riceverai un elenco di stringhe (l'archivio) e una stringa che deve essere aggiunta a tale elenco (il documento)
• Tutte le stringhe conterranno solo lettere maiuscole, lettere minuscole e spazi
• Le stringhe inizieranno e finiranno sempre con una lettera

Compito

Determina la posizione target del documento: la posizione che dovrebbe ricevere nell'archivio. La posizione target può essere determinata come segue:

• Per ogni posizione:
  • Contare la quantità di stringhe nell'archivio prima di quella posizione in ordine alfabetico prima del documento
  • Conta la quantità di stringhe nell'archivio dopo quella posizione in ordine alfabetico dopo il documento
  • Definire il punteggio della posizione come somma dei due conteggi precedenti
• La posizione target del documento è la posizione con il punteggio più alto
• In caso di pareggio, tutte le posizioni con il punteggio più alto sono ugualmente valide come posizione target. È necessario selezionarne solo uno.

Durante l'ordinamento:

• Le lettere maiuscole e minuscole sono equivalenti
• Gli spazi vengono prima delle lettere

Produzione

• L'archivio con il documento aggiunto ad esso in qualsiasi forma

O

• La posizione di destinazione del documento, in un indice basato su 0 o 1

Valutazione del lavoro

Vince il minor numero di byte!

Esempio di I / O

Archive:
    Applebuck Season
    Friendship is Magic
    The Ticket Master
    Griffon the BrushOff
    Boast Busters
    Bridle Gossip

Document: Dragonshy

Position scores (0-based index):
0: 0 + 3 = 3
1: 1 + 3 = 4
2: 1 + 2 = 3
3: 1 + 1 = 2
4: 1 + 0 = 1
5: 2 + 0 = 2
6: 3 + 0 = 3

Target position: 1

JavaScript (ES6), 81 byte

(a,d)=>a.map((e,i)=>d[l="toLowerCase"]()<e[l]()?s--:++s>m&&(++m,p=++i),m=s=p=0)|p

Ungolfed:

function position(archive, document) {
    var score = 0;
    var max = 0;
    var pos = 0;
    var i = 0;
    while (i < archive.length) {
        if (archive[i++].toLowerCase() > document.toLowerCase()) {
            score--;
        } else {
            score++;
            if (score > max) {
                max++;
                pos = i;
            }
        }
    }
    return pos;
}

Modifica: molti byte salvati grazie a @ user81655.

Pyth, 40 38 byte

Ringraziamo @Katenkyo per avermi insegnato che A xnor Bè fondamentalmente A==B. ( A xor Bè anche A!=B)

AQJ+],k0.e,rb0hkGteh.Msmq<hdrH0<edeZJJ

Provalo online!

Come funziona:

Riassume l'XNOR se la voce è più piccola del documento e se l'indice della voce è più piccolo dell'indice del documento.

Trova la posizione in cui questa somma è il massimo, quindi la emette.

Python 3, 135 167 byte

def a(b,c):a=[sum(map(lambda x:x.lower()>c.lower(),b[i:]))+sum(map(lambda x:x.lower()<c.lower(),b[:i]))for i in range(0,len(b)+1)];b.insert(a.index(max(a)),c);print(b)

Rubino, 97 byte

Funzione anonima, restituisce la posizione target.

->a,d{d.upcase!;(0...a.size).max_by{|i|a[0,i].count{|s|s.upcase<d}+a[i..-1].count{|s|s.upcase>d}}}

Quando si inserisce effettivamente nell'archivio, 110 byte :

->a,d{t=d.upcase;a.insert (0...a.size).max_by{|i|a[0,i].count{|s|s.upcase<d}+a[i..-1].count{|s|s.upcase>d}},d}

Pyth, 54 52 47 45 byte

AQVhlG=Ys+m>rH0rd0:G0Nm<rH0rd0gGNI>YZ=ZY=kN;k

Aspettatevi che l'input sia un elenco, il primo elemento è un elenco di stringhe (archivio), il secondo elemento è una stringa (documento)

AQ                                            # initialize G and H with the archive and the document
  VhlG                                        # iterate over the indexes on archive
      =Ys+                                    # concatenate and sum the following scores
          m>rH0rd0:G0N                        # map a string comparison between the document and the archives up to the index, returning true(1) for lower, and false(0) for higher
                      m<rH0rd0gGN             # same as above, but starts at the index and goes up to the end of the archive, returning false(0) for lower, and true(1) for higher
                                 I>YZ         # Check if score is higher than highest
                                     =ZY      # update highest score
                                        =kN;  # update index
                                            k # print index

Prova qui

• 5 byte salvati sull'inizializzazione dell'input (grazie a @Kenny Lau)

MATL , 32 byte

hk4#S4#S%2#0)>t0whYsw~0hPYsP+K#X>

L'input è una matrice di celle di stringhe (diverse stringhe separate da spazi e racchiuse tra parentesi graffe) per l'archivio e una stringa per il documento. L'output è basato su 1. In caso di pareggio viene restituita la prima posizione.

Provalo online!

Spiegazione

h      % Concatenate archive and document as a cell array of strings
k      % Convert all strings to lowercase
4#S    % Sort and output the indices of the sorting
4#S    % Again. This gives the indices that applied to the concatenated
       % array would make it sorted
2#0)   % Separate last index (document) from the others (archive)
>      % Is it greater? Gives zero/one array the size of the archive
t      % Duplicate that array
0wh    % Prepend a 0
Ys     % Cumulative sum. This is first part of the score
w~     % Swap. Negate zero/one array
0h     % Postpend a 0
PYsP   % Reverse, cumulative sum, reverse. Second part of the score
+      % Add. This is the score of each position
K#X>   % Arg max