_{Basierend auf dieser Frage von Code Review}

Geben Sie bei einer nicht leeren Zeichenfolge aus druckbaren ASCII-Zeichen das zweite nicht wiederholende Zeichen aus. Zum Beispiel für Eingabe DEFD, Ausgabe F.

Eingang

• Eine einzelne Zeichenfolge in einem beliebigen geeigneten Format .

Ausgabe

• Das zweite Zeichen, das beim Lesen von links nach rechts in einem geeigneten Format nicht wiederholt wird.
• Das Ausgabezeichen unterscheidet nicht zwischen Groß- und Kleinschreibung.
• Wenn kein solches Zeichen vorhanden ist (z. B. wenn sich alle Zeichen wiederholen), geben Sie eine leere Zeichenfolge aus.

Regeln

• Der Algorithmus sollte Groß- und Kleinschreibung ignorieren. Das heißt, Dund dzählen als das gleiche Zeichen.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig.
• Die Eingabezeichenfolge ist garantiert nicht leer (dh mindestens ein Zeichen lang).
• Die Eingabezeichenfolge ist ASCII. Jedes gültige Zeichen kann wiederholt werden, nicht nur alphanumerisch (einschließlich Leerzeichen).
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

Die Eingabe erfolgt in der ersten Zeile, die Ausgabe in der zweiten Zeile.

DEFD
F

FEED
D

This is an example input sentence.
x

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

ABCDefgHijklMNOPqrsTuVWxyz
B

AAAAAABBBBB


Thisxthis


This this.
.

MATL , 11 Bytes

tk&=s1=)FT)

Dies wird mit einem Fehler beendet (standardmäßig zulässig), wenn kein zweites nicht wiederholtes Zeichen vorhanden ist.

Probieren Sie es online!

Erläuterung

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 

Retina , 25 Bytes

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

Probieren Sie es online! (In der ersten Zeile kann der Code für eine Testsuite mit mehreren Eingaben ausgeführt werden.)

Erläuterung

Dies ist nur ein einziger regulärer Ausdruck, der reguläre Ausdruck ist:

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

Vergleichen Sie ein Zeichen und stellen Sie sicher, dass es an keiner anderen Stelle in der Eingabe angezeigt wird. Der Rest ist Konfiguration:

• i Aktiviert die Groß- und Kleinschreibung.
• ! weist Retina an, die Übereinstimmungen zu drucken, anstatt sie zu zählen.
• 2= weist Retina an, nur das zweite Match zu drucken, im Gegensatz zu allen.

05AB1E, 15 12 Bytes

l©v®y¢iy}}1@

Erklärt

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

Probieren Sie es online aus

3 Bytes gespart dank @Adnan

Python 2, 59 58 Bytes

Gibt eine Liste mit einem einzelnen Zeichen oder eine leere Liste zurück, wenn keine Ausgabe erfolgt. (Dumme Groß- / Kleinschreibung ...)

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

Probieren Sie es online aus

Jelly , 11 Bytes

Œlµḟœ-Q$Ḋḣ1

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Batch, 171 Bytes

@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%

Alternative Formulierung, auch 171 Bytes:

@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 Bytes

1 Byte danke an @ mbomb007

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

Testsuite.

Eigentlich 19 Bytes

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

Probieren Sie es online!

Erläuterung:

;╗`ù╜ù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 Bytes

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

funktioniert gut. Ich wünschte, ich müsste nicht alles klein schreiben

C # Lambda mit Linq, 63 Bytes

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

C #, 141 Bytes

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

Ohne Pause (kleinste), 135 Bytes

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

Mit für (;;) 150 Bytes

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

Ungolfed mit Kommentaren

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 Bytes, die von TuukkaX gespeichert wurden (Zählung in c ändern).

3 Bytes, die von TuukkaX gespeichert wurden (String in var ändern).

4 Bytes, die von TuukkaX in "With for (;;)" gespeichert wurden (geändert, während (true) in for (;;)).

2 Bytes, die von TuukkaX gespeichert wurden (geändert von c ++; if (c == 2) in if (++ c == 2)).

Von Bryce Wagner gespeicherte 14 Byte (x.ToCharArray () in x geändert).

x86-Maschinencode, 43 Byte

In hex:

FC31C031C95641AC84C0740E3C6172F63C7A77F28066FFDFEBEC5EAC49740B89F751F2AE5974F44A77F1C3

Function nimmt einen Zeiger auf die Eingabezeichenfolge in (E) SI und eine Ganzzahl in (E) DX und gibt das (E) DX-te nicht wiederholende Zeichen oder Null zurück, wenn es kein solches Zeichen gibt. Als Nebeneffekt konvertiert es die Zeichenfolge in Großbuchstaben.

Demontage:

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 Bytes

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

Probieren Sie es aus || Alle Testfälle

Erläuterung:

                (⎕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

Ich wollte es gerade mit 16 Bytes posten, aber als ich merkte, dass es zwischen Groß- und Kleinschreibung nicht unterschieden werden musste ...

Retina, 43 36 Bytes

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

Probieren Sie es online!

Mathematica, 49 Bytes

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

Anonyme Funktion. Nimmt eine Liste von Zeichen als Eingabe. Ignorieren Sie alle generierten Fehler.

JavaScript (Firefox 48 oder früher), 60 Byte

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

Gibt zurück, undefinedwenn es nur null oder ein sich nicht wiederholendes Zeichen gibt. Löscht alle Vorkommen von Zeichen, die mehr als einmal in der Zeichenfolge vorkommen. Stützt sich auf eine nicht standardmäßige Firefox-Erweiterung, die in Firefox 49 entfernt wurde. 119 91-Byte-ES6-Version:

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

Sucht rekursiv nach allen Zeichen, die in der Zeichenfolge mindestens zweimal vorkommen. Wenn das Zeichen genau zweimal vorkommt, werden beide Vorkommen gelöscht, andernfalls wird nur das erste Vorkommen gelöscht (die anderen Vorkommen werden später gelöscht). Dies ermöglicht es den Ereignissen, einen Differenzfall zu haben.

J, 25 Bytes

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

Verwendung

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

Erläuterung

(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 Bytes

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

Vorsicht: Dadurch wird eine temporäre Datei mit dem Namen t erstellt . Wenn es bereits existiert, wird es überschrieben.

C 174 Bytes

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

Dies ist nicht die kürzeste, aber sehr effiziente Implementierung. Im Wesentlichen wird eine doppelt verknüpfte Liste verwendet, um den geordneten Satz von Kandidatenzeichen zu verwalten und die Eingabezeichenfolge nur einmal zu scannen. Gibt den Zeichencode oder Null zurück, wenn keine gefunden wurde.

Ein bisschen ungolfed version:

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 Bytes

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 Bytes

Golf gespielt:

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)

Ungolfed:

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)

Geige

Ruby, 53 Bytes

Eingang ist STDIN, Ausgang ist STDOUT. In Ruby werden nicht indexierte Positionen in einem Array oder einer Zeichenfolge zurückgegeben nil, die nicht gedruckt werden.

String#countist eine seltsame Funktion in Ruby, da sie nicht die Anzahl der Vorkommen für die übergebene Zeichenfolge zählt, sondern die Anzahl der Vorkommen für jeden Buchstaben in dieser Zeichenfolge. Es ist normalerweise ärgerlich, aber diesmal können wir es zu unserem Vorteil nutzen. String#swapcasevertauscht Groß- und Kleinbuchstaben.

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

Alte Version, die gegen Sonderzeichen wie .- 46 Bytes nicht sicher war

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

Java 8, 172 157 Bytes

(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 Bytes. Mist, ich war damals schlecht im Golfen. ;)

Erläuterung:

Probieren Sie es hier aus.

(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 Bytes

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

Probieren Sie es online!

Ich habe definitiv das Gefühl, dass hier draußen etwas gespielt werden kann. Aber ich habe diese Herausforderung wirklich genossen.

Diese Antwort teilt die Zeichenfolge in einen Vektor von Zeichen auf, ändert sie alle in Kleinbuchstaben und tabelliert sie (zählt sie). Einmal vorkommende Zeichen werden ausgewählt und mit Zeichen innerhalb des oben genannten Vektors verglichen. Dann wird der zweite Wert, der wahr ist, als Ausgabe zurückgegeben. Eine leere Zeichenfolge oder eine Zeichenfolge ohne sich wiederholende Zeichen gibt NA aus.

Perl 6 , 38 32 Bytes

-6 Byte dank nwellnhof durch Umstellung .combauf Regex ohne Berücksichtigung der Groß- und Kleinschreibung

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

Probieren Sie es online!

K (oK) / K4 , 11 Bytes

Lösung:

*1_&1=#:'=_

Probieren Sie es online!

Erläuterung:

*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

Gelee, 15 Bytes

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

Probieren Sie es online!

Überprüfen Sie alle Testfälle. (Leicht modifiziert, um allen Testfällen gerecht zu werden)

Perl, 75 Bytes

 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 (mit externer Bibliothek) (107 Bytes)

Crushed dies mit einer Bibliothek, die ich geschrieben habe. Ich bin mir nicht sicher, ob ich die Deklaration der Variablen "s" zählen muss, bei der es sich um die fragliche Zeichenfolge handelt.

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

Dies behandelt eine leere Zeichenfolge-Eingabe, eine Eingabe mit nur einem sich nicht wiederholenden Zeichen und eine Eingabe mit 2+ sich nicht wiederholenden Zeichen

Clojure, 109 Bytes

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

Ich hoffe, es gibt einen prägnanteren Weg.