Inspirado pela lição da APL da semana passada .

Dado um mapa de assentos 2D em maiúsculas e uma lista 1D de clientes, retorne o mapa de assentos e a lista de clientes, mas modificado da seguinte forma (para indicar assentos ocupados e clientes sentados):

Para cada letra exclusiva na lista de passageiros de entrada, minúscula que muitas (ou todas, se não houver o suficiente) dessa letra no mapa de assentos, indo da esquerda para a direita, de cima para baixo.

Para cada letra exclusiva no mapa de assentos, minúscula que muitas (ou todas, se não houver o suficiente) dessa carta na lista de passageiros, indo da esquerda para a direita.

1. O mapa de assentos de entrada contém apenas espaços e letras maiúsculas do conjunto { F, B, P, E}, e pode ser:
   1. separados em linhas por quebras de linha
   2. uma lista de strings
   3. uma matriz de caracteres maiúsculos
   4. em qualquer outro formato comparável
2. A lista de clientes de entrada contém apenas letras maiúsculas do conjunto { F, B, P, E} e pode ser:
   1. uma linha
   2. uma lista de caracteres
   3. em qualquer outro formato comparável
3. O mapa de assentos retornado deve ser idêntico ao mapa de entrada, exceto que zero ou mais letras foram dobradas para minúsculas
4. A lista de clientes retornados deve ser idêntica à da entrada, exceto que zero ou mais letras foram dobradas para minúsculas
5. Espaço em branco à esquerda e à direita é permitido

Exemplos ^{(edições reduzidas das aeronaves da United)}

ERJ145

Entrada do mapa de assentos:

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

P  PP
E  EE
E  EE
E  EE

Entrada da lista de passageiros:

FFEEEEEEEEEEEEEEEE

Saída do mapa de assentos:

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

P  PP
e  eE
E  EE
E  EE

Saída da lista de passageiros:

FFeeeeeeeeeeeeeeee

CRJ700

Entrada do mapa de assentos:

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

PP  PP
EE  EE
EE  EE
EE  EE

Entrada da lista de clientes:

FFFFFFFFPPEEEEEEEEEEEEEEEEEEEEE

Saída do mapa de assentos:

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

PP  PP
ee  ee
ee  ee
ee  ee

Saída da lista de clientes:

ffffffFFppeeeeeeeeeeeeeeeeEEEEE

B757

Entrada do mapa de assentos:

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 da lista de passageiros:

FEEEEEEEEFEEEFEEEEEEEEFEEFFEEFEFFFEE

Saída do mapa de assentos:

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     

Saída da lista de passageiros:

feeeeeeeefeeefeeeeeeeefeeffeefefffee

B767

Entrada do mapa de assentos:

 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 da lista de passageiros:

PPFEFEEEEEEEBBEEFFPEBPEBBEEFEEEFEEEEEEFPEEEPB

Saída do mapa de assentos:

 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          

Saída da lista de passageiros:

ppfefeeeeeeebbeeffpebpebbeefeeefeeeeeeFpeeepb

05AB1E , 22 16 15 bytes

Economizou 6 bytes graças ao Nit, notando que o mapa de assentos poderia ser usado como uma string.

svDyå·Fyyl.;s]»

Experimente online!

Explicação

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

Experimente online!

Aceita entrada como duas strings. Imprime duas strings

Salvou

• -5 bytes, graças a Dead Possum
• -4 bytes, graças 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++;}}

Leva dois char *(assentos e passageiros) cujo conteúdo é modificado no local.

Experimente online!

Estou menos acostumado a jogar golfe em C do que em Python, mas isso também é divertido!

Se alguém tiver uma idéia de um truque para encurtar a *r+=32,*i+=32parte, ficaria grato. -> Obrigado ao @Dave por me ajudar a jogar mais alguns bytes!

C (gcc) , 63 bytes

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

Experimente online!

Muito crédito ao eteno pelo conceito básico. Apenas aplicou o golfe pesado à estratégia de sua resposta.

C (gcc) , 64 bytes

Tomando emprestado a resposta de @ etene, removi o ifcom o ?:operador terciário e reutilizei o ponteiro de passageiro como seu próprio índice.

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

Experimente online!

Geléia , 19 bytes

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

Experimente online!

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

Experimente online!

Recebe 2 seq de caracteres na entrada e retorna 2 seq de caracteres.

Explicação:

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

Experimente online! Supõe que a lista de clientes seja a última linha da entrada. Explicação: Localiza pares de caracteres maiúsculos e minúsculos correspondentes $l, evitando assim os caracteres intermediários.

APL (Dyalog Classic) , 29 27 bytes

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

Experimente online!

Perl 5 -pF , 48 bytes

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

Experimente online!

A primeira linha de entrada é a lista de passageiros. Todas as linhas subseqüentes são o mapa de assentos. A saída é a mesma.