Geben Sie bei zwei gegebenen Zeichenfolgen eine dritte Zeichenfolge aus, die keiner der beiden Eingaben entspricht, jedoch dieselbe Länge (in Zeichen) wie eine der Eingaben hat. Es gibt garantiert mindestens eine gültige Ausgabe.

Testfälle

Testfälle werden zitiert, um zu zeigen, dass es sich um Zeichenfolgen handelt. Ausgänge sind einer von vielen möglichen.

input, input -> output

"test", "test" -> "tttt"
"do", "don't" -> "dnut_"
"ye s", "yes" -> "fals"
"yes", "yes" -> "noo"
"maybe", "mayue" -> "false"
"false", "false" -> "truee"
"false", "true" -> "fatr"
"1", "" -> "0"
"", "t" -> "s"
"", "abcabc" -> "testst"
"abcdefghijklmnopqrstuvwxyz", "aaaaaaaaaaaaaaaaaaaaaaaaaa" -> "zbcdefghijklmnopqrstuvwxya"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" -> "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"

Regeln

• Sie können Ihre Eingabedomäne auswählen, diese muss jedoch mindestens aus druckbarem ASCII-Code bestehen und Ihre Ausgabedomäne muss mit Ihrer Eingabedomäne identisch sein.
• Die Eingabelängen können gleich oder unterschiedlich sein.
• Die Ausgabe muss mit Wahrscheinlichkeit 1 gültig sein; Das heißt, Sie können zufällige Zeichenfolgen generieren, bis eine gültig ist (und theoretisch können Sie eine Endlosschleife erstellen), aber Sie können nicht einfach eine zufällige Zeichenfolge ausgeben und hoffen, dass sie gültig ist. Beachten Sie, dass dies bedeutet, dass Ihre Ausgabe nicht deterministisch sein muss.
• Automatisch nachgestellte Zeilenumbrüche sind zulässig, werden jedoch nicht für die Länge der Ausgabe berücksichtigt.
• Aufgrund von Fragen zu Speicherfehlern muss es innerhalb von 60 Sekunden bis zu einer Eingabelänge von funktionieren 6. Eine Antwort, die dafür funktioniert und theoretisch für längere Zeichenfolgen funktioniert, ist in Ordnung, aber etwas, das Memory Errors auf modernen Computern für die Eingabelänge 4nicht gültig ist.

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

05AB1E , 8 7 Bytes

øvAyм¬?

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Haskell, 43 Bytes

x!y=[s|s<-(<$max x y)<$>"abc",s/=x,s/=y]!!0

Nimmt die maximale (später lexikografisch) Zeichenfolge, von der wir wissen, dass sie nicht leer ist. Ersetzt alle Zeichen mit "a", "b" und "c". using <$; und gibt die erste zurück, die keine der Eingaben ist. Ich denke, dies ähnelt Neils Charcoal-Antwort und / oder Geokavel's CJam-Antwort .

(Ich habe eine Weile gelauert, aber dies ist das erste Mal, dass ich auf dieser Seite antworte; hi!)

Brainfuck, 97 Bytes

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

Code online ausführen (beachten Sie, dass "dynamischer Speicher" unten rechts ausgewählt sein muss)

Tolle Herausforderung! Ich dachte, es wäre trivial, aber es wurde wirklich schwierig. Ich komme immer darauf zurück , weil ich wie das Gefühl , es sollte einige elegante 20-oder-so-Byte BF Lösung sein. Zu diesem Zeitpunkt bin ich ziemlich froh, dass ich es (anscheinend) überhaupt in BF zum Laufen gebracht habe.

Die Eingabe erfolgt als str1+ \0+ str2, wobei Zeichenfolgen aufeinanderfolgende 1-Byte-Zeichen ungleich Null sind.

Rückgabe (first str1 + first str2) or (first str1 + 1) or 2. Dieser Algorithmus wurde von dem brillanten @ ØrjanJohansen ausgedacht, (vermutlich) basierend auf meinem (kaputten) Original.

Kommentiert:

# Let (Kn) be the nth character of K
# Let (^) designate the pointer
# Let F be the first string inputted
# Let S be the second string inputted

+>+[-  # Twice do
,[>>,]  # Input string (characters separated by 1)
<<[<<]>  # Go to left of beginning of string
]>  # End on first character of second string
# If second string is null we will end one too far to the left
>[>]<<<[<]>  # If first string is null we will end there too
# We will use this to do flow control

[  # Only run if both strings were non null

# Tape:    S0 ' F0 ' S1 ' F1 ' S2 ' F2 ' etc
#          ^

<+>>  # Let F0* = F0 (plus) 1  (is 1 as of now; F0 will be added later)
[-<+<+>>] # Let A = S0 (plus) F0
# A may or may not be zero
# F0* may or may not be zero
# Tape:    F0* ' A ' 0  ' S1 ' F1 ' etc
#                ^

[>]<[->+<]  # Let B = A or F0*
# B may or may not be zero
<[-]>>  # Clear F0*
# Tape:     0 ' B ' 0 ' S1 ' F1 ' etc    (if A was zero)
#               ^
# OR        0 ' 0 ' B ' s1 ' F1 ' etc    (if A was nonzero)
#                   ^

# Let C = B or 2
# C will be guaranteed nonzero and unique from S0 and F0
>++<[<]>  # Create C
[.>>]  # Print (using S or F; does not matter)

>[>>]  # End on a zero cells with zero cells all to the right
# This is necessary for the coming functionality
# also as to not loop
]  # End non null block

# Now we consider if one of the strings was null
# Tape:    0 ' E0 ' 0 ' E1 ' etc    (if one string was null)
#          ^
# Tape:    0 '  0 ' 0 '  0 ' etc    (if neither string was null)
#          ^
# Where E is F or S (we don't care)

>[  # Execute only if one string was null

+  # Let A = E0 (plus) 1
# A may or many not be zero
# Tape: 0 ' A ' 0 ' E1 ' etc
#           ^

[>]+[<]>  # Let B = A or 1
# B is guaranteed nonzero and != E0
# Tape: 0 ' B ' ? ' E1 ' 0 ' E2 ' etc
#           ^

[.>>]  # Print

# End on zero cell as not to loop
]  # End null block

Gelee , 8 Bytes

żḟ@€ØAZḢ

Probieren Sie es online!

Wie?

żḟ@€ØAZḢ - Link: list of characters, a; list of characters, b
ż        - zip a and b
    ØA   - uppercase alphabet
 ḟ@€     - filter discard for €ach (swap @rguments)
      Z  - transpose the result
       Ḣ - head

Python 3 , 62 47 57 54 51 Bytes

Bearbeiten: - 5 Bytes dank @ Mr.Xcoder

Bearbeiten: +10 Bytes, um einen Fehler zu beheben

Edit: -3 Bytes dank @betaveros

Bearbeiten: -3 Bytes mit max anstelle von pop

lambda x,y:max({*"abc"}-{x[:1],y[:1]})+max(x,y)[1:]

Probieren Sie es online!

Holzkohle , 22 Bytes

ＦＥα×ι⌈⟦ＬθＬη⟧¿¬№⟦θη⟧ιＰι

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Generiert alle Zeichenfolgen aus Großbuchstaben, die bis zur Länge der längeren Eingabe wiederholt werden, und überdruckt alle Zeichen, die nicht in der Eingabe enthalten sind. Mit anderen Worten, die Ausgabe erfolgt normalerweise, ZZZ...sofern es sich nicht um eine der Eingaben handelt. In diesem Fall handelt es sich YYY...um die andere Eingabe. In diesem Fall handelt es sich um eine Eingabe XXX....

Mathematica, 111 Bytes

(c=Characters;a=#2;While[f=Alphabet[]~RandomChoice~Length@#;f==#||f==c@a]&[#&@@c@{##}~MaximalBy~Length];""<>f)&

Online ausprobieren (Code mit Strg + V einfügen, Eingabe am Ende platzieren und Shift + Enter drücken)

Eingang

["teste mich"]

Danke @Nicht ein Baum zum Überprüfen und Golfen -21 Bytes

Perl 6 , 38 30 Bytes

{(1 x.max.comb...*∉$_).tail}

Probieren Sie es online!

Anonymer Codeblock, der die Eingabe als Liste mit zwei Zeichenfolgen annimmt und die erste Zahl 1111...mit einer nicht leeren Anzahl von Einsen zurückgibt, die nicht in der Eingabe enthalten ist.

Erläuterung:

{                          }   # Anonymous code block
  1 x.max.comb                 # String multiply 1 by the size of the non-empty string
              ...              # Create a sequence increasing by 1
                 *∉$_          # Until the number is not in the input
 (                   ).tail    # And take the last number

Zsh , 51 47 37 36 Bytes

-4 Bytes , die durch eingebaute Array argv, -10 Bytes Präfix Entfernung unter Verwendung und RC_EXPAND_PARAM, -1 - Byte durch die Klammer Expansion inlining.

<<<${${${:-{1..3}${^@#?}}:|argv}[1]}

Probieren Sie es online!

Zunächst war dies eine großartige Herausforderung. Ich habe eine Menge Ideen durchgearbeitet, bevor ich auf dieser landete.

<<<${${${:-{1..3}${^@#?}}:|argv}[1]}
       ${:-             }            # empty fallback
                 ${ @#?}             # remove first character from each parameter
                 ${^@  }             # enable brace expansion (set -P)
           {1..3}${^@#?}             # expand to 1foo 2foo 3foo 1bar 2bar 3bar
     ${                  :|argv}     # Set difference with 'argv'
   ${                           [1]} # The first found element
<<<                                  # print to stdout

@und *sind keine Bezeichner, also ${ :|@}und ${ :|*}funktionieren nicht, daher die Verwendung von${ :|argv}

Diese Methode funktioniert mit bis zu 93 Eingaben und findet eine 94., die einzigartig ist. Ersetzen Sie einfach die {1..3}durch die maximal mögliche Reichweite {~..!}.

Zsh , 48 47 Bytes *

for ((;$#i<${#${1:-$2}}||$@[(I)$i];i++)):
<<<$i

Probieren Sie es online!

Vollständig neue Methode mit freundlicher Genehmigung von JoKings Perl 6-Einreichung, funktioniert jedoch aufgrund von Beschränkungen der Ganzzahlgröße nicht für große Zeichenfolgen (n> 20). $@[(I)$i]Wenn die Array-Suche in umgekehrter Reihenfolge zum größten Index erfolgt, wird Null ausgegeben (falsch in der arithmetischen Erweiterung), wenn $ i nicht in den Befehlszeilenparametern gefunden wird.

MATL , 12 Bytes

c"1Y2@X-1)&h

Die Eingabe ist ein Zellenarray von Zeichenfolgen, die druckbare ASCII-Zeichen enthalten. Die Ausgabe wird aus den Buchstaben gebildet 'ABC'und gehört somit zur Eingabedomäne.

Probieren Sie es online!

Erläuterung

Die Ausgabe ist so lang wie die längste Eingabezeichenfolge. Das n- te Zeichen ist der erste Buchstabe 'ABC', der sich vom n- ten Zeichen beider Eingabezeichenfolgen unterscheidet.

c        % Concatenate the two strings vertically. If one is shorter it is
         % right-padded with spaces. Gives a 2-row character matrix
"        % For each column
  1Y2    %   Push the string 'ABC...Z' (the upper-case letters)
  @      %   Push current column
  X-     %   Set difference
  1)     %   Get first character
  &h     %   Horizontally concatenate the results so far
         % End (implicit). Display stack (implicit)

Haskell, 56 52 48 Bytes

x#y|_:t<-max x y=[c:t|c<-"abc",c:t/=x,c:t/=y]!!0

Probieren Sie es online!

Ersetzen des erste Zeichen des Maximums der beiden Eingänge Saiten a, bund , cund die ersten eine auswählen , die von beiden Eingabezeichenfolgen unterschiedlich ist.

Ruby , 53 Bytes

->a,b{([?a,?b,?c].map{|e|e*[a,b].max.size}-[a,b])[0]}

Probieren Sie es online!

Generiert im Grunde die Zeichenfolgen a...a, b...bund c...cund wählt die erste nicht in der Eingabe.

ES6, 54 Bytes

a=>b=>(a[0]+b[0]|0?'a':9-(a[0]^b[0]))+(a||b).substr(1)

Pyth, 7 8 Bytes

hC-LG.T

1 Byte danke an Jakube

Testsuite

Wir verwenden die .Tlängenerhaltende Transponierung und nicht das CAbschneiden der Transponierung, sodass sie bei Eingaben funktioniert, bei denen eine Zeichenfolge leer ist.

Wenn wir zwei Strings als Tupel gegeben haben, transponieren wir sie ( .T), ordnen dann das resultierende Zeichenpaar oder einzelne Zeichen zu, indem wir die Zeichen vom Lowerase-Alphabet mit subtrahieren -LG, transponieren dann die resultierende Liste von Strings nicht verwendeter Zeichen mit Cund kehren dann zurück die erste solche Zeichenfolge mit h. Dies besteht aus dem ersten Buchstaben in alphabetischer Reihenfolge, der für jede Position nicht in einer der beiden Zeichenfolgen enthalten ist.

Java (OpenJDK 8) , 100 73 Bytes

-27 Bytes dank der magischen Note von @ Nevay! :)

a->b->{b=b.length<1?a:b;if(a.length<1||(b[0]^=2)==a[0])b[0]^=1;return b;}

Probieren Sie es online!

Eingabedomäne = Druckbarer ASCII + Codepunkt 127.

Ruby, 56 Bytes

->a,b{a,b=b,a if a<b;a[0]=([?a,?b,?c]-[a[0],b[0]])[0];a}

Pyth , 23 22 Bytes

+.)-.{<G3.{,<Q1<KE1t|K

Probieren Sie es hier aus!

Pyth , 22 Bytes

+eS-.{<G3.{,<Q1<KE1t|K

Test Suite!

Erläuterung

+.)-.{<G3.{,<Q1<KE1t|K  - Full program.
      <G3               - Yields the String "abc"; Alphabet[:3].
    .{                  - Set formed by the above.
         .{,<Q1<KE1     - Set formed by input_1[:1] and input_2[:1]
   -                    - Set subtraction.
 .)                     - Pop the last element.
+                       - Append.
                   t|K  - input_1[1:] or input_2[1:], relying on the result of Logical OR.

Perl 5, 82 79 Bytes

sub{$_=$_[0];$_=$_[1]||$_ if/^(xz*)?$/;s/[^z]/z/||s/./y/;$_ eq$_[1]&&s/./x/;$_}

Nimmt Eingaben als zwei separate Argumente und gibt die dritte Zeichenfolge zurück.

Das Unterprogramm versucht, eine Zeichenfolge zu erzeugen, die der ersten Zeichenfolge sehr ähnlich ist, wobei jedoch das erste Nichtzeichen zdurch a ersetzt wird z. Dann werden Eckfälle behandelt, indem das erste Zeichen durch yoder ersetzt xwird, wenn festgestellt wird, dass es sich bei einer der Eingaben tatsächlich um eine Folge aller Zeichen handelt z.

Perl 5 , 68 Bytes

sub{$_="a"x length $_[0]||$_[1];$_++while $_ eq$_[0]||$_ eq$_[1];$_}

Erläuterung:

• beginnt mit (Zeichenfolge des Buchstabens "a" so lang wie die erste Zeichenfolge) oder der zweiten Zeichenfolge, wenn diese falsch ist, dh die Länge Null hat
• erhöht dies so lange, bis es sich sowohl vom ersten als auch vom zweiten unterscheidet

Ausgehend von "a" sollte vermieden werden, zu erhöhen, bis Perl die Zeichenfolge verlängert. Mit nur zwei Zeichenfolgen konnte es nicht überlaufen.

Ausführen mit:

perl -e '$s = ' -E 'sub{$_="a"x length $_[0]||$_[1];$_++while $_ eq$_[0]||$_ eq$_[1];$_}' -E ';say $s->("z", "true")'

C (gcc) ,70 65 73 67 61 Bytes

Für die Funktion müssen die bereitgestellten Zeichenfolgen veränderbar sein (dh entweder Arrays oder dynamisch zugewiesen).

f(a,b)char*a,*b;{a=*a?a:b;*a=*a>70?33:99;*a+=*a==*b;puts(a);}

Probieren Sie es online!

Funktioniert für den Standard-ASCII-Bereich

Erläuterung:

a=*a?a:b           // If a is empty, point to b instead
*a=*a>70?33:99     // Choose a different value for the 1st character of a,
                   // while giving enough space to increment it without 
                   // going back to its previous value
*a+=*a==*b         // Increment the 1st character of a if the arbitrary
                   // chosen value is equal to the value of the 1st 
                   // character of b
puts(a)            // Outputs a

R 89 67 Bytes

@ Giuseppe speicherte 9 Bytes, @ user2390246 speicherte 13 Bytes

Funktion

function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)

Demo

# define function
f <- function(x,y)sub("^.",letters[!letters%in%substr(c(x,y),1,1)][1],x)

# test cases
f("test","test")
[1] "aest"
f("do","don't")
[1] "ao"
f("ye s","yes")
[1] "ae s"
f("maybe","mayue")
[1] "aaybe"
f("false","false")
[1] "aalse"
f("false","true")
[1] "aalse"
f("1","")
[1] "a"
f("art","bug")
[1] "crt"

Java 8, 119 Bytes

Lambda (Curry) von Stringbis Lambda von Stringbis String. Zuweisen zu Function<String, Function<String, String>>.

s->t->{String r=s.length()>t.length()?s:t;while((s+t).contains(r))r=r.substring(1)+(char)(Math.random()*128);return r;}

Probieren Sie es online

Ungolfed Lambda

s ->
    t -> {
        String r = s.length() > t.length() ? s : t;
        while ((s + t).contains(r))
            r = r.substring(1) + (char) (Math.random() * 128);
        return r;
    }

Diese Lösung dreht zufällige ASCII-Zeichen in die längere Zeichenfolge, bis die erforderlichen Bedingungen erfüllt sind. Eingänge sind UTF-8 und Ausgänge sind ASCII.

Ich kenne die grundlegenden Details von Unicode nicht, aber es scheint mir plausibel, dass diese Lösung fehlschlagen könnte, wenn ein angefügtes charElement den vorhergehenden Codepunkt verbindet, um eine einzelne Codeeinheit zu bilden. Wenn jemand, der mehr darüber weiß, dies überprüfen kann, werde ich die Eingabedomäne in ASCII ändern.

Java 8, 126 Bytes

Gleicher Typ wie oben.

s->t->{String r;for(byte[]o=(s.length()>t.length()?s:t).getBytes();(s+t).contains(r=new String(o));o[0]%=128)o[0]++;return r;}

Probieren Sie es online

Ungolfed Lambda

s ->
    t -> {
        String r;
        for (
            byte[] o = (s.length() > t.length() ? s : t).getBytes();
            (s + t).contains(r = new String(o));
            o[0] %= 128
        )
            o[0]++;
        return r;
    }

Dadurch wird das erste Byte der längeren Zeichenfolge in ASCII-Zeilen erhöht, bis die erforderlichen Bedingungen erfüllt sind. Ein- und Ausgänge sind ASCII-Zeichenfolgen.

APL (Dyalog Unicode) , 11 Byte ^SBCS

Vollständiges Programm, Eingabe als verschachtelte Liste mit zwei Elementen.

⊃¨⎕A∘~¨,⌿↑⎕

Probieren Sie es online!

Bash, 115 .. 77 Bytes

Ersetzt das erste Zeichen der ersten (nicht leeren) Eingabezeichenfolge durch 1,2,3, bis für keine der Eingaben eine Übereinstimmung gefunden wird. Probieren Sie es online!

-9, -12, -9, -8 Bytes dank GammaFunction

x="${1:-$2}"
for s in {1..3}"${x:1}"
{ [[ $s = @($1|$2) ]]||break;}
echo "$s"

(eine ziemliche Verbesserung gegenüber dem Original ... )

Perl 5 , 79 + 1 (-p) = 80 Bytes

$"=<>;chop;$_=length($,=$_)>length$"?$_:$";s/./chr$&+65+$i++/e while/^($"|$,)$/

Probieren Sie es online!

Japt , 17 Bytes

;B¬£ñl g1 çXÃkU v

Wiederholt die Buchstaben A-Zbis zur Länge der längeren Eingabe, entfernt die Werte in der Eingabe und ruft das erste Element im Array ab.

Probieren Sie es online!

Alte Lösung, 18 Bytes

;@!UøX}a@ñl g1 çBö

Probieren Sie es online!

Wählt ein zufälliges Zeichen aus dem Alphabet und wiederholt es bis zur Länge der längeren Eingabezeichenfolge, bis es in der Eingabe nicht mehr vorhanden ist.

Python 3, 74 73 Bytes

-1 Byte dank Step Hen

def f(x,y,i=1):
 while i*10<10**len(x or y)or str(i)in x+y:i*=2
 print(i)

Gibt die niedrigste Ganzzahl mit derselben Länge aus wie die erste der Eingaben mit einer Länge ungleich Null.

Python 2, 77 Bytes

a=input()
b=ord(a[0][0])+1
if b==ord(a[1][0]):b+=1
print unichr(b)+a[0][1:-1]

Ich denke, es hat ein gewisses Potenzial. Die Idee ist, dass es dem 1. Zeichen in der 1. Zeichenfolge 1 hinzufügt und dann prüft, ob das 1. Zeichen des anderen Eingangs dasselbe ist.

** Beachten Sie, dass ^ keine Zeichenfolgen mit der Länge 0 verarbeitet und daher bei dieser Länge nicht wirklich funktioniert.

Hier ist eine super lange Lösung, die mit der Länge 0 funktioniert

146 Bytes

a=input()
def c(i):print unichr(ord(a[i][0])+1)+a[i][1:];exit();
for x in range(2):if len(a[x-1])<1:c(x)
if a[0]==a[1]:c(1)
print a[1][0]+a[0][1:]

Verbesserungen wären willkommen!

CJam, 31 30 23 Bytes

q~:A:e>,3,sf*{A\f=:+!}=

Übernimmt druckbares ASCII als Eingabe. Gibt entweder eine Zeichenfolge mit 0, 1 oder 2 aus, die dieselbe Länge wie eine der Eingabezeichenfolgen hat. Die Logik ist, dass eine dieser Zeichenfolgen keine der Eingabezeichenfolgen sein kann!

Probieren Sie es online

q~:A    e# Store input array as var 'A'
:e>,    e# Take the length of the lexicographically greater string in the input array
3,s     e# Generate "012"
f*      e# Repeat each number as many times as the longer string length, yielding something like ["000","111","222"]
{       e# Search array of number strings for first that returns true for this function
A\f=    e# Map each string in the input array to whether it equals the current number string (0,1)
:+!     e# Add up the array of bits and take the logical not. This returns true iff both array values were not equal to the current number string.
}=      e# Return the first number string that returns true.

C # (Mono) , 94 Bytes

s=>t=>{var r=s!=""?s:t;while(r==s|r==t)r=r.Substring(1).Insert(0,(char)(r[0]+1)+"");return r;}

Probieren Sie es online!