Objectif

Écrivez un programme ou une fonction (ou équivalent) qui trie et renvoie la lettre impaire dans la matrice de taille aléatoire.

Détails

Vous recevrez une matrice (sous forme de chaîne) en entrée de dimensions aléatoires comme celle-ci.

bbbbbbbbbb
bbbbbdbbbb
bbbbbbbbbb
bbbbbbbbbb
bbbbbbbbbb

Votre travail consiste à trouver la lettre qui ne correspond pas au reste (dans ce cas, elle se dtrouve à la ligne 2, col 6) et à renvoyer cette lettre en sortie. La matrice sera composée de lettres A-Z, de a-znouvelles lignes ( \n, uniquement aux extrémités des lignes) et aura des dimensions allant de 5x5 à 10x10 (25-100 lettres).

Des échappatoires standard s'appliquent. Il s'agit d'un défi de golf de code; entrée avec le code du moins d'octets gagne.

Contribution

L'entrée sera transmise via l'entrée standard sous forme de chaîne s'il s'agit d'un programme ou d'argument s'il s'agit d'une fonction (ou similaire).

Production

Un seul caractère qui est le « bizarre » dans la matrice ou None , nil, NULou la chaîne "None"s'il n'y a pas de caractère « étrange ».

Plus d'exemples

AAAAAAA
AAAAAAA
AAAAAAA
AAAIAAA
AAAAAAA

Réponse: I

vvqvvvvvvv
vvvvvvvvvv
vvvvvvvvvv
vvvvvvvvvv
vvvvvvvvvv

Réponse: q

puuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu

Réponse: p

Générateur

Voici un générateur de matrice aléatoire écrit en Python que vous pouvez utiliser pour tester votre programme. Remarque: Il y a une légère chance qu'il puisse faire une erreur et ne pas mettre une lettre bizarre.

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 octets

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

Essayez-le en ligne!

J , 12 10 7 octets

-.}./.~

Essayez-le en ligne!

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

Version 10 octets

-._1 1{\:~

^{siffle ...}

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

Brachylog , 8 4 octets

oḅ∋≠

Essayez-le en ligne!

Explication

Je n'ai jamais utilisé Brachylog auparavant, donc ce n'est peut-être pas optimal.

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 octets

Solution

*<#:'=

Essayez-le en ligne!

Exemple:

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

Explication:

Trouvé une approche légèrement plus courte: Évalué de droite à gauche:

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

Remarques:

Alors que je m'attends à ce que l'aspect bonus de ce défi soit abandonné, cette solution retournera le caractère de nouvelle ligne \ns'il n'y a pas de caractère impair:

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

Prolog (SWI) , 46 octets

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

Essayez-le en ligne!

Ou si la sortie vraie standard des requêtes prolog n'est pas correcte:

Prolog (SWI) , 48 octets

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

Essayez-le en ligne!

Explication

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 octets

Beaucoup plus court en fonction

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

Essayez-le en ligne!

code de test

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

l'ancienne version est un programme

C 86 octets

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

Sort le caractère impair, ou rien. courir comme ça;

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 octets

Enregistré 2 octets grâce à Adnan

.m

Essayez-le en ligne!

Explication

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

Rétine , 13 octets

s(O`.
(.)\1+

Essayez-le en ligne!

Explication

s(O`.

Triez tous les caractères.

(.)\1+

Supprimez tous les caractères qui apparaissent au moins deux fois.

Husk , 2 octets

◄=

Essayez-le en ligne!

Il s'agit d'une fonction prenant une chaîne en entrée et renvoyant un caractère. Il prend le minimum de la chaîne d'entrée lors de la comparaison des caractères pour l'égalité (c'est-à-dire qu'il renvoie le caractère qui est égal au moins grand nombre d'autres caractères).

C, 94 octets

Retour par pointeur. Si aucun, revenez \0.

Cela entraînera des fuites de mémoire. En supposant que intc'est 4 octets.

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

Essayez-le en ligne!

Mathematica, 27 octets

Last@*Keys@*CharacterCounts

Essayez-le en ligne!

-1 octet de Martin Ender

Bash , 15 20 octets

fold -1|sort|uniq -u

Essayez-le en ligne!

Explication: fold s l'entrée du 1caractère par ligne, sorts en groupes de lettres correspondantes, puis imprime uniquement les lignes qui sont unique.

Merci à @Nahuel Fouilleul d' avoir attrapé et aidé à résoudre un problème avec cette approche.

Pyth , 4 octets

ho/Q

Essayez-le ici!

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

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

essayez-le en ligne

Matlab, 25 octets

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

L'entrée "a" où "a" n'est pas le mode de "a". Produit un tableau vide pour aucune excuse.

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

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

Renvoie une liste vide s'il n'y a pas de caractère impair.

Essayez-le en ligne!

Pour chaque caractère cde la matrice (donné sous forme de chaîne s), créez une chaîne de tous les caractères ségaux à cet conservez ceux de longueur 1.

JavaScript (ES6), 37 octets

Renvoie nulls'il n'y a pas de lettre impaire.

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

Cas de test

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 octets

Prend l'entrée sous la forme d'une chaîne multi-lignes et génère une chaîne de caractères unique ou une chaîne vide s'il n'y a pas de solution.

k@èX É

Essayez-le

Explication

Supprimez les caractères qui retournent truey ( k) lorsqu'ils sont passés par une fonction ( @) qui compte ( è) les occurrences de l'élément courant ( X) dans l'entrée et soustrait 1 ( É).

Lisp commun, 47 octets

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

Essayez-le en ligne!

Renvoie la lettre impaire ou NIL si elle n'existe pas.

Gelée , 4 octets

ċ@ÐṂ

Essayez-le en ligne!

Retour \n(une seule nouvelle ligne) au cas où il n'y aurait pas de caractère impair. Ce \nn'est évidemment pas un caractère imprimable.

Par coïncidence, c'est exactement le même algorithme que la réponse Mr.Xcoder Python. (Je l'ai trouvé indépendamment)

Explication:

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

Cela fonctionne parce que dans une m×nmatrice:

• S'il existe un caractère impair: Il y a des m-1sauts de ligne, 1 caractère impair et m×n-1un caractère normal, et 1 < m-1 < m×n-1parce que 5 ≤ m, n ≤ 10.
• S'il n'y a pas de caractère impair: il y a des m-1sauts de ligne et m×nun caractère normal, et m-1 < m×n.

C # (.NET Core) , 54 octets

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

Essayez-le en ligne!

C (gcc) , 91 86 82 79 71 octets

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

Essayez-le en ligne!

• Merci à Gastropner pour le xor et? astuces (-3 octets)
• Retravaillé la version de comparaison pour corriger les bugs et utilisé la magie Gastropner à partir des commentaires.

Explication:

Comparez les caractères actuels et précédents tout en sautant les nouvelles lignes. Si différent, comparez au caractère suivant. Cela nous indique si nous renvoyons le caractère actuel ou précédent. La fonction renvoie la valeur de caractère "impair" si elle existe ou 0 si le tableau n'est pas impair. Nous nous en sortons avec le "prochain" chèque car il y a toujours une nouvelle ligne avant le caractère \0. S'il n'y a pas de caractère impair, nous renvoyons intrinsèquement le \ 0 de la boucle for.

Code xor plus ancien et plus sexy Explication:

Créez un masque xor en cours d'exécution des 3 valeurs de chaîne suivantes. S'ils sont tous identiques, la valeur sera égale à l'un des trois. S'ils sont différents, alors les 2 identiques s'annuleront en laissant l'unique.

Doit factoriser / n avant le xor ou il devient désordonné. Vous devez également vérifier l'inégalité de 2 caractères dans le cas où s [0] est la valeur impaire. Cela coûte plus cher || vérifier.

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

Octave , 26 25 octets

1 octet enregistré grâce à @Giuseppe

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

Fonction anonyme qui prend un tableau de caractères 2D en entrée et génère la lettre impaire ou une chaîne vide si elle n'existe pas.

Essayez-le en ligne!

Alice , 16 * 75% = 12 octets

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

Essayez-le en ligne!

Sort Jabberwockys'il n'y a pas de caractère en double.

Explication

/...@
\.../

Il s'agit d'un cadre pour les programmes linéaires qui fonctionnent entièrement en ordinal (mode de traitement de chaîne). Le code réel est exécuté en zigzag et se déroule pour:

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

Au lieu de &-, nous pourrions également utiliser ey(translittération dans une chaîne vide). Alternativement, en dépensant un caractère de plus pour la manipulation de la pile, nous pourrions également dédupliquer l'entrée qui nous permet de supprimer les caractères indésirables avec N, mais c'est toujours le même nombre d'octets:

i.D.QXN.n*o@

Alice , 13 octets

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

Essayez-le en ligne!

Ceci est la solution sans bonus, il manque simplement le .n*.

Rétine , 22 octets

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

Essayez-le en ligne! Nécessite seulement une hauteur et une largeur d'au moins 3, au lieu de 5.

APL + WIN, 16 octets

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

Invite à saisir l'écran et génère une lettre impaire ou rien s'il n'y a pas de lettre impaire

PowerShell , 39 octets

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

Essayez-le en ligne!

Prend l'entrée sous forme de chaîne avec des retours à la ligne (comme spécifié dans le défi), la convertit en un chartableau. Nous avons ensuite Group-Objectles personnages, afin que les personnages soient regroupés par leurs noms, puis en sortfonction du cnombre. Cela garantit que le caractère solitaire est le premier, nous prenons donc l' [0]index et le sortons .Name.

Si la nouvelle ligne est acceptable pour «rien», cela donne droit au bonus.

Perl 6 ,  27  24-25% = 18 octets

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

Essaye-le

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

Essaye-le

Cela renverra une valeur indéfinie quand une entrée ne contient pas de caractère impair.

Étendu:

{  # 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 octets

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

Essayez-le en ligne

Imprime la lettre de la matrice s'il n'y en a pas de bizarre

Java 8, 85 octets

Il s'agit d'un lambda de Stringà String(par exemple Function<String, String>). C'est essentiellement une copie de la solution de Luca , mais j'ai un peu réduit le tri des chaînes.

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

Essayez-le en ligne