_{Basé sur cette question de Code Review}

Étant donné une chaîne non vide de caractères ASCII imprimables, affichez le deuxième caractère non répétitif. Par exemple, pour l'entrée DEFD, la sortie F.

Contribution

• Une seule chaîne, dans n'importe quel format approprié .

Production

• Le deuxième caractère qui ne se répète pas, lors de la lecture de gauche à droite, à nouveau dans un format approprié.
• Le caractère de sortie est insensible à la casse.
• Si un tel caractère n'existe pas (par exemple, tous les caractères se répètent), sortez une chaîne vide.

Règles

• L'algorithme doit ignorer la casse. Autrement dit, Det dcomptez comme le même personnage.
• Un programme complet ou une fonction sont acceptables.
• La chaîne d'entrée sera garantie non vide (c'est-à-dire, au moins un caractère de longueur).
• La chaîne d'entrée est ASCII. Tout caractère valide peut se répéter, pas seulement alphanumérique (cela inclut les espaces).
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Exemples

L'entrée est sur la première ligne, la sortie est sur la deuxième ligne.

DEFD
F

FEED
D

This is an example input sentence.
x

...,,,..,,!@
@

ABCDefgHijklMNOPqrsTuVWxyz
B

AAAAAABBBBB


Thisxthis


This this.
.

MATL , 11 octets

tk&=s1=)FT)

Cela se termine avec une erreur (autorisée par défaut) s'il n'y a pas de deuxième caractère non répété.

Essayez-le en ligne!

Explication

t      % Implicitly take input string. Duplicate
k      % Convert to lowercase
&=     % 2D array of equality comparisons
s      % Sum of each column
1=     % True for entries that equal 1
)      % Apply logical index to the input string to keep non-repeated characters
TF)    % Apply logical index to take 2nd element if it exists. Implicitly display 

Rétine , 25 octets

i!2=`(.)(?<!\1.+)(?!.*\1)

Essayez-le en ligne! (La première ligne permet d'exécuter le code sur une suite de tests de plusieurs entrées.)

Explication

Ceci est juste une correspondance regex unique, la regex étant:

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

Autrement dit, faites correspondre un caractère et assurez-vous qu'il n'apparaît nulle part ailleurs dans l'entrée. Le reste est la configuration:

• i active l'insensibilité à la casse.
• ! dit à Retina d'imprimer les correspondances au lieu de les compter.
• 2= indique à Retina de n'imprimer que la deuxième correspondance, par opposition à toutes.

05AB1E, 15 12 octets

l©v®y¢iy}}1@

Expliqué

l©            # store lower case string in register
  v     }     # for each char in lower case string
   ®y¢iy      # if it occurs once in string, push it to stack
         }    # end if
          1@  # push the 2nd element from stack and implicitly display

Essayez-le en ligne

Sauvegardé 3 octets grâce à @Adnan

Python 2, 59 58 octets

Renvoie une liste d'un seul caractère ou une liste vide si aucune sortie. (Insensibilité à la casse stupide ...)

s=input().lower();print[c for c in s if s.count(c)<2][1:2]

Essayez-le en ligne

Gelée , 11 octets

Œlµḟœ-Q$Ḋḣ1

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça fonctionne

Œlµḟœ-Q$Ḋḣ1  Main link. Argument: s (string)

Œl           Convert s to lowercase.
  µ          Begin a new, monadic chain. Argument: s (lowercase string)
       $     Combine the two links to the left into a monadic chain.
      Q        Unique; yield the first occurrence of each character.
    œ-         Perform multiset subtraction, removing the last occurrence of each
               character.
   ḟ         Filterfalse; keep characters that do not appear in the difference.
        Ḋ    Dequeue; remove the first character.
         ḣ1  Head 1; remove everything but the first character.

Lot, 171 octets

@echo off
set a=.
set s=%~1
:l
if "%s%"=="" exit/b
set c=%s:~0,1%
call set t=%%s:%c%=%%
if "%s:~1%"=="%t%" set a=%a%%c%
set s=%t%
if "%a:~2%"=="" goto l
echo %c%

Formulation alternative, également 171 octets:

@echo off
set a=.
set s=%~1
:l
if "%s%"=="" exit/b
set c=%s:~0,1%
set t=%s:~1%
call set s=%%s:%c%=%%
if "%s%"=="%t%" set a=%a%%c%
if "%a:~2%"=="" goto l
echo %c%

Pyth, 16 15 octets

1 octet grâce à @ mbomb007

= rz1.xhtfq1 / zTzk
= rz1: fq1 / zTz1 2

Suite de tests.

En fait, 19 octets

;╗`ù╜ùc1=`░ε;(qq1@E

Essayez-le en ligne!

Explication:

;╗`ù╜ùc1=`░ε;(qq1@E
;╗                   push a copy of input to reg0
  `ù╜ùc1=`░          [v for v in s if
   ù╜ùc1=              s.lower().count(v.lower()) == 1]
           ε;(qq     append two empty strings to the list
                1@E  element at index 1 (second element)

C #, 129 128 octets

char c(string i){var s=i.Where((n,m)=>i.ToLower().Where(o=>o==Char.ToLower(n)).Count()<2).ToArray();return s.Length>1?s[1]:' ';}

fonctionne bien. J'aimerais ne pas avoir besoin de tout mettre en minuscules

C # lambda avec Linq, 63 octets

s=>(s=s.ToUpper()).Where(c=>s.Count(C=>c==C)<2).Skip(1).First()

C #, 141 octets

void p(){var x=Console.ReadLine().ToLower();var c=0;foreach(char i in x){if(x.Split(i).Length-1<2){if(++c==2){Console.WriteLine(i);break;}}}}

Sans interruption (le plus petit), 135 octets

void p(){var x=Console.ReadLine().ToLower();var c=0;foreach(char i in x){if(x.Split(i).Length-1<2){if(++c==2){Console.WriteLine(i);}}}}

Avec pour (;;), 150 octets

void p(){for(;;){var x=Console.ReadLine().ToLower();var c=0;foreach(char i in x){if(x.Split(i).Length-1<2){if(++c==2){Console.WriteLine(i);break;}}}}}

Non golfé avec des commentaires

void p()
{
    var x=Console.ReadLine().ToLower();//Get lowercase version of input from STDIN
    var c=0; //Create "count" integer
    foreach(char i in x){//For each char in input from STDIN
        if(x.Split(i).Length-1<2)//If current char occurs once in input from STDIN
        {
            if(++c==2){ //Add 1 to count and if count is 2
                Console.WriteLine(i); //Print result to STDOUT
                break; //Exit foreach
            } //End of IF
         } //End of IF
     } //End of FOREACH
} //End of VOID

12 octets enregistrés par TuukkaX (changez le nombre en c).

3 octets enregistrés par TuukkaX (changez la chaîne en var).

4 octets enregistrés par TuukkaX dans "With for (;;)" (changé en (true) en for (;;)).

2 octets enregistrés par TuukkaX (changé c ++; if (c == 2) en if (++ c == 2)).

14 octets enregistrés par Bryce Wagner (changé x.ToCharArray () en x).

code machine x86, 43 octets

En hex:

FC31C031C95641AC84C0740E3C6172F63C7A77F28066FFDFEBEC5EAC49740B89F751F2AE5974F44A77F1C3

La fonction prend un pointeur sur la chaîne d'entrée dans (E) SI et un entier dans (E) DX et renvoie le (E) DX-ème caractère non répétitif ou zéro s'il n'y a pas un tel caractère. Comme effet secondaire, il convertit la chaîne en majuscules.

Démontage:

fc             cld
31 c0          xor    eax,eax
31 c9          xor    ecx,ecx
56             push   esi
_loop0:                         ;Search for the NULL char,
41             inc    ecx       ;counting the length in the process
ac             lodsb
84 c0          test   al,al
74 0e          je     _break0   ;NULL found, break
3c 61          cmp    al,0x61   ;If char is
72 f6          jb     _loop0    ;between 'a' and 'z'
3c 7a          cmp    al,0x7a   ;convert this char
77 f2          ja     _loop0    ;to uppercase in-place
80 66 ff df    and    byte ptr [esi-0x1],0xdf
eb ec          jmp    _loop0
_break0:
5e             pop    esi       ;Reset pointer to the string
_loop:                          ;ECX=string length with NULL
ac             lodsb            ;Load next char to AL
49             dec    ecx
74 0b          je     _ret      ;End of string found, break (AL==0)
89 f7          mov    edi,esi   ;EDI points to the next char
51             push   ecx
f2 ae          repnz scasb      ;Search for AL in the rest of the string
59             pop    ecx
74 f4          je     _loop     ;ZF==1 <=> another instance found, continue
4a             dec    edx
77 f1          ja     _loop     ;If not yet the EDX-th non-rep char, continue
_ret:
c3             ret

APL, 32 octets

{⊃1↓⍵/⍨1=+/∘.=⍨(⎕UCS ⍵)+32×⍵∊⎕A}

Essayez-le || Tous les cas de test

Explication:

                (⎕UCS ⍵)+32×⍵∊⎕A  Add 32 to uppercase letters
            ∘.=⍨                    Make an equality matrix
          +/                        Check how many matches
    ⍵/⍨1=                           Keep elements with 1 match
  1↓                                Drop the first one
⊃                                   Return the second one

J'étais sur le point de le poster avec 16 octets, mais j'ai réalisé qu'il devait être insensible à la casse ...

Rétine, 43 36 octets

iM!`(.)(?<!\1.+)(?!.*\1)
!`(?<=^.¶).

Essayez-le en ligne!

Mathematica, 49 octets

Cases[Tally@ToUpperCase@#,{_,1}][[2,1]]~Check~""&

Fonction anonyme. Prend une liste de caractères en entrée. Ignorez toutes les erreurs générées.

JavaScript (Firefox 48 ou version antérieure), 60 octets

f=s=>(m=s.match(/(.).*\1/i))?f(s.replace(m[1],"","gi")):s[1]

Renvoie undefineds'il n'y a que zéro ou un caractère non répétitif. Fonctionne en supprimant de manière insensible à la casse toutes les occurrences de caractères qui apparaissent plusieurs fois dans la chaîne. Repose sur une extension Firefox non standard qui a été supprimée dans Firefox 49. 119 Version ES6 91 octets:

f=s=>(m=s.match(/(.).*?(\1)(.*\1)?/i))?f((m[3]?s:s.replace(m[2],"")).replace(m[1],"")):s[1]

Recherche récursivement tous les caractères qui apparaissent au moins deux fois dans la chaîne. Si le caractère apparaît exactement deux fois, les deux occurrences sont supprimées, sinon seule la première occurrence est supprimée (les autres occurrences seront supprimées ultérieurement). Cela permet aux occurrences d'avoir un cas de différence.

J, 25 octets

(1{2{.]-.]#~1-~:)@tolower

Usage

   f =: (1{2{.]-.]#~1-~:)@tolower
   f 'DEFD'
f
   f 'FEED'
d
   f 'This is an example input sentence.'
x
   f '...,,,..,,!@'
@
   f 'ABCDefgHijklMNOPqrsTuVWxyz'
b
   f 'AAAAAABBBBB'

   f 'Thisxthis'

   f 'This this.'
.

Explication

(1{2{.]-.]#~1-~:)@tolower  Input: s
                  tolower  Converts the string s to lowercase
              ~:           Mark the indices where the first time a char appears
            1-             Complement it
         ]                 Identity function to get s
          #~               Copy only the chars appearing more than once
      ]                    Identity function to get s
       -.                  Remove all the chars from s appearing more than once
   2{.                     Take the first 2 chars from the result (pad with empty string)
 1{                        Take the second char at index 1 and return it

Bash, 58 octets

tr A-Z a-z>t
tr -dc "`fold -1<t|sort|uniq -u`"<t|cut -c2

Attention: Cela crée un fichier temporaire nommé t . S'il existe déjà, il sera écrasé.

C, 174 octets

int c(char*s){int y=128,z=256,c[384],t;memset(c,0,z*6);for(;t=toupper(*s);s++){c[t]++?c[t]-2?0:c[z+(c[y+c[z+t]]=c[y+t])]=c[z+t]:c[z]=c[y+(c[z+t]=c[z])]=t;}return c[y+c[y]];}

Ce n'est pas la mise en œuvre la plus courte mais la plus efficace. En substance, il utilise une liste à double liaison pour conserver un ensemble ordonné de caractères candidats et analyse la chaîne d'entrée une seule fois. Renvoie le code de caractère ou zéro s'il n'en trouve aucun.

Une version un peu non golfée:

int c(char*s)
{
    int y=128,z=256,c[384],t;
    //It's basically c[3][128], but with linear array the code is shorter

    memset(c,0,z*6);

    for(;t=toupper(*s);s++)
    {
        c[t]++ ?        // c[0][x] - number of char x's occurrence
            c[t] - 2 ?  // > 0
                0       // > 1 - nothing to do  
                : c[z + (c[y + c[z + t]] = c[y + t])] = c[z + t]  // == 1 - remove char from the list
            : c[z] = c[y + (c[z + t] = c[z])] = t; // == 0 - add char to the end of the list
    }
    return c[y + c[y]];
}

C #, 143 octets

char c(string s){var l=s.Select(o=>Char.ToLower(o)).GroupBy(x=>x).Where(n=>n.Count()<2).Select(m=>m.Key).ToList();return l.Count()>1?l[1]:' ';}

TSQL, 128 octets

Golfé:

DECLARE @ varchar(99)=',,zzzbb@kkkkkkJgg'

,@i INT=99WHILE @i>1SELECT
@i-=1,@=IIF(LEN(@)>LEN(x)+1,x,@)FROM(SELECT
REPLACE(@,SUBSTRING(@,@i,1),'')x)x PRINT SUBSTRING(@,2,1)

Non golfé:

DECLARE @ varchar(99)=',,zzzbb@kkkkkkJgg'

,@i INT=99

WHILE @i>1
  SELECT
    @i-=1,@=IIF(LEN(@)>LEN(x)+1,x,@)
  FROM
    (SELECT 
       REPLACE(@,SUBSTRING(@,@i,1),'')x
    )x

PRINT SUBSTRING(@,2,1)

Violon

Rubis, 53 octets

L'entrée est STDIN, la sortie est STDOUT. En Ruby, les positions hors index dans un tableau ou une chaîne retournent nil, qui n'est pas imprimée.

String#countest une fonction étrange dans Ruby car au lieu de compter le nombre d'occurrences pour la chaîne qui a été transmise, elle compte le nombre d'occurrences pour chaque lettre de cette chaîne. C'est généralement ennuyeux, mais nous pouvons l'utiliser à notre avantage cette fois. String#swapcasepermute les lettres majuscules et minuscules.

$><<gets.chars.reject{|c|$_.count(c+c.swapcase)>1}[1]

Ancienne version qui n'était pas sûre contre les caractères spéciaux comme .- 46 octets

$><<gets.chars.reject{|c|$_=~/#{c}.*#{c}/i}[1]

Java 8, 172157 octets

(String s)->{s=s.toLowerCase();for(char i=0,c;s.length()>0;s=s.replace(c+"","")){c=s.charAt(0);if(!s.matches(".*"+c+".*"+c+".*")&&++i>1)return c;}return' ';}

-15 octets .. Dang j'étais mauvais au golf à l'époque. ;)

Explication:

Essayez-le ici.

(String s)->{                          // Method with String parameter and character return-type
  s=s.toLowerCase();                   // Make the input-String lowercase
  for(char i=0,c;s.length()>0;         // Loop over the characters of `s`
      s=s.replace(c+"","")){           // And after every iteration, remove all occurrences of the previous iteration
    c=s.charAt(0);                     // Get the current first character
    if(!s.matches(".*"+c+".*"+c+".*")  // If it doesn't occur more than once
     &&++i>1)                          // And this was the second one we've found
      return c;                        // Return this second characters
  }                                    // End of loop
  return' ';                           // Else: return an empty character/nothing
}                                      // End of method

R , 79 octets

function(z){y=tolower(el(strsplit(z,"")));x=table(y);y[y%in%names(x[x==1])][2]}

Essayez-le en ligne!

J'ai vraiment l'impression que quelque chose peut être joué ici. Mais j'ai vraiment apprécié ce défi.

Cette réponse divise la chaîne en un vecteur de caractères, les change tous en minuscules et les table (les compte). Les caractères qui se produisent une fois sont sélectionnés et comparés aux caractères du vecteur susmentionné, puis la deuxième valeur vraie est renvoyée en sortie. Une chaîne vide ou une chaîne sans caractère répétitif génère NA.

Perl 6 , 38 32 octets

-6 octets grâce à nwellnhof en passant .combà une expression rationnelle insensible à la casse

{~grep({2>m:g:i/$^a/},.comb)[1]}

Essayez-le en ligne!

K (oK) / K4 , 11 octets

Solution:

*1_&1=#:'=_

Essayez-le en ligne!

Explication:

*1_&1=#:'=_ / the solution
          _ / convert input to lowercase
         =  / group alike characters
      #:'   / count (#:) each group
    1=      / 1 equal to length of the group?
   &        / where true
 1_         / drop the first
*           / take the first

Gelée, 15 octets

Œlµċ@Ị¥Ðf¹ḊḢȯ“”

Essayez-le en ligne!

Vérifiez tous les cas de test. (Légèrement modifié pour répondre à tous les cas de test)

Perl, 75 octets

 my$s=<>;chomp$s;my$c;for my$i(split//,$s){my$m=@{[$s=~/$i/gi]};$m<2and++$c>=2and say$i and last}

Javascript (à l'aide d'une bibliothèque externe) (107 octets)

Écrasé cela en utilisant une bibliothèque que j'ai écrite. Je ne sais pas si je dois compter la déclaration de la variable "s", qui est la chaîne en question.

(s)=>_.From(s).ToLookup(y=>y.toLowerCase(),z=>z).Where(g=>g.Value.Count()==1).Select(x=>x.Key).ElementAt(1)

Cela gérera une entrée de chaîne vide, une entrée avec un seul caractère non répétitif et une entrée avec 2+ caractères non répétitifs

Clojure, 109 octets

#(let[s(clojure.string/lower-case %)](or(second(remove(set(map(fn[[k v]](if(> v 1)k))(frequencies s)))s))""))

Ough, j'espère qu'il y a un moyen plus succinct.