Cho hai chuỗi, xuất ra một chuỗi thứ ba không bằng một trong hai đầu vào, nhưng có cùng độ dài (tính bằng ký tự) với một trong hai đầu vào. Có đảm bảo có ít nhất một đầu ra hợp lệ.

Các trường hợp thử nghiệm

Các trường hợp thử nghiệm được trích dẫn để hiển thị chúng là các chuỗi. Đầu ra là một trong nhiều khả năng

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"

Quy tắc

• Bạn có thể chọn miền đầu vào của mình, nhưng nó phải bao gồm ít nhất ASCII có thể in được và miền đầu ra của bạn phải giống với miền đầu vào của bạn.
• Độ dài đầu vào có thể giống hoặc khác nhau.
• Đầu ra phải hợp lệ với xác suất 1; nghĩa là, bạn có thể tạo các chuỗi ngẫu nhiên cho đến khi một chuỗi hợp lệ (và về mặt lý thuyết bạn có thể lặp vô hạn), nhưng bạn không thể chỉ xuất một chuỗi ngẫu nhiên và hy vọng nó hợp lệ. Lưu ý rằng điều này có nghĩa là đầu ra của bạn không cần phải xác định.
• Tự động theo dõi dòng mới cho phép, nhưng chúng không được tính vào chiều dài của đầu ra.
• Do các câu hỏi liên quan đến Lỗi bộ nhớ, nó phải hoạt động trong vòng 60 giây cho đến độ dài đầu vào 6. Một câu trả lời phù hợp với điều đó và về mặt lý thuyết hoạt động cho các chuỗi dài hơn là OK, nhưng một điều mà Lỗi bộ nhớ trên máy tính hiện đại cho độ dài đầu vào 4là không hợp lệ.

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.

05AB1E , 8 7 byte

øvAyм¬?

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Haskell, 43 byte

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

Lấy chuỗi max (từ vựng sau này), mà chúng ta biết là không trống; thay thế tất cả các ký tự bằng một trong các "a", "b" và "c" bằng cách sử dụng <$; và trả về cái đầu tiên không phải là đầu vào. Tôi nghĩ rằng điều này tương tự như câu trả lời Char than của Neil và / hoặc câu trả lời CJam của geokavel .

(Tôi đã ẩn giấu một lúc nhưng đây là lần đầu tiên tôi trả lời trên trang web này; xin chào!)

Brainfuck, 97 byte

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

Chạy mã trực tuyến (lưu ý rằng "bộ nhớ động" phải được chọn ở phía dưới bên phải)

Thử thách tuyệt vời! Tôi nghĩ rằng nó sẽ tầm thường nhưng cuối cùng thực sự khó khăn. Tôi tiếp tục quay lại với nó bởi vì tôi cảm thấy như cần có một giải pháp BF 20 hay thanh lịch. Tại thời điểm này, tôi khá hạnh phúc (dường như) tôi đã làm cho nó hoạt động hoàn toàn trong BF.

Đầu vào được lấy là str1+ \0+ str2, trong đó các chuỗi là các ký tự 1 byte khác không liên tiếp.

Trả về (first str1 + first str2) or (first str1 + 1) or 2. Thuật toán này đã được nghĩ ra bởi @ janrjanJohansen, (có lẽ) dựa trên bản gốc (bị hỏng) của tôi.

Đã bình luận:

# 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

Thạch , 8 byte

żḟ@€ØAZḢ

Hãy thử trực tuyến!

Làm sao?

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

Chỉnh sửa: - 5 byte nhờ @ Mr.Xcoder

Chỉnh sửa: +10 byte để sửa lỗi

Chỉnh sửa: -3 byte nhờ @betaveros

Chỉnh sửa: -3 byte bằng cách sử dụng max thay vì pop

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

Hãy thử trực tuyến!

Than , 22 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Tạo tất cả các chuỗi ký tự viết hoa được lặp lại theo độ dài của đầu vào dài hơn và in đè lên tất cả các chuỗi ký tự không xuất hiện trong đầu vào. Nói cách khác, đầu ra là bình thường ZZZ...trừ khi đó là một trong những đầu vào, trong trường hợp đó, YYY...trừ khi đó là đầu vào khác, trong trường hợp đó là đầu vào XXX....

Toán học, 111 byte

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

thử trực tuyến (dán mã với ctrl + v, đặt đầu vào ở cuối và nhấn shift + enter)

đầu vào

["kiểm tra tôi"]

thanx @ Không phải là một cây để kiểm tra và chơi gôn -21 byte

Perl 6 , 38 30 byte

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

Hãy thử trực tuyến!

Khóa mã ẩn danh lấy đầu vào làm danh sách gồm hai chuỗi và trả về số đầu tiên với số lượng 1111...1 không trống trong đầu vào.

Giải trình:

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

-4 byte bằng cách sử dụng mảng dựng sẵn argv, -10 byte bằng cách sử dụng loại bỏ tiền tố và RC_EXPAND_PARAM, -1 byte bằng cách nội tuyến mở rộng dấu ngoặc.

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

Hãy thử trực tuyến!

Đầu tiên, đây là một thử thách tuyệt vời, tôi đã trải qua rất nhiều ý tưởng trước khi tiếp cận ý tưởng này.

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

@và *không phải là định danh, vì vậy ${ :|@}và ${ :|*}không hoạt động, do đó việc sử dụng${ :|argv}

Phương pháp này sẽ hoạt động tới 93 đầu vào và tìm thứ 94 là duy nhất. Đơn giản chỉ cần thay thế {1..3}với phạm vi tối đa có thể {~..!}.

Zsh , 48 47 byte *

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

Hãy thử trực tuyến!

Phương pháp hoàn toàn mới nhờ phép đệ trình Perl 6 của JoKing, nhưng không hoạt động trên các chuỗi lớn (n> 20) do hạn chế kích thước số nguyên. $@[(I)$i]là tìm kiếm mảng đảo ngược đến chỉ mục lớn nhất, nó sẽ xuất ra 0 (sai lệch trong mở rộng số học) nếu không tìm thấy $ i trong các tham số dòng lệnh.

MATL , 12 byte

c"1Y2@X-1)&h

Đầu vào là một mảng các chuỗi chứa các ký tự ASCII có thể in được. Đầu ra được hình thành từ các chữ cái 'ABC', và do đó thuộc về miền đầu vào.

Hãy thử trực tuyến!

Giải trình

Đầu ra dài bằng chuỗi đầu vào dài nhất. Ký tự thứ n của nó là chữ cái đầu tiên 'ABC'khác với ký tự thứ n của cả hai chuỗi đầu vào.

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 byte

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

Hãy thử trực tuyến!

Thay thế các char đầu tiên của tối đa của hai chuỗi đầu vào với a, bvà cvà chọn một trong những đầu tiên đó là khác nhau từ cả hai chuỗi đầu vào.

Ruby , 53 byte

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

Hãy thử trực tuyến!

Về cơ bản tạo ra các chuỗi a...a, b...bvà c...cvà lựa chọn đầu tiên không phải trong đầu vào.

ES6, 54 byte

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

Bình thường, 7 8 byte

hC-LG.T

1 byte nhờ Jakube

Bộ kiểm tra

Chúng tôi sử dụng .T, bảo toàn độ dài chuyển vị, thay vì Ccắt ngắn chuyển vị, để nó hoạt động trên các đầu vào trong đó một chuỗi trống.

Cho hai chuỗi dưới dạng một tuple, chúng ta hoán vị chúng ( .T), sau đó ánh xạ cặp ký tự hoặc ký tự đơn kết quả bằng cách trừ (các) ký tự từ bảng chữ cái dưới -LG, sau đó hoán chuyển danh sách kết quả của các chuỗi ký tự không được sử dụng C, sau đó trả về chuỗi đầu tiên như vậy với h. Điều này bao gồm chữ cái đầu tiên theo thứ tự abc không nằm trong một trong hai chuỗi cho mỗi vị trí.

Java (OpenJDK 8) , 100 73 byte

-27 byte nhờ vào cảm ứng kỳ diệu của @ Nevay! :)

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

Hãy thử trực tuyến!

Tên miền đầu vào = ASCII + có thể in được 127.

Ruby, 56 byte

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

Bình thường , 23 22 byte

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

Hãy thử nó ở đây!

Bình thường , 22 byte

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

Phòng thử nghiệm!

Giải trình

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

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

Lấy đầu vào là hai đối số riêng biệt và trả về chuỗi thứ ba.

Chương trình con cố gắng tạo ra một chuỗi rất giống với chuỗi đầu tiên nhưng với zký tự không đầu tiên được thay thế bằng a z. Sau đó, nó xử lý các trường hợp góc bằng cách thay thế ký tự đầu tiên bằng yhoặc x, nếu cần, nếu nó thấy rằng một trong những đầu vào trên thực tế là một chuỗi tất cả z.

Perl 5 , 68 byte

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

Giải trình:

• bắt đầu bằng (chuỗi ký tự "a" miễn là chuỗi thứ nhất) hoặc chuỗi thứ hai nếu đó là sai tức là độ dài bằng không
• cứ tăng dần cho đến khi nó khác với cả thứ nhất và thứ hai

Bắt đầu từ "a" là để tránh tăng dần đến điểm mà Perl kéo dài chuỗi; chỉ có hai chuỗi để tránh giống nhau, nó không thể tràn.

Thực hiện với:

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 byte

Hàm cần các chuỗi được cung cấp để có thể thay đổi (tức là mảng hoặc được phân bổ động).

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

Hãy thử trực tuyến!

Hoạt động cho phạm vi ASCII tiêu chuẩn

Giải trình:

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 byte

@Giuseppe đã lưu 9 byte, @ user2390246 đã lưu 13 byte

chức năng

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

bản giới thiệu

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

Lambda (cà ri) từ Stringđến lambda từ Stringđến String. Chỉ định cho 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;}

Dùng thử trực tuyến

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

Giải pháp này xoay các ký tự ASCII ngẫu nhiên thành chuỗi dài hơn cho đến khi các điều kiện cần thiết được thỏa mãn. Đầu vào là UTF-8 và đầu ra là ASCII.

Tôi không biết các chi tiết nghiệt ngã của Unicode, nhưng có vẻ hợp lý với tôi rằng giải pháp này có thể thất bại khi được nối thêm char với điểm mã trước đó để tạo thành một đơn vị mã. Nếu ai đó biết thêm về điều này có thể xác minh điều này, tôi sẽ thay đổi miền đầu vào thành ASCII.

Java 8, 126 byte

Cùng loại như trên.

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

Dùng thử trực tuyến

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

Điều này làm tăng byte đầu tiên của chuỗi dài hơn, bao bọc trong ASCII, cho đến khi các điều kiện bắt buộc được đáp ứng. Đầu vào và đầu ra là các chuỗi ASCII.

APL (Dyalog Unicode) , 11 byte ^SBCS

Chương trình đầy đủ, lấy đầu vào là danh sách lồng 2 phần tử.

⊃¨⎕A∘~¨,⌿↑⎕

Hãy thử trực tuyến!

Bash, 115 .. 77 byte

Thay thế char đầu tiên của chuỗi đầu vào (không trống) bằng 1,2,3 cho đến khi không tìm thấy kết quả khớp nào với đầu vào. Hãy thử trực tuyến!

-9, -12, -9, -8 byte tất cả là nhờ GammaFunction

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

(khá là cải tiến so với bản gốc ... )

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

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

Hãy thử trực tuyến!

Japt , 17 byte

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

Lặp lại các chữ cái A-Ztheo chiều dài của đầu vào dài hơn, loại bỏ các giá trị trong đầu vào và lấy mục đầu tiên trong mảng.

Hãy thử trực tuyến!

Giải pháp cũ, 18 byte

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

Hãy thử trực tuyến!

Chọn một ký tự ngẫu nhiên từ bảng chữ cái và lặp lại nó theo chiều dài của chuỗi đầu vào dài hơn, cho đến khi nó không có trong đầu vào.

Python 3, 74 73 byte

-1 byte nhờ 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)

In số nguyên thấp nhất có cùng độ dài với đầu vào đầu tiên có độ dài khác không.

Python 2, 77 byte

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

Tôi nghĩ rằng nó có một số tiềm năng. Ý tưởng là nó thêm 1 vào char thứ 1 trong chuỗi thứ 1, sau đó kiểm tra xem char thứ 1 của đầu vào khác có giống nhau không.

** Lưu ý, ^ không xử lý chuỗi 0 độ dài, vì vậy nó không thực sự hoạt động ở độ dài này.

Đây là một giải pháp siêu dài hoạt động với độ dài 0

146 byte

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

Bất kỳ cải tiến sẽ được đánh giá cao!

CJam, 31 30 23 byte

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

Lấy ASCII có thể in làm đầu vào. Xuất ra một chuỗi 0, 1 hoặc 2 có cùng độ dài với một trong các chuỗi đầu vào. Logic là một trong những chuỗi không thể là một trong các chuỗi đầu vào!

Dùng thử trực tuyến

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 byte

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

Hãy thử trực tuyến!