Avec deux chaînes, génère une troisième chaîne qui n'est pas égale à l'une des deux entrées, mais a la même longueur (en caractères) que l'une ou l'autre des entrées. Il est garanti qu’il existe au moins une sortie valide.

Cas de test

Les cas de test sont cités pour montrer qu'ils sont des chaînes. Les sorties sont l’un des nombreux possibles.

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"

Règles

• Vous pouvez choisir votre domaine d'entrée, mais celui-ci doit au moins être composé d'ASCII imprimable et votre domaine de sortie doit être identique à votre domaine d'entrée.
• Les longueurs d’entrée peuvent être identiques ou différentes.
• La sortie doit être valide avec la probabilité 1; Autrement dit, vous pouvez générer des chaînes aléatoires jusqu'à ce qu'une chaîne soit valide (et théoriquement, vous pourriez créer une boucle infinie), mais vous ne pouvez pas simplement générer une chaîne aléatoire en espérant qu'elle est valide. Notez que cela signifie que votre sortie n'a pas besoin d'être déterministe.
• Les retours à la ligne automatiques sont autorisés, mais ils ne comptent pas dans la longueur de la sortie.
• En raison de questions relatives aux erreurs de mémoire, il doit fonctionner dans un délai de 60 secondes et atteindre une longueur maximale de 6. Une réponse qui fonctionne pour cela et fonctionne théoriquement pour des chaînes plus longues est OK, mais les erreurs de mémoire sur l'ordinateur moderne pour la longueur d'entrée 4ne sont pas valides.

C'est du code-golf , donc la réponse la plus courte en octets est gagnante.

05AB1E , 8 7 octets

øvAyм¬?

Utilise le codage 05AB1E . Essayez-le en ligne!

Haskell, 43 octets

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

Prend la chaîne max (lexicographiquement plus tard), que nous savons non vide; remplace tous les caractères par l'un de "a", "b" et "c" using <$; et retourne le premier qui n'est aucune des entrées. Je pense que cela ressemble à la réponse de Neil sur Charcoal et / ou celle de geokavel à CJam .

(Je me suis caché pendant un moment, mais c'est la première fois que je réponds sur ce site; salut!)

Brainfuck, 97 octets

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

Exécuter le code en ligne (notez que "mémoire dynamique" doit être sélectionné en bas à droite)

Super défi! Je pensais que ce serait trivial, mais cela a fini par être très difficile. J'y reviens sans cesse parce que j'estime qu'il devrait y avoir une solution élégante de BF d'une vingtaine d'octets. À ce stade, je suis assez heureux de l'avoir (apparemment) mis au travail en BF.

L'entrée est considérée comme str1+ \0+ str2, où les chaînes sont des caractères consécutifs non nuls de 1 octet.

Retours (first str1 + first str2) or (first str1 + 1) or 2. Cet algorithme a été conçu par le génial @ ØrjanJohansen, basé (vraisemblablement) sur mon original (brisé).

Commenté:

# 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

Gelée , 8 octets

żḟ@€ØAZḢ

Essayez-le en ligne!

Comment?

żḟ@€Ø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 octets

Edit: - 5 octets grâce à @ Mr.Xcoder

Edit: +10 octets pour corriger un bogue

Edit: -3 octets grâce à @betaveros

Edit: -3 octets en utilisant max au lieu de pop

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

Essayez-le en ligne!

Charbon de bois , 22 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Génère toutes les chaînes de caractères majuscules répétées à la longueur de l'entrée la plus longue et surimprime toutes celles qui n'apparaissent pas dans l'entrée. En d’autres termes, la sortie est normalement ZZZ...sauf s’il s’agit d’une des entrées, auquel cas c’est YYY...l’autre, c’est le cas XXX....

Mathematica, 111 octets

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

essayez-le en ligne (collez le code avec ctrl + v, placez l'entrée à la fin et appuyez sur shift + entrée)

contribution

["teste moi"]

Thanx @Not un arbre pour le contrôle et le golf -21 octets

Perl 6 , 38 30 octets

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

Essayez-le en ligne!

Codeblock anonyme qui prend en entrée une liste de deux chaînes et renvoie le premier nombre 1111...avec une quantité non vide de 1 qui n'est pas dans l'entrée.

Explication:

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

-4 octets en utilisant réseau intégré argv, -10 octets en utilisant l' enlèvement et de préfixe RC_EXPAND_PARAM, -1 octet par inline le développement des accolades.

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

Essayez-le en ligne!

Premièrement, c’était un défi formidable, j’ai eu une tonne d’idées avant d’atterrir sur celui-ci.

<<<${${${:-{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

@et *ne sont pas des identificateurs, donc ${ :|@}et ${ :|*}ne fonctionnent pas, d'où l'utilisation de${ :|argv}

Cette méthode fonctionnera jusqu’à 93 entrées et trouvera une 94e unique. Il suffit de remplacer le {1..3}avec la plage maximale possible {~..!}.

Zsh , 48 47 octets *

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

Essayez-le en ligne!

Méthode complètement nouvelle, gracieuseté de la soumission de JoKing Perl 6, mais ne fonctionnant pas sur les grandes chaînes (n> 20) en raison de restrictions de taille. $@[(I)$i]Si la recherche inverse est inversée vers le plus grand des index, la sortie sera zéro (valeur faussée dans le développement arithmétique) si $ i n’est pas trouvé dans les paramètres de ligne de commande.

MATL , 12 octets

c"1Y2@X-1)&h

L'entrée est un tableau de cellules de chaînes contenant des caractères imprimables ASCII. La sortie est formée à partir des lettres 'ABC'et appartient donc au domaine en entrée.

Essayez-le en ligne!

Explication

La sortie est aussi longue que la plus longue chaîne d'entrée. Son n caractère -ème est la première lettre de 'ABC'qui est différent du n caractère -ème des deux chaînes d'entrée.

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 octets

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

Essayez-le en ligne!

Remplacer le premier caractère du maximum des deux chaînes d'entrée avec a, bet cet choisir le premier qui est différent des deux chaînes d'entrée.

Ruby , 53 octets

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

Essayez-le en ligne!

Fondamentalement génère les cordes a...a, b...bet c...cet sélectionne le premier pas dans l'entrée.

ES6, 54 octets

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

Pyth, 7 8 octets

hC-LG.T

1 octet grâce à Jakube

Suite de tests

Nous utilisons .Tune transposition préservant la longueur plutôt que la Ctransposition tronquée, de sorte que cela fonctionne sur les entrées où une chaîne est vide.

Étant donné deux chaînes comme un tuple, nous les transposons ( .T), puis mappons la paire de caractères ou le caractère unique obtenu en soustrayant le ou les caractères de l'alphabet minuscule avec -LG, puis nous transposons la liste résultante de chaînes de caractères inutilisés C, puis nous retournons. la première chaîne avec h. Il s’agit de la première lettre alphabétiquement qui ne figure pas dans l’une ou l’autre chaîne, pour chaque position.

Java (OpenJDK 8) , 100 73 octets

-27 octets grâce à la touche magique de @ Nevay! :)

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

Essayez-le en ligne!

Domaine d'entrée = ASCII imprimable + code 127.

Ruby, 56 octets

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

Pyth , 23 22 octets

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

Essayez-le ici!

Pyth , 22 octets

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

Suite de tests!

Explication

+.)-.{<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 octets

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

Prend les entrées sous forme de deux arguments distincts et retourne la troisième chaîne.

Le sous-programme tente de produire une chaîne très similaire à la première chaîne mais avec le premier non- zcaractère remplacé par un z. Ensuite, il traite les cas de coin en remplaçant le premier caractère par you x, au besoin, s'il constate que l'une des entrées était en fait une séquence de tous zles éléments.

Perl 5 , 68 octets

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

Explication:

• commence par (chaîne de lettres "a" aussi longtemps que la première chaîne) ou deuxième chaîne si elle est fausse c'est-à-dire zéro-longueur
• continue à incrémenter jusqu'à ce qu'il soit différent des premier et deuxième

En partant de "a", il fallait éviter d’augmenter au point où Perl allongeait la chaîne; avec seulement deux chaînes pour éviter d'être identique à, il ne pourrait pas déborder.

Exécuter avec:

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 octets

La fonction a besoin que les chaînes fournies soient modifiables (c'est-à-dire des tableaux ou allouées dynamiquement).

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

Essayez-le en ligne!

Fonctionne pour la gamme standard ASCII

Explication:

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 octets

@ Giuseppe a enregistré 9 octets, @ user2390246 a enregistré 13 octets

une fonction

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

démo

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

Lambda (au curry) de Stringà lambda de Stringà String. Attribuer à 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;}

Essayez-le en ligne

Lambda Ungolfed

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

Cette solution fait pivoter des caractères ASCII aléatoires dans la chaîne la plus longue jusqu'à ce que les conditions requises soient remplies. Les entrées sont UTF-8 et les sorties sont ASCII.

Je ne connais pas les détails précis d'Unicode, mais il me semble plausible que cette solution puisse échouer lorsqu'un annexé charjoint le point de code précédent pour former une seule unité de code. Si quelqu'un qui en sait plus à ce sujet peut le vérifier, je changerai le domaine d'entrée en ASCII.

Java 8, 126 octets

Même type que ci-dessus.

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

Essayez-le en ligne

Lambda Ungolfed

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

Cela incrémente le premier octet de la chaîne la plus longue, en l'habillant d'ASCII, jusqu'à ce que les conditions requises soient remplies. Les entrées et les sorties sont des chaînes ASCII.

APL (Dyalog Unicode) , ^{SBCS de} 11 octets

Programme complet, prend les entrées sous forme de liste imbriquée à 2 éléments.

⊃¨⎕A∘~¨,⌿↑⎕

Essayez-le en ligne!

Frapper, 115 .. 77 octets

Remplace le premier caractère de la première chaîne d'entrée (non vide) par 1,2,3 jusqu'à ce qu'aucune correspondance ne soit trouvée pour l'une ou l'autre des entrées. Essayez-le en ligne!

-9, -12, -9, -8 octets, tous grâce à GammaFunction

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

(une amélioration par rapport à l' original ... )

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

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

Essayez-le en ligne!

Japt , 17 octets

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

Répète les lettres A-Z à la longueur de l'entrée la plus longue, supprime les valeurs de l'entrée et récupère le premier élément du tableau.

Essayez-le en ligne!

Ancienne solution, 18 octets

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

Essayez-le en ligne!

Choisit un caractère aléatoire de l'alphabet et le répète jusqu'à la longueur de la chaîne d'entrée la plus longue, jusqu'à ce qu'il ne soit plus présent dans l'entrée.

Python 3, 74 73 octets

-1 octet grâce à 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)

Imprime le plus petit entier avec la même longueur que la première des entrées dont la longueur est différente de zéro.

Python 2, 77 octets

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

Je pense que cela a du potentiel. L'idée est qu'il ajoute 1 au premier caractère de la première chaîne, puis vérifie si le premier caractère de l'autre entrée est identique.

** Remarque, ^ ne gère pas les chaînes de longueur 0, il ne fonctionne donc pas vraiment avec cette longueur.

Voici une solution super longue qui fonctionne avec 0 longueur

146 octets

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:]

Toute amélioration serait appréciée!

CJam, 31 30 23 octets

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

Prend ASCII imprimable en entrée. Sort une chaîne de 0, 1 ou 2 de la même longueur que l'une des chaînes d'entrée. La logique est qu'une de celles-ci ne peut être l'une des chaînes d'entrée!

Essayez-le en ligne

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 octets

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

Essayez-le en ligne!