İki dize verildiğinde, iki girişten herhangi birine eşit olmayan, ancak girişlerden biriyle aynı uzunluğa sahip (karakter cinsinden) üçüncü bir dize verin. En az bir geçerli çıktı olduğu garantilidir.

Test Kılıfları

Test durumları dizge olduklarını göstermek için alıntılanır. Çıktılar, birçok olasıdır.

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"

kurallar

• Giriş alanınızı seçebilirsiniz, ancak en azından yazdırılabilir ASCII'den oluşmalı ve çıkış alanınız giriş alanınızla aynı olmalıdır.
• Giriş uzunlukları aynı veya farklı olabilir.
• Çıktı olasılık 1 ile geçerli olmalıdır; yani, biri geçerli olana kadar rasgele dizeler oluşturabilirsiniz (ve teorik olarak sınırsız döngü oluşturabilirsiniz), ancak sadece rastgele bir dizge çıktılayamazsınız ve geçerli olmasını umarsınız. Bunun, çıktının belirleyici olmak zorunda olmadığı anlamına geldiğine dikkat edin.
• Otomatik takip eden yeni satırlara izin verilir, ancak çıktının uzunluğuna sayılmazlar.
• Bellek Hatalarıyla ilgili sorular nedeniyle, giriş uzunluklarına kadar 60 saniye içinde çalışmalıdır 6. Bunun için çalışan ve daha uzun dizeler için teorik olarak çalışan bir cevap TAMAM, ancak modern bilgisayarda giriş uzunluğu için Bellek Hatalarının 4geçerli olmadığı bir şey geçerli değil.

Bu kod golf , bayt cinsinden en kısa cevap kazanır.

05AB1E , 8 7 bayt

øvAyм¬?

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

Haskell, 43 bayt

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

Boş olmadığını bildiğimiz max (sözlüksel olarak daha sonra) dizesini alır; Tüm karakterleri "a", "b" ve "c" harflerinden biri ile değiştirir <$; ve girişlerden hiçbiri olmayanı döndürür. Bunun Neil'in Kömür cevabına ve / veya geokavel'in CJam cevabına benzer olduğunu düşünüyorum .

(Bir süredir gizlenmiştim ama bu siteye ilk kez cevap veriyorum; merhaba!)

Brainfuck, 97 bayt

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

Çevrimiçi kod çalıştırma (sağ altta "dinamik bellek" seçilmesi gerektiğini unutmayın)

Müthiş meydan okuma! Önemsiz olacağını düşündüm ama sonuçta zor oldu. Geri dönmeye devam ediyorum çünkü 20 ya da baytlık şık bir BF çözümü olması gerektiğini düşünüyorum. Bu noktada, (görünüşe göre) BF'de çalışabildiğim için çok mutluyum.

Girdiler str1+ \0+ olarak alınır str2, burada dizeler art arda sıfır olmayan 1 bayt karakterlerdir.

Döner (first str1 + first str2) or (first str1 + 1) or 2. Bu algoritma benim (kırılmış) orjinalini temel alan parlak @ ØrjanJohansen (muhtemelen) tarafından düşünülmüştü.

Yorumlananlar:

# 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

Jöle , 8 bayt

żḟ@€ØAZḢ

Çevrimiçi deneyin!

Nasıl?

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

Düzenleme: - @ Mr.Xcoder sayesinde 5 bayt

Düzenleme: Bir hatayı düzeltmek için +10 bayt

Düzenleme: @betaveros sayesinde -3 bayt

Düzenleme: pop yerine max kullanarak -3 bayt

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

Çevrimiçi deneyin!

Kömür , 22 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Daha uzun girişin uzunluğuna tekrarlanan tüm büyük harfli karakter dizelerini oluşturur ve giride görünmeyenlerin üzerine yazdırır. Başka bir deyişle, çıkış normalde ZZZ...girdilerden biri olmadıkça gerçekleşir, bu durumda YYY...diğer girdi değilse, bu durumda olur XXX....

Mathematica, 111 bayt

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

çevrimiçi deneyin (ctrl + v kodunu yapıştırın, girişi sonuna yerleştirin ve shift + enter tuşuna basın)

giriş

["Sına beni"]

thanx @Nontrol ve golf oynamak için bir ağaç yok -21 bayt

Perl 6 , 38 30 bayt

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

Çevrimiçi deneyin!

Girdiyi iki dizenin bir listesi olarak alan ve ilk sayıyı 1111...girişte bulunmayan boş olmayan bir 1s miktarıyla döndüren adsız kod bloğu .

Açıklama:

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

Zş , 51 47 37 36 bayt

-4 dizi yerleşik kullanılarak bayt argv, -10 önek çıkarma ve kullanılarak bayt RC_EXPAND_PARAM, -1 bağ genişleme inlining ile bayt.

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

Çevrimiçi deneyin!

İlk olarak, bu müthiş bir mücadeleydi, buna inmeden önce bir sürü fikirden geçtim.

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

@ve *tanımlayıcı değiller, ${ :|@}ve${ :|*} , dolayısıyla kullanımı işi yok${ :|argv}

Bu yöntem 93 girişe kadar çalışacak ve benzersiz olan bir 94üncüyü bulacaktır. Sadece {1..3}mümkün olan maksimum aralık ile değiştirin{~..!} .

Zsh , 48 47 bayt *

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

Çevrimiçi deneyin!

JoKing'in Perl 6 gönderiminin izniyle tamamen yeni bir yöntem olmakla birlikte, tamsayı boyut kısıtlamaları nedeniyle büyük dizelerde (n> 20) çalışmaz. $@[(I)$i]komut dizisi parametrelerinde $ i bulunmazsa, en büyük dizine ters dizi aramasıdır, sıfırı (aritmetik genişlemede falsi) çıkarır.

MATL , 12 bayt

c"1Y2@X-1)&h

Giriş, yazdırılabilir ASCII karakterleri içeren bir hücre dizesi dizisidir. Çıktı harflerden oluşur 'ABC've bu nedenle giriş alanına aittir.

Çevrimiçi deneyin!

açıklama

Çıkış, en uzun giriş dizesi olduğu sürece. Onun n -inci karakter ilk harfi 'ABC'farklıdır n hem girdi dizeleri ninci karakterle.

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 bayt

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

Çevrimiçi deneyin!

İle iki giriş dizeleri maksimum birinci kömürü değiştirin a, bve cher iki giriş dizeleri farklıdır ilkini seçin.

Ruby , 53 bayt

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

Çevrimiçi deneyin!

Temelde dizeleri üretir a...a, b...bve c...cve girişteki ilk değil seçer.

ES6, 54 bayt

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

Pyth, 7 8 bayt

hC-LG.T

Jakube sayesinde 1 bayt

Test odası

Bir dizginin boş olduğu girdilerde çalışacak şekilde, kesik transpozit .Tyerine uzunluk koruyucu transpozisyon kullanıyoruz C.

Bir dize olarak iki dize verildiğinde, bunları ( .T) dönüştürdük, sonra karakterleri veya karakterleri tek harfli karakterleri alt karakterli alfabeden çıkararak eşleştirelim -LG, sonra kullanılmayan karakter dizelerinin listesini sıraya alın C, sonra geri dönün ile ilk böyle dize h. Bu, her pozisyon için, her iki dizgede bulunmayan alfabetik olarak ilk harften oluşur.

Java (OpenJDK 8) , 100 73 bayt

@ Nevay'ın büyülü dokunuşu sayesinde -27 bayt! :)

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

Çevrimiçi deneyin!

Giriş alanı = Yazdırılabilir ASCII + kod noktası 127.

Ruby, 56 bayt

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

Pyth , 23 22 bayt

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

Burada dene!

Pyth , 22 bayt

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

Test odası!

açıklama

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

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

Girdiyi iki ayrı argüman olarak alır ve üçüncü dizeyi döndürür.

Alt yordam ilk dizeye çok benzeyen ancak ilk zkarakter olmayan a ile değiştirilen bir dize üretmeye çalışır z. Daha sonra , girdilerden birinin gerçekte hepsinin bir dizisi olduğunu bulursa , ilk karakteri yveya ile xgerektiği şekilde değiştirerek köşe durumlarıyla ilgilenir z.

Perl 5 , 68 bayt

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

Açıklama:

• sıfır (sıfır (sıfır) uzunluğunda "a" harfinin dizesi) veya eğer yanlışsa ikinci dizeyle başlar
• hem birinci hem de ikinci olandan farklı olana kadar artmaya devam ediyor

"A" dan başlayarak, Perl'nin ipi uzattığı noktaya kadar artan noktalardan kaçınmak; taşmasını engellemek için aynı olmaktan kaçınmak için yalnızca iki dizeyle.

Şununla çalıştır:

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 bayt

Fonksiyon, sağlanan dizgelerin değişken olmasını gerektirir (yani, diziler veya dinamik olarak tahsis edilmiş).

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

Çevrimiçi deneyin!

Standart ASCII serisi için çalışır

Açıklama:

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 bayt

@Giuseppe 9 bayt, @ user2390246 13 bayt kurtardı

fonksiyon

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

gösteri

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

Lambda (curried) Stringgelen lambda Stringiçin String. Atama 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;}

Çevrimiçi Deneyin

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

Bu çözüm, istenen koşullar sağlanıncaya kadar rastgele ASCII karakterlerini daha uzun dizgelere döndürür. Girişler UTF-8 ve çıkışlar ASCII.

Unicode'un kırılgan ayrıntılarını bilmiyorum, ancak bir ekli charkod kodunu birleştirdiğinde tek bir kod birimi oluşturmak için bu çözümün başarısız olacağı bana mantıklı geliyor . Bu konuda daha fazla şey bilen biri bunu doğrulayabilirse, giriş alanını ASCII olarak değiştireceğim.

Java 8, 126 bayt

Yukarıdaki ile aynı tipte.

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

Çevrimiçi Deneyin

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

Bu, gerekli koşullar yerine getirilinceye kadar ASCII içinde saran uzun dizenin ilk baytını artırır. Girişler ve çıkışlar ASCII dizeleridir.

APL (Dyalog Unicode) , 11 bayt ^SBCS

Tam program, 2 elemanlı iç içe liste olarak girişi alır.

⊃¨⎕A∘~¨,⌿↑⎕

Çevrimiçi deneyin!

Bash, 115 .. 77 bayt

Her iki girişte eşleşme bulunamayana kadar ilk (boş olmayan) giriş dizesinin ilk karakterini 1,2,3 ile değiştirir. Çevrimiçi Deneyin!

-9, -12, -9, -8 byte hepsi GammaFunction sayesinde

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

( orijinali üzerinde oldukça bir gelişme ... )

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

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

Çevrimiçi deneyin!

Japt , 17 bayt

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

Harfleri A-Zuzun girişin uzunluğuna kadar tekrarlar, girişdeki değerleri siler ve dizideki ilk öğeyi alır.

Çevrimiçi deneyin!

Eski çözüm, 18 bayt

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

Çevrimiçi deneyin!

Alfabeden rastgele bir karakter seçer ve girişte bulunmayana kadar onu uzun giriş dizesinin uzunluğuna kadar tekrarlar.

Python 3, 74 73 bayt

Adım Tavuk sayesinde -1 bayt

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

Sıfır uzunluğu olmayan girişlerin ilki ile aynı uzunlukta en düşük tam sayıyı yazdırır.

Python 2,77 bayt

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

Bence bazı potansiyelleri var. Buradaki fikir, 1. dizedeki 1. karaktere 1 eklemesi, ardından diğer girişin 1. karakterinin aynı olup olmadığını kontrol etmesidir.

** Not, ^ 0 uzunluk dizgilerini işlemez, bu nedenle gerçekten bu uzunluklarda çalışmaz.

İşte 0 uzunluk ile çalışan süper uzun bir çözüm

146 Bayt

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

Herhangi bir iyileştirme takdir edilecektir!

CJam, 31 30 23 bayt

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

Girdi olarak yazdırılabilir ASCII'yi alır. Giriş dizelerinden biriyle aynı uzunluktaki 0, 1 veya 2 dizisinden oluşan bir çıktı verir. Mantık, bunlardan birinin giriş dizgilerinden hiçbiri olamaz!

Çevrimiçi Deneyin

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 bayt

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

Çevrimiçi deneyin!