Objetivo

Escriba un programa o función (o equivalente) que clasifique y devuelva la letra impar en la matriz de tamaño aleatorio.

Detalles

Se le pasará una matriz (como una cadena) como entrada de dimensiones aleatorias como esta.

bbbbbbbbbb
bbbbbdbbbb
bbbbbbbbbb
bbbbbbbbbb
bbbbbbbbbb

Su trabajo es encontrar la letra que no coincide con el resto (en este caso, se dencuentra en la línea 2, col 6) y devolver esa letra como salida. La matriz consistirá en letras A-Z, a-zlíneas nuevas ( \nsolo en los extremos de las filas) y tendrá dimensiones que van desde 5x5 a 10x10 (25-100 letras).

Se aplican lagunas estándar. Este es un desafío de código de golf; la entrada con el código de bytes mínimos gana.

Entrada

La entrada se pasará a través de la entrada estándar como una cadena si es un programa o como argumento si es una función (o similar).

Salida

Un único personaje que es la "extraña" en la matriz o None , nil, NUL, o la cadena "None", si no hay ningún carácter "extraño".

Más ejemplos

AAAAAAA
AAAAAAA
AAAAAAA
AAAIAAA
AAAAAAA

Responder: I

vvqvvvvvvv
vvvvvvvvvv
vvvvvvvvvv
vvvvvvvvvv
vvvvvvvvvv

Responder: q

puuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu

Responder: p

Generador

Aquí hay un generador de matriz aleatorio escrito en Python que puede usar para probar su programa. Nota: Existe una pequeña posibilidad de que pueda cometer un error y no poner una letra extraña.

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)

Pruébalo en línea!

J , 12 10 7 bytes

-.}./.~

Pruébalo en línea!

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

Versión de 10 bytes

-._1 1{\:~

^{siseo ...}

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

Brachylog , 8 4 bytes

oḅ∋≠

Pruébalo en línea!

Explicación

No he usado Brachylog antes, por lo que esto puede no ser óptimo.

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

Solución

*<#:'=

Pruébalo en línea!

Ejemplo:

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

Explicación:

Encontró un enfoque un poco más corto: evaluado de derecha a izquierda:

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

Notas:

Si bien espero que se elimine el aspecto adicional de este desafío, esta solución devolverá el carácter de nueva línea \nsi no hay un carácter extraño:

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

Prólogo (SWI) , 46 bytes

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

Pruébalo en línea!

O si el resultado verdadero estándar de las consultas de prólogo no está bien:

Prólogo (SWI) , 48 bytes

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

Pruébalo en línea!

Explicación

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

Mucho más corto como una función

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

Pruébalo en línea!

código de prueba

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

la versión anterior es un 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 el carácter impar, o nada. corre así;

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

Guardado 2 bytes gracias a Adnan

.m

Pruébalo en línea!

Explicación

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

Retina , 13 bytes

s(O`.
(.)\1+

Pruébalo en línea!

Explicación

s(O`.

Ordenar todos los personajes.

(.)\1+

Elimina los caracteres que aparezcan al menos dos veces.

Casco , 2 bytes

◄=

Pruébalo en línea!

Esta es una función que toma una cadena como entrada y devuelve un carácter. Se necesita el mínimo de la cadena de entrada al comparar caracteres para igualdad (es decir, devuelve el carácter que es igual al menor número de otros caracteres).

C, 94 bytes

Regreso por puntero. Si no hay ninguno, regrese \0.

Esto provocará pérdidas de memoria. Suponiendo que intes de 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;}

Pruébalo en línea!

Mathematica, 27 bytes

Last@*Keys@*CharacterCounts

Pruébalo en línea!

-1 byte de Martin Ender

Bash , 15 20 bytes

fold -1|sort|uniq -u

Pruébalo en línea!

Explicación: fold s la entrada al 1carácter por línea, sorts en grupos de letras coincidentes, luego imprime solo las líneas que son unique.

Gracias @Nahuel Fouilleul por atrapar y ayudar a solucionar un problema con este enfoque.

Pyth , 4 bytes

ho/Q

Pruébalo aquí!

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

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

pruébalo en línea

Matlab, 25 bytes

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

La entrada "a" donde "a" no es el modo de "a". Emite una matriz vacía para ningún bicho raro.

Haskell, 33 * 0.75 = 24.75 bytes

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

Devuelve una lista vacía si no hay caracteres extraños.

Pruébalo en línea!

Para cada carácter cen la matriz (dado como una cadena s), haga una cadena de todos los caracteres sque sean iguales cy mantenga los de longitud 1.

JavaScript (ES6), 37 bytes

Devuelve nullsi no hay letras impares.

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

Casos de prueba

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

Toma la entrada como una cadena de varias líneas y genera una cadena de un solo carácter, o una cadena vacía si no hay solución.

k@èX É

Intentalo

Explicación

Elimine los caracteres que devuelven verdadero ( k) cuando se pasa a través de una función ( @) que cuenta ( è) las ocurrencias del elemento actual ( X) en la entrada y resta 1 ( É).

Lisp común, 47 bytes

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

Pruébalo en línea!

Devuelve la letra impar o NIL si no existe.

Jalea , 4 bytes

ċ@ÐṂ

Pruébalo en línea!

Regresar \n(una nueva línea) en caso de que no haya un carácter impar. Obviamente \nno es un personaje imprimible.

Casualmente, este es exactamente el mismo algoritmo que la respuesta Mr.Xcoder Python. (Se me ocurrió de forma independiente)

Explicación:

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

Eso funciona porque en una m×nmatriz:

• Si existe un carácter impar: hay m-1líneas nuevas, 1 carácter impar y m×n-1carácter normal, y 1 < m-1 < m×n-1porque 5 ≤ m, n ≤ 10.
• Si no existe un carácter extraño: hay m-1líneas nuevas y m×ncaracteres normales, y m-1 < m×n.

C # (.NET Core) , 54 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

• Gracias a Gastropner por el xor y? trucos (-3 bytes)
• Se modificó la versión de comparación para corregir errores y se utilizó la magia de Gastropner de los comentarios.

Explicación:

Compara los caracteres actuales y anteriores mientras saltas las nuevas líneas. Si es diferente, compare con el siguiente personaje. Esto nos dice si devolvemos los caracteres actuales o anteriores. La función devuelve el valor char "impar" si existe o 0 si la matriz no es impar. Nos salimos con la "próxima" verificación de caracteres porque siempre hay una nueva línea antes del \0carácter. Si no hay caracteres impares, retornamos intrínsecamente el \ 0 del ciclo for.

Código xor más antiguo y sexy Explicación:

Haga una máscara xor en ejecución de los siguientes 3 valores de cadena. Si son todos iguales, entonces el valor será igual a cualquiera de los tres. Si son diferentes, entonces los 2 idénticos se cancelarán entre sí dejando el único.

Debe factorizar / n antes del xor o se vuelve desordenado. También debe verificar 2 caracteres para la desigualdad en caso de que s [0] sea el valor impar. Esto cuesta el extra || cheque.

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

Octava , 26 25 bytes

1 byte guardado gracias a @Giuseppe

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

Función anónima que toma una matriz de caracteres 2D como entrada y emite la letra impar o una cadena vacía si no existe.

Pruébalo en línea!

Alice , 16 * 75% = 12 bytes

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

Pruébalo en línea!

Salidas Jabberwockysi no hay caracteres duplicados.

Explicación

/...@
\.../

Este es un marco para programas lineales que operan completamente en Ordinal (modo de procesamiento de cadenas). El código real se ejecuta en zigzag y se despliega para:

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".

En lugar de &-, también podríamos usar ey(transliteración a una cadena vacía). Alternativamente, al gastar un carácter más en la manipulación de la pila, también podríamos deduplicar la entrada que nos permite eliminar los caracteres no deseados N, pero sigue siendo el mismo número de bytes:

i.D.QXN.n*o@

Alice , 13 bytes

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

Pruébalo en línea!

Esta es la solución sin la bonificación, simplemente falta la .n*.

Retina , 22 bytes

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

Pruébalo en línea! Solo requiere altura y ancho de al menos 3, en lugar de 5.

APL + WIN, 16 bytes

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

Solicita la entrada de pantalla y genera letras impares o nada si no hay letras impares

PowerShell , 39 bytes

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

Pruébalo en línea!

Toma la entrada como una cadena con nuevas líneas (como se especifica en el desafío), la convierte en una charmatriz. Luego, Group-Objectlos personajes, de modo que los personajes se agrupan por sus nombres, luego en sortfunción de la cbúsqueda. Esto asegura que el personaje solitario sea el primero, por lo que tomamos el [0]índice y lo sacamos .Name.

Si la nueva línea es aceptable para "nada", entonces esto califica para el bono.

Perl 6 ,  27  24-25% = 18 bytes

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

Pruébalo

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

Pruébalo

Esto devolverá un valor indefinido cuando se le da una entrada que no tiene un carácter extraño.

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

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

Pruébalo en línea

Imprime la letra de la matriz si no hay ninguna extraña

Java 8, 85 bytes

Este es un lambda de Stringa String(por ejemplo Function<String, String>). Es esencialmente una copia de la solución de Luca , pero he reducido un poco la clasificación de cadenas.

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

Pruébalo en línea