Objetivo

Escreva um programa ou função (ou equivalente) que classifique e retorne a letra ímpar na matriz de tamanho aleatório.

Detalhes

Você receberá uma matriz (como uma string) como entrada de dimensões aleatórias como esta.

bbbbbbbbbb
bbbbbdbbbb
bbbbbbbbbb
bbbbbbbbbb
bbbbbbbbbb

Seu trabalho é encontrar a letra que não corresponde ao restante (neste caso, é dencontrada na linha 2, coluna 6) e retornar essa letra como saída. A matriz será composta por letras A-Z, a-znovas linhas ( \napenas nas extremidades das linhas) e terá dimensões que variam de 5x5 a 10x10 (25 a 100 letras).

Aplicam-se brechas padrão. Este é um desafio de código de golfe; entrada com código de menos bytes ganha.

Entrada

A entrada será transmitida através da entrada padrão como uma string, se for um programa ou como argumento, se for uma função (ou similar).

Resultado

A única personagem que é o "estranho" na matriz ou None , nil, NULou a corda "None"se não houver nenhum caráter "estranho".

Mais exemplos

AAAAAAA
AAAAAAA
AAAAAAA
AAAIAAA
AAAAAAA

Responda: I

vvqvvvvvvv
vvvvvvvvvv
vvvvvvvvvv
vvvvvvvvvv
vvvvvvvvvv

Responda: q

puuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu

Responda: p

Gerador

Aqui está um gerador de matriz aleatória escrito em Python que você pode usar para testar seu programa. Nota: Há uma pequena chance de que isso possa cometer um erro e não colocar uma letra estranha.

Instructions

1. Copy this code into a file called `matrix_gen.py`.
2. Run it with `python matrix_gen.py`.

---

from random import randint

rows = randint(5,10)
cols = randint(5,10)

charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
neg = charset[randint(0,51)]
pos = charset[randint(0,51)]
p_used = 0

comp = 0
matrix = ""

while comp < rows:
  row = ""
  while len(row) < cols:
    if not p_used and not randint(0,10):
      p_used = 1
      row = row + pos
    else:
      row = row + neg
  row = row + "\n"
  matrix = matrix + row
  comp += 1

print matrix[:-1]

Python 3 , 27 bytes

lambda x:min(x,key=x.count)

Experimente online!

J , 12 10 7 bytes

-.}./.~

Experimente online!

    /.~        Group identical items together
  }.           Remove one item from each group
-.             Remove the rest from the input

Versão de 10 bytes

-._1 1{\:~

^{assobios ...}

       \:~        Sort down
  _1 1{           Take the last character (which is a newline) and the second one.
-.                Remove those from the input

Braquilog , 8 4 bytes

oḅ∋≠

Experimente online!

Explicação

Eu não usei o Brachylog antes, então isso pode não ser o ideal.

oḅ∋≠  Input is a string.
o     Sort the input.
 ḅ    Split it into blocks of equal elements.
  ∋   There is a block
   ≠  whose elements are all different.
      That block is the output.

K (oK) , 7 6 bytes

Solução

*<#:'=

Experimente online!

Exemplo:

*<#:'="vvqvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv"
"q"

Explicação:

Foi encontrada uma abordagem um pouco mais curta: avaliada da direita para a esquerda:

*<#:'= / the solution
     = / group matching items together
  #:'  / count (#:) each (')
 <     / sort ascending
*      / take the first one

Notas:

Enquanto espero que o aspecto bônus deste desafio seja descartado, esta solução retornará o caractere de nova linha \nse não houver um caractere estranho:

*<#:'="vvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv"
"\n"

Prolog (SWI) , 46 bytes

p(L):-select(X,L,Y),\+member(X,Y),writef([X]).

Experimente online!

Ou se a saída verdadeira padrão das consultas de prólogo não estiver correta :

Prolog (SWI) , 48 bytes

Z*L:-select(X,L,Y),\+member(X,Y),char_code(Z,X).

Experimente online!

Explicação

Find the first element X in the input  
that when removed, results in output  
that does not contain X

then depending on the version above either:  
print X as a character  
or  
return X as an atom

C (gcc) , 93 92 90 66 62 bytes

Muito mais curto como uma função

t;f(char*p){for(t=*p;*p;)t^*p++?putchar(*p^*--p?*p:t),*p=0:0;}

Experimente online!

código de teste

main()
{
    char s[99];
    for(;gets(s);)f(s);
}

versão antiga é um programa

C 86 bytes

char*p;s[9];main(t){for(;p=gets(s);)for(t=*p;*p;)t^*p++?putchar(*p^*--p?*p:t),*p=0:0;}

Emite o caractere ímpar ou nada. corra assim;

C:\eng\golf>python matrix_gen.py | a.exe
X
C:\eng\golf>python matrix_gen.py | a.exe
G
C:\eng\golf>python matrix_gen.py | a.exe
x
C:\eng\golf>python matrix_gen.py | a.exe

C:\eng\golf>python matrix_gen.py | a.exe
J

05AB1E ,  4  2 bytes

Economizou 2 bytes graças a Adnan

.m

Experimente online!

Explicação

.m   # push a list of the least frequent character(s) in input

Retina , 13 bytes

s(O`.
(.)\1+

Experimente online!

Explicação

s(O`.

Classifique todos os caracteres.

(.)\1+

Remova todos os caracteres que aparecerem pelo menos duas vezes.

Casca , 2 bytes

◄=

Experimente online!

Esta é uma função que recebe uma string como entrada e retorna um caractere. É necessário o mínimo da string de entrada ao comparar caracteres para igualdade (ou seja, retorna o caractere que é igual ao menor número de outros caracteres).

C, 94 bytes

Retorno por ponteiro. Se não houver, retorne \0.

Isso causará vazamentos de memória. Supondo que intsejam 4 bytes.

*t;f(c,p,i)char*c,*p;{t=calloc(64,8);for(*p=-1;*c;c++)t[*c]--;for(i=0;++i<128;)!~t[i]?*p=i:0;}

Experimente online!

Mathematica, 27 bytes

Last@*Keys@*CharacterCounts

Experimente online!

-1 byte de Martin Ender

Bash , 15 20 bytes

fold -1|sort|uniq -u

Experimente online!

Explicação: fold s a entrada do 1caractere por linha, sorts em grupos de letras correspondentes e, em seguida, imprime apenas as linhas que são unique.

Obrigado a @Nahuel Fouilleul por capturar e ajudar a solucionar um problema com essa abordagem.

Pitão , 4 bytes

ho/Q

Experimente aqui!

Perl 5, 17 + 3 (-00p) -25% = 15 bytes

/(.)\1/;s/
|$1//g

experimente online

Matlab, 25 bytes

a=input('');a(a~=mode(a))

A entrada "a" onde "a" não é o modo de "a". Produz um array vazio para nenhum oddball.

Haskell, 33 * 0,75 = 24,75 bytes

f s=[c|[c]<-(`filter`s).(==)<$>s]

Retorna uma lista vazia se não houver um caractere ímpar.

Experimente online!

Para cada caractere cna matriz (fornecido como uma string s), faça uma string de todos os caracteres siguais ce mantenha os caracteres de comprimento 1.

JavaScript (ES6), 37 bytes

Retorna nullse não houver uma letra ímpar.

s=>s.match(`[^
${s.match(/(.)\1/)}]`)

Casos de teste

let f =

s=>s.match(`[^
${s.match(/(.)\1/)}]`)

console.log(f(
  'bbbbbbbbbb\n' +
  'bbbbbdbbbb\n' +
  'bbbbbbbbbb\n' +
  'bbbbbbbbbb\n' +
  'bbbbbbbbbb'
))

console.log(f(
  'AAAAAAA\n' +
  'AAAAAAA\n' +
  'AAAAAAA\n' +
  'AAAIAAA\n' +
  'AAAAAAA'
))

console.log(f(
  'vvqvvvvvvv\n' +
  'vvvvvvvvvv\n' +
  'vvvvvvvvvv\n' +
  'vvvvvvvvvv\n' +
  'vvvvvvvvvv'
))

console.log(f(
  'puuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu'
))

console.log(f(
  'AAAAA\n' +
  'AAAAA\n' +
  'AAAAA\n' +
  'AAAAA\n' +
  'AAAAA'
))

Japt , 6 bytes

Recebe a entrada como uma sequência de linhas múltiplas e gera uma única sequência de caracteres ou uma sequência vazia, se não houver solução.

k@èX É

Tente

Explicação

Remova os caracteres que retornam verdade ( k) quando passados ​​por uma função ( @) que conta ( è) as ocorrências do elemento atual ( X) na entrada e subtrai 1 ( É).

Lisp comum, 47 bytes

(lambda(s)(find-if(lambda(x)(=(count x s)1))s))

Experimente online!

Retorna a letra ímpar ou NIL, se não existir.

Gelatina , 4 bytes

ċ@ÐṂ

Experimente online!

Retornar \n(uma única nova linha) caso não haja caracteres estranhos. Obviamente \nnão é um caractere imprimível.

Coincidentemente, esse é exatamente o mesmo algoritmo que a resposta do Mr.Xcoder Python. (Eu vim com ele de forma independente)

Explicação:

  ÐṂ    Ṃinimum value by...
ċ@      ċount. (the `@` switch the left and right arguments of `ċ`)

Isso funciona porque em uma m×nmatriz:

• Se existir um caractere ímpar: existem m-1novas linhas, 1 caractere ímpar e m×n-1caractere normal e 1 < m-1 < m×n-1porque5 ≤ m, n ≤ 10 .
• Se não houver caracteres ímpares: existem m-1novas linhas e m×ncaracteres normais, e m-1 < m×n.

C # (.NET Core) , 54 bytes

i=>i.GroupBy(x=>x).FirstOrDefault(g=>g.Count()<2)?.Key

Experimente online!

C (gcc) , 91 86 82 79 71 bytes

f(char*s){for(;*++s==10?s+=2:0,*s;)if(*s^s[-1])return*s^s[1]?*s:s[-1];}

Experimente online!

• Obrigado ao Gastropner pelo xor e? truques (-3 bytes)
• Retrabalhou a versão de comparação para corrigir bugs e usou a magia do Gastropner nos comentários.

Explicação:

Compare o caractere atual e o anterior, ignorando as novas linhas. Se diferente, compare com o próximo caractere. Isso nos diz se retornamos caracteres atuais ou anteriores. A função retorna o valor de caractere "ímpar" se existir ou 0 se a matriz não for ímpar. Nós nos safamos da "próxima" verificação de char, porque sempre há uma nova linha antes do\0 char. Se não houver um caractere ímpar, retornamos intrinsecamente o \ 0 do loop for.

Código xor mais antigo e mais sexy Explicação:

Faça uma máscara xor em execução dos próximos 3 valores de sequência. Se forem todos iguais, o valor será igual a qualquer um dos três. Se forem diferentes, os 2 idênticos se cancelarão deixando o único.

Deve fatorar / n antes do xor ou ficar confuso. Também é necessário verificar 2 caracteres quanto à desigualdade, caso s [0] seja o valor ímpar. Isso custa o extra || Verifica.

v;f(char*s){while(s[3]){s[2]==10?s+=3:0;v=*s^s[1]^s[2];if(v^‌​*s++||v^*s)break;}}

Oitava , 26 25 bytes

1 byte salvo graças a @Giuseppe

@(x)x(sum(x(:)==x(:)')<2)

Função anônima que recebe uma matriz de caracteres 2D como entrada e gera uma letra ímpar ou uma sequência vazia, se não existir.

Experimente online!

Alice , 16 * 75% = 12 bytes

/-.nDo&
\i..*N@/

Experimente online!

Saídas Jabberwocky se não houver caracteres duplicados.

Explicação

/...@
\.../

Essa é uma estrutura para programas lineares que operam inteiramente no Ordinal (modo de processamento de strings). O código real é executado em zigue-zague e se desdobra em:

i..DN&-o

i   Read all input.
..  Make two copies.
D   Deduplicate one copy, giving only the two letters and a linefeed.
N   Multiset difference. Removes one copy of each letter and one linefeed.
    Therefore it drops the unique letter.
&-  Fold substring removal over this new string. This essentially removes
    all copies of the repeated letter and all linefeeds from the input,
    leaving only the unique letter.
.   Duplicate.
n   Logical NOT. Turns empty strings into "Jabberwocky" and everything else
    into an empty string.
*   Concatenate to the previous result.
o   Print the unique letter or "Jabberwocky".

Em vez de &-, também poderíamos usar ey(transliteração para uma string vazia). Como alternativa, gastando mais um caractere na manipulação de pilha, também poderíamos deduplicar a entrada, o que nos permite remover os caracteres indesejados N, mas ainda é a mesma contagem de bytes:

i.D.QXN.n*o@

Alice , 13 bytes

/N.-D@
\i&.o/

Experimente online!

Esta é a solução sem o bônus, simplesmente está faltando o .n*.

Retina , 22 bytes

!`(.)(?!.*\1)(?<!\1.+)

Experimente online! Requer apenas altura e largura de pelo menos 3, em vez de 5.

APL + WIN, 16 bytes

(1=+/a∘.=a)/a←,⎕

Solicita a entrada na tela e gera uma letra ímpar ou nada se não houver uma letra ímpar

PowerShell , 39 bytes

([char[]]"$args"|group|sort c*)[0].Name

Experimente online!

Recebe a entrada como uma string com novas linhas (conforme especificado no desafio) e a converte em uma charmatriz. Nós, então, Group-Objectos caracteres, para que os caracteres sejam agrupados por seus nomes e depois com sortbase no count. Isso garante que o caractere solitário seja o primeiro, então pegamos o [0]índice e produzimos seu .Name.

Se a nova linha for aceitável para "nada", isso será qualificado para o bônus.

Perl 6 ,  27  24 -25% = 18 bytes

*.comb.Bag.min(*.value).key

Teste-o

{%(.comb.Bag.invert){1}}

Teste-o

Isso retornará um valor indefinido quando receber uma entrada que não tenha um caractere ímpar.

Expandido:

{  # bare block lambda with implicit parameter ｢$_｣

  %(        # coerce into a Hash

    .comb   # split the input into graphemes (implicit method call on ｢$_｣)
    .Bag    # turn into a weighted Set
    .invert # invert that (swap keys for values) returns a sequence

  ){ 1 }    # get the character that only occurs once
}

Brainfuck, 125 bytes

,[----------[>],]<[->+<]<<[[->->+<<]>[>[->-<<<+>>]>[,<<,>>]<<<[->+<]>[->+<]<]>[-<<+>>]>[-<+>]<<<<]>>>>[<]<++++++++++.

Experimente Online

Imprime a letra da matriz se não houver um número ímpar

Java 8, 85 bytes

Este é um lambda de Stringpara String(por exemplo Function<String, String>). É essencialmente uma cópia da solução de Luca , mas reduzi um pouco a seqüência de caracteres.

s->new String(s.chars().sorted().toArray(),0,s.length()).replaceAll("(.)\\1+|\\n","")

Experimente Online