Inspirado en la lección APL de la semana pasada .

Dado un mapa de asientos en 2D en mayúsculas y una lista de clientes en 1D, devuelva el mapa de asientos y la lista de clientes, pero modifique de la siguiente manera (para indicar los asientos ocupados y los clientes sentados):

Para cada letra única en la lista de pasajeros de entrada, minúscula esa cantidad (o todas, si no hay suficiente) de esa letra en el mapa de asientos, de izquierda a derecha, de arriba a abajo.

Para cada letra única en el mapa de asientos, minúscula esa cantidad (o todas, si no hay suficiente) de esa letra en la lista de pasajeros, de izquierda a derecha.

1. El mapa de asientos de entrada sólo contiene espacios y letras mayúsculas del conjunto { F, B, P, E}, y puede ser:
   1. separados en filas por saltos de línea
   2. una lista de cadenas
   3. una matriz de caracteres en mayúscula
   4. en cualquier otro formato comparable
2. La lista de clientes de entrada sólo contiene letras mayúsculas del conjunto { F, B, P, E} y pueden ser:
   1. una cuerda
   2. una lista de personajes
   3. en cualquier otro formato comparable
3. El mapa de asiento devuelto debe ser idéntico al de entrada, excepto que cero o más letras se han plegado a minúsculas
4. La lista de clientes devuelta debe ser idéntica a la de entrada, excepto que cero o más letras se han plegado a minúsculas
5. Se permiten espacios en blanco iniciales y finales

Ejemplos ^{(ediciones abreviadas de aviones de United)}

ERJ145

Entrada del mapa del asiento:

P    
E    
E  PP
E  EE
E  EE
E  EE
E  EE

P  PP
E  EE
E  EE
E  EE

Entrada de la lista de pasajeros:

FFEEEEEEEEEEEEEEEE

Salida del mapa del asiento:

P    
e    
e  PP
e  ee
e  ee
e  ee
e  ee

P  PP
e  eE
E  EE
E  EE

Salida de la lista de pasajeros:

FFeeeeeeeeeeeeeeee

CRJ700

Entrada del mapa del asiento:

F   FF
F   FF
PP  PP
PP  PP
PP  PP
EE  EE

PP  PP
EE  EE
EE  EE
EE  EE

Entrada de lista de clientes:

FFFFFFFFPPEEEEEEEEEEEEEEEEEEEEE

Salida del mapa del asiento:

f   ff
f   ff
pp  PP
PP  PP
PP  PP
ee  ee

PP  PP
ee  ee
ee  ee
ee  ee

Lista de clientes de salida:

ffffffFFppeeeeeeeeeeeeeeeeEEEEE

B757

Entrada del mapa del asiento:

F F  F F
F F  F F
F F  F F

PPP     
PPP  PPP
PPP  PPP
PPP  PPP
EEE  EEE
EEE  EEE
PPP  PPP
EEE  EEE
EEE  EEE
     EEE

EEE  EEE
EEE  EEE
EEE  EEE
EEE     

Entrada de la lista de pasajeros:

FEEEEEEEEFEEEFEEEEEEEEFEEFFEEFEFFFEE

Salida del mapa del asiento:

f f  f f
f f  f f
f f  F F

PPP     
PPP  PPP
PPP  PPP
PPP  PPP
eee  eee
eee  eee
PPP  PPP
eee  eee
eee  eee
     eeE

EEE  EEE
EEE  EEE
EEE  EEE
EEE     

Salida de la lista de pasajeros:

feeeeeeeefeeefeeeeeeeefeeffeefefffee

B767

Entrada del mapa del asiento:

 F   F   F           
 F   F   F           
BB  B B  BB          
BB  B B  BB          
BB  B B  BB          
PP       BB          
PP                   

PP  PPP  PP          
PP  PPP  PP          
PP  PPP  PP          
PP  PPP  PP          
PP  EEE  PP          
EE  EEE  EE          
EE  EEE  EE          
EE  EEE  EE          
EE  EEE  EE          
EE  EEE  EE          

Entrada de la lista de pasajeros:

PPFEFEEEEEEEBBEEFFPEBPEBBEEFEEEFEEEEEEFPEEEPB

Salida del mapa del asiento:

 f   f   f           
 f   f   f           
bb  b b  bb          
BB  B B  BB          
BB  B B  BB          
pp       BB          
pp                   

pp  PPP  PP          
PP  PPP  PP          
PP  PPP  PP          
PP  PPP  PP          
PP  eee  PP          
ee  eee  ee          
ee  eee  ee          
ee  eee  ee          
ee  EEE  EE          
EE  EEE  EE          

Salida de la lista de pasajeros:

ppfefeeeeeeebbeeffpebpebbeefeeefeeeeeeFpeeepb

05AB1E , 22 16 15 bytes

Ahorró 6 bytes gracias a que Nit notó que el mapa del asiento podría tomarse como una cadena.

svDyå·Fyyl.;s]»

Pruébalo en línea!

Explicación

s                     # setup stack as <passengerlist>,<seatmap>,<passengerlist>
 v                    # for each passenger y
  Dyå                 # does a corresponding seat exist?
     ·F               # multiplied by 2 times do:
       yyl.;          # replace the first y with a lowercase y
            s         # and swap the seatmap and passengerlist on the stack
             ]        # end loops
              »       # join seatmap and passengerlist on newline and output

Python 2 , 93 89 84 83 82 78 bytes

l=input()
for c in l[1]:l=[x.replace(c,c.lower(),c in l[0])for x in l]
print l

Pruébalo en línea!

Toma la entrada como dos cadenas. Imprime dos cadenas

Salvado

• -5 bytes, gracias a Dead Possum
• -4 bytes, gracias a Lynn

C (clang) , 75 68 bytes

f(char*s,char*p){char*r;while(*s){if(r=strchr(p,*s))*r=*s+=32;s++;}}

Toma dos char *(asientos y pasajeros) cuyo contenido se modifica en el lugar.

Pruébalo en línea!

Estoy menos acostumbrado al golf en C que en Python, ¡pero eso también es divertido!

Si alguien tiene una idea para un truco para acortar la *r+=32,*i+=32parte, se lo agradecería. -> ¡Gracias a @Dave por ayudarme a jugar golf más bytes!

C (gcc) , 63 bytes

f(x,y,z)char*x,*y,*z;{for(;*y;++y)if(z=strchr(x,*y))*z=*y+=32;}

Pruébalo en línea!

Mucho crédito a etene por el concepto básico. Acaba de aplicar el golf pesado a la estrategia de su respuesta.

C (gcc) , 64 bytes

Tomando prestado de la respuesta de @etene, eliminé el ifcon el ?:operador terciario y reutilicé el puntero del pasajero como su propio índice.

f(s,p,j)char*s,*p,*j;{for(;*p;p++)(j=strchr(s,*p))?*j=*p|=32:0;}

Pruébalo en línea!

Jalea , 19 bytes

,ṚŒlẹЀḣ"ċЀ`}Ẏʋ¦/€

Pruébalo en línea!

Scala , 104 bytes

def f(l:Array[Char]*)=(l(0).map(? =>{val i=l(1)indexOf?;if(i>=0){l(1)(i)= ?toLower;l(1)(i)}else?}),l(1))

Pruébalo en línea!

Toma 2 seq de caracteres en la entrada y devuelve 2 seq de caracteres.

Explicación:

def f(l: Array[Char]*) =          // input are varargs of Array[Char]; in our case 2 arrays. Arrays are chosen since mutable (the seatmap will be updated while the passenger list is mapped)
  (                               // we return a tuple with the 2 arrays of Chars
    l(0).map(                     // l(0) is the passenger list. We map (transform) each element of this list to lowercase or not and this is what's returned as 1st part of the tuple
      ? => {                      // ? is the current element of the passenger list being mapped (it's ? and not let's say m in order to be able to stick it next to functions)
        val i = l(1) indexOf ?   // i is the index (or -1) of the letter ? in the seat map
        if (i >= 0) {             // if index found
          l(1)(i) = ? toLower     // then we update the seatmap with the lower case version of this seat
          l(1)(i)                 // and the passenger list elmt is mapped to its lower case version (same as ?.toLower)
        }                         //
        else ?                    // if not found, the seatmap is not updated and the passenger list elmt stays in upper case
      }                           //
    ),                            // 
    l(1)                          // the updated seat map
  )

Retina , 36 bytes

+`(([A-Z])(.*¶)+.*?)(\2.*$)
$l$1$l$4

Pruébalo en línea! Asume que la lista de clientes es la última línea de la entrada. Explicación: Encuentra pares de caracteres en mayúsculas y minúsculas coincidentes $l, evitando los caracteres intermedios.

APL (Dyalog Classic) , 29 27 bytes

(~2∊/3⍴(⍴⍴,\∘,∩¨,)¨)819⌶¨¨⊢

Pruébalo en línea!

Perl 5 -pF , 48 bytes

$\=join'',<>;say map$\=~s/$_/lc$_/e&&lc||$_,@F}{

Pruébalo en línea!

La primera línea de entrada es la lista de pasajeros. Todas las líneas siguientes son el mapa de asientos. La salida es la misma.