Bienvenido a su primer día en PPCG Inc. Como nuestro nuevo clasificador de documentos de asistente junior, usted es responsable de asegurarse de que todos los documentos que le enviamos estén archivados en orden alfabético. Es tan fácil que un mono puede hacerlo. Bueno, metafóricamente hablando, ya que contratamos a un mono para hacerlo. ¿Adivina qué? Resulta que los monos carecen de una comprensión de nuestro alfabeto. De todos modos, no hay tiempo para arreglar el desorden que hay ahora, así que trata de no empeorar la situación, ¿de acuerdo? ¡Entonces consíguelo! Si tienes hambre, hay plátanos junto al enfriador de agua. ¡Buena suerte!

Descripción del trabajo

Entrada

• Recibirá una lista de cadenas (el archivo) y una cadena que debe agregarse a esa lista (el documento)
• Todas las cadenas contendrán solo letras mayúsculas, minúsculas y espacios
• Las cadenas siempre comenzarán y terminarán con una letra

Tarea

Determine la posición de destino del documento: la posición que debe recibir en el archivo. La posición objetivo se puede determinar de la siguiente manera:

• Para cada puesto:
  • Cuente la cantidad de cadenas en el archivo antes de esa posición que están alfabéticamente antes del documento
  • Cuente la cantidad de cadenas en el archivo después de esa posición alfabéticamente después del documento
  • Defina el puntaje de la posición como la suma de los dos conteos anteriores
• La posición de destino del documento es la posición con la puntuación más alta.
• En caso de empate, todas las posiciones con la puntuación más alta son igualmente válidas que la posición objetivo. Solo uno necesita ser seleccionado.

Al ordenar:

• Las letras mayúsculas y minúsculas son equivalentes
• Los espacios van antes que las letras

Salida

• El archivo con el documento agregado en cualquier forma

O

• La posición de destino del documento, ya sea en un índice basado en 0 o en 1

Evaluación del trabajo

¡Pocos bytes ganan!

Ejemplo de E / S

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 bytes

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

Sin golf:

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

Editar: ahorró muchos bytes gracias a @ user81655.

Pyth, 40 38 bytes

Créditos a @Katenkyo por enseñarme eso A xnor Bes básicamente A==B. ( A xor Bes también A!=B)

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

Pruébalo en línea!

Cómo funciona:

Suma el XNOR de si la entrada es más pequeña que el documento y si el índice de la entrada es más pequeño que el índice del documento.

Encuentra la posición en la que esta suma es la máxima, luego la genera.

Python 3, 135 167 Bytes

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)

Ruby, 97 bytes

Función anónima, devuelve la posición de destino.

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

Cuando realmente se inserta en el archivo, 110 bytes :

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

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

La entrada esperada es una lista, el primer elemento es una lista de cadenas (archivo), el segundo elemento es una cadena (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

Prueba aquí

• Guardado 5 bytes en la inicialización de entrada (gracias @Kenny Lau)

MATL , 32 bytes

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

La entrada es un conjunto de celdas de cadenas (varias cadenas separadas por espacios y encerradas entre llaves) para el archivo y una cadena para el documento. La salida está basada en 1. En caso de empate se devuelve la primera posición.

Pruébalo en línea!

Explicación

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