Thứ hai Mini-Golf: Một loạt các thử thách golf-code ngắn , được đăng (hy vọng!) Vào mỗi thứ Hai.
_{(Xin lỗi người này hơi muộn.)}

Tôi chắc rằng hầu hết các bạn đã nghe về khoảng cách Levenshtein , một thuật toán để tính khoảng cách giữa hai chuỗi. Chà, thử thách này là về việc thực hiện một thuật toán tương tự của phát minh của riêng tôi *, được gọi là khoảng cách đảo chữ . Sự khác biệt chính là thứ tự của các nhân vật không quan trọng; thay vào đó, chỉ các ký tự duy nhất cho một chuỗi hoặc chuỗi kia được đo.

Thử thách

Mục tiêu của thử thách là viết một chương trình hoặc hàm có hai chuỗi và trả về khoảng cách đảo chữ giữa chúng. Cách chính để làm điều này là sử dụng logic sau:

1. Chuyển đổi cả hai chuỗi thành chữ thường và (tùy chọn) sắp xếp các ký tự của mỗi người theo thứ tự bảng chữ cái.
2. Trong khi các chuỗi chứa ít nhất một ký tự bằng nhau, hãy xóa phiên bản đầu tiên của ký tự này khỏi mỗi chuỗi.
3. Thêm độ dài của các chuỗi còn lại và trả về / xuất kết quả.

Thí dụ

Nếu đầu vào là:

Hello, world!
Code golf!

Sau đó, hạ cấp và sắp xếp, chúng trở thành: (theo cách sắp xếp mặc định của JS; lưu ý các khoảng trắng hàng đầu)

 !,dehllloorw
 !cdefgloo

Xóa tất cả các ký tự trong cả hai chuỗi, chúng tôi kết thúc bằng:

,hllrw
cfg

Do đó, khoảng cách đảo chữ giữa hai chuỗi gốc = 6 + 3 = 9.

Chi tiết

• Các chuỗi có thể được thực hiện trong bất kỳ định dạng hợp lý.
• Các chuỗi sẽ chỉ bao gồm ASCII có thể in.
• Bản thân các chuỗi sẽ không chứa bất kỳ khoảng trắng nào ngoài các khoảng trắng thông thường. (Không có tab, dòng mới, v.v.)
• Bạn không cần sử dụng thuật toán chính xác này, miễn là kết quả là như nhau.

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

Đầu vào 1:

Hello, world!
Code golf!

Đầu ra 1:

9

Đầu vào 2:

12345 This is some text.
.txet emos si sihT 54321

Đầu ra 2:

0

Đầu vào 3:

All unique characters here!
Bdfgjkmopvwxyz?

Đầu ra 3:

42

Đầu vào 4:

This is not exactly like Levenshtein distance,
but you'll notice it is quite similar.

Đầu ra 4:

30

Đầu vào 5:

all lowercase.
ALL UPPERCASE!

Đầu ra 5:

8

Chấm điểm

Đây là mã golf , vì vậy mã hợp lệ ngắn nhất tính bằng byte thắng. Tiebreaker đi đến trình mà đạt đến số byte cuối cùng của nó đầu tiên. Người chiến thắng sẽ được chọn vào thứ Hai tới, ngày 12 tháng 10. Chúc may mắn!

Chỉnh sửa: Xin chúc mừng người chiến thắng, @isaacg, sử dụng Pyth (một lần nữa) cho 12 byte đáng kinh ngạc !

_{* Nếu thuật toán này đã được sử dụng ở nơi khác và / hoặc được đặt tên khác, vui lòng cho tôi biết! Tôi không thể tìm thấy nó với một tìm kiếm 20 phút.}

Bình thường, 12 byte

ls.-M.prR0.z

Bộ kiểm tra

Hoạt động trong câu hỏi tương đương với toán tử trừ theo chiều dọc của Pyth .-, được áp dụng theo cả hai hướng. Bạn có thể gọi nó là bagwise xor, tôi cho là vậy.

Giải pháp là:

.z: lấy đầu vào là danh sách 2 chuỗi.

rR0: chuyển đổi cả hai thành chữ thường.

.p: Hình thành tất cả các hoán vị, tức là bình thường và đảo ngược.

.-M: Ánh xạ .-hoạt động qua từng đơn hàng.

s: Kết hợp các kết quả.

l: In chiều dài.

JavaScript (ES7), 92 byte

Xác định một hàm ẩn danh.

Để kiểm tra, hãy chạy đoạn mã dưới đây. Bạn có thể chỉnh sửa mã và nhấp vào 'Kiểm tra' để so sánh đầu ra của mã đó với bản gốc. (Để lại nhận xét nếu bạn tìm thấy một cải tiến!) Đầu vào giống như "Hello, world!", "Code golf!"trong hộp đầu vào.

Cảm ơn @ETHproductions đã lưu 6 byte!

(a,b)=>[for(v of a[t="toLowerCase"]())if((b=b[t]())==(b=b.replace(v,"")))v][l="length"]+b[l]

<!--                               Try the test suite below!                              --><strong id="bytecount" style="display:inline; font-size:32px; font-family:Helvetica"></strong><strong id="bytediff" style="display:inline; margin-left:10px; font-size:32px; font-family:Helvetica; color:lightgray"></strong><br><br><pre style="margin:0">Code:</pre><textarea id="textbox" style="margin-top:5px; margin-bottom:5px"></textarea><br><pre style="margin:0">Input:</pre><textarea id="inputbox" style="margin-top:5px; margin-bottom:5px"></textarea><br><button id="testbtn">Test!</button><button id="resetbtn">Reset</button><br><p><strong id="origheader" style="font-family:Helvetica; display:none">Original Code Output:</strong><p><div id="origoutput" style="margin-left:15px"></div><p><strong id="newheader" style="font-family:Helvetica; display:none">New Code Output:</strong><p><div id="newoutput" style="margin-left:15px"></div><script type="text/javascript" id="golfsnippet">var bytecount=document.getElementById("bytecount");var bytediff=document.getElementById("bytediff");var textbox=document.getElementById("textbox");var inputbox=document.getElementById("inputbox");var testbtn=document.getElementById("testbtn");var resetbtn=document.getElementById("resetbtn");var origheader=document.getElementById("origheader");var newheader=document.getElementById("newheader");var origoutput=document.getElementById("origoutput");var newoutput=document.getElementById("newoutput");textbox.style.width=inputbox.style.width=window.innerWidth-50+"px";var _originalCode=null;function getOriginalCode(){if(_originalCode!=null)return _originalCode;var allScripts=document.getElementsByTagName("script");for(var i=0;i<allScripts.length;i++){var script=allScripts[i];if(script.id!="golfsnippet"){originalCode=script.textContent.trim();return originalCode}}}function getNewCode(){return textbox.value.trim()}function getInput(){try{var inputText=inputbox.value.trim();var input=eval("["+inputText+"]");return input}catch(e){return null}}function setTextbox(s){textbox.value=s;onTextboxChange()}function setOutput(output,s){output.innerHTML=s}function addOutput(output,data){output.innerHTML+='<pre style="background-color:'+(data.type=="err"?"lightcoral":"lightgray")+'">'+escape(data.content)+"</pre>"}function getByteCount(s){return(new Blob([s],{encoding:"UTF-8",type:"text/plain;charset=UTF-8"})).size}function onTextboxChange(){var newLength=getByteCount(getNewCode());var oldLength=getByteCount(getOriginalCode());bytecount.innerHTML=newLength+" bytes";var diff=newLength-oldLength;if(diff>0){bytediff.innerHTML="(+"+diff+")";bytediff.style.color="lightcoral"}else if(diff<0){bytediff.innerHTML="("+diff+")";bytediff.style.color="lightgreen"}else{bytediff.innerHTML="("+diff+")";bytediff.style.color="lightgray"}}function onTestBtn(evt){origheader.style.display="inline";newheader.style.display="inline";setOutput(newoutput,"");setOutput(origoutput,"");var input=getInput();if(input===null){addOutput(origoutput,{type:"err",content:"Input is malformed. Using no input."});addOutput(newoutput,{type:"err",content:"Input is malformed. Using no input."});input=[]}doInterpret(getNewCode(),input,function(data){addOutput(newoutput,data)});doInterpret(getOriginalCode(),input,function(data){addOutput(origoutput,data)});evt.stopPropagation();return false}function onResetBtn(evt){setTextbox(getOriginalCode());origheader.style.display="none";newheader.style.display="none";setOutput(origoutput,"");setOutput(newoutput,"")}function escape(s){return s.toString().replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;")}window.alert=function(){};window.prompt=function(){};function doInterpret(code,input,cb){var workerCode=interpret.toString()+";function stdout(s){ self.postMessage( {'type': 'out', 'content': s} ); }"+" function stderr(s){ self.postMessage( {'type': 'err', 'content': s} ); }"+" function kill(){ self.close(); }"+" self.addEventListener('message', function(msg){ interpret(msg.data.code, msg.data.input); });";var interpreter=new Worker(URL.createObjectURL(new Blob([workerCode])));interpreter.addEventListener("message",function(msg){cb(msg.data)});interpreter.postMessage({"code":code,"input":input});setTimeout(function(){interpreter.terminate()},1E4)}setTimeout(function(){getOriginalCode();textbox.addEventListener("input",onTextboxChange);testbtn.addEventListener("click",onTestBtn);resetbtn.addEventListener("click",onResetBtn);setTextbox(getOriginalCode())},100);function interpret(code,input){window={};alert=function(s){stdout(s)};window.alert=alert;console.log=alert;prompt=function(s){if(input.length<1)stderr("not enough input");else{var nextInput=input[0];input=input.slice(1);return nextInput.toString()}};window.prompt=prompt;(function(){try{var evalResult=eval(code);if(typeof evalResult=="function"){var callResult=evalResult.apply(this,input);if(typeof callResult!="undefined")stdout(callResult)}}catch(e){stderr(e.message)}})()};</script>

Tìm hiểu thêm về bộ thử nghiệm

Làm thế nào nó hoạt động

//Define function w/ paramters a, b
(a,b)=>
     //lowercase a
     //for each character v in a:
     [for(v of a[t="toLowerCase"]())
          //lowercase b
          //remove the first instance of v in b
          //if b before removal equals b after removal (if nothing was removed):
          if((b=b[t]())==(b=b.replace(v,"")))
               //keep v in the array of a's values to keep
               v]
     //get the length of the computed array
     [l="length"]
     //add b's length
     +b[l]
     //implicitly return the sum

CJam, 23 19 byte

2{'¡,lelfe=}*.-:z:+

Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

2{         }*        Do the following twice:
  '¡,                  Push the string of the first 161 Unicode charcters.
     lel               Read a line from STDIN and convert it to lowercase.
        fe=            Count the number of occurrences of each of the 160
                       characters in the lowercased line.
             .-      Vectorized subtraction; push the differences of the
                     occurrences of all 161 characters.
               :z    Apply absolute value to each difference.
                 :+  Push the sum of all results.

Ruby, 62

#!ruby -naF|
gets
p$F.count{|c|!$_.sub!(/#{Regexp.escape c}/i){}}+~/$/

Có phải là một cách tốt hơn.

Chỉnh sửa: 57 ký tự nhờ iamnotmaynard điều tra một con đường tôi đã quá lười biếng.

#!ruby -naF|
gets.upcase!
p$F.count{|c|!$_.sub!(c.upcase){}}+~/$/

Python, 90 87 81 80 79 byte

lambda a,b,s=str.lower:sum(abs(s(a).count(c)-s(b).count(c)))for c in{*s(a+b)}))

Python <phiên bản 3.5, 80 byte

lambda a,b,s=str.lower:sum(abs(s(a).count(c)-s(b).count(c))for c in set(s(a+b)))

Giải trình

Đối với mỗi ký tự trong a hoặc b, hãy đếm số lần xuất hiện trong mỗi chuỗi và thêm chênh lệch (dương).

Chỉnh sửa: Đọc lại quy tắc, nhận ra các hàm ẩn danh được chấp nhận, câu trả lời được cải thiện bằng cách loại bỏ raw_input. Đầu tiên chơi golf, hãy nhẹ nhàng!

Cảm ơn sp3000 vì đã cải thiện việc xác định lại str.lower và khiến tôi nhận ra việc in ấn là không cần thiết. Ngoài ra không gian. Vẫn đang học.

Sử dụng python> = 3.5, có một cách ngắn hơn để xác định các tập hợp, do đó, một byte có thể được lưu trên các phiên bản trước.

Võng mạc, 40 20 byte

20 byte được lưu nhờ Martin Büttner.

Đặt mỗi dòng trong tệp riêng của nó và thay thế \nbằng một dòng mới theo nghĩa đen.

+i`(.)(.*\n.*)\1
$2
.

pb , 648 byte

^w[B!0]{t[B]vb[T]^>}vb[-1]w[X!0]{<t[64]w[T!0]{w[B!0]{b[B-1]v}^[Y]t[T-1]}}w[B!-1]{w[B=0]{b[27]}t[26]w[T!0]{w[B!0]{b[B-1]v}^[Y]t[T-1]}>}b[0]w[X!0]{<w[B!0]{b[1]v}^[Y]w[B=0]{b[32]}w[B=1]{b[0]}}^w[B!0]{t[B]vb[B+T]^>}vb[1]<w[B!9]{t[B]b[0]vv<[X]w[B!0]{>}b[T]^^<[X]w[B!0]{>}<}b[0]<w[X!-1]{t[B]vb[1]^w[B!1]{>}vvw[X!-1]{w[B=T]{b[0]<[X]^w[B!1]{>}^b[0]vt[2]}<}^[Y]vw[B!1]{>}b[0]^<}t[0]w[B!1]{w[B!0]{t[T+1]b[0]}>}b[0]vvw[X!-1]{w[B!0]{t[T+1]b[0]}<}>b[11]^b[T]w[B!0]{vw[B!11]{>}t[B]b[0]>b[T]<[X]^t[B]b[0]vw[B!11]{>}<w[T!0]{t[T-1]b[B+1]w[B=11]{b[0]^<[X]b[B+1]vw[B!11]{>}<}}^<[X]}vw[B!11]{b[B+48]>}b[0]<w[B!0]{w[B!0]{>}<t[B]^^<[X]w[B!0]{>}b[T]<[X]vvw[B!0]{>}<b[0]<}

Đưa đầu vào với một ký tự tab tách hai chuỗi.

Đây là một doozy. Trên thực tế, việc thực hiện thuật toán không phải là phần khó, điều đó đến tương đối dễ dàng. Nhưng tôi đã phải làm hai điều khó thực hiện trong pb: Vô cảm trường hợp và itoa. Tôi tình cờ có một chương trình chuyển đổi thành chữ thường chỉ nằm xung quanh (bản thân nó dài 211 byte) và mọi thứ khác đã được giải quyết vào cuối để thực hiện công việc cho thử thách này một cách cụ thể.

Bạn có thể xem chương trình này chạy trên YouTube! Có một vài điều bạn nên ghi nhớ nếu bạn làm:

• Phiên bản này của chương trình được sửa đổi một chút, nặng 650 byte. Sự khác biệt duy nhất là 255 được sử dụng làm giá trị cờ thay vì -1, vì đang cố in chr(-1)lỗi trình thông dịch khi chạy ở chế độ đồng hồ.
• Đầu vào trong video đó là Hello, world!và Code golf.. Điều này hơi khác so với một trong những ví dụ đầu vào trong thử thách; Tôi đã sử dụng nó vì nó ngắn nhưng đã sửa đổi nên đầu ra chính xác sẽ là 10 thay vì 9. Điều này chỉ để thể hiện rằng số được in chính xác ngay cả khi nó có nhiều chữ số, rất khó tính bằng pb.
• Thông dịch viên là khủng khiếp, và nó hiển thị ở đây. Đáng chú ý, ký tự tab loại bỏ khoảng cách để mọi thứ không được xếp thành các phần lớn của video, bất cứ khi nào một byte được đặt thành 10, nó sẽ hiển thị ngắt dòng mặc dù ngôn ngữ vẫn coi đó là một "dòng" và thực tế là nó chỉ di chuyển con trỏ đến điểm bắt đầu thay vì xóa màn hình có nghĩa là thỉnh thoảng có một số ký tự trong video thậm chí không thực sự ở đó, chúng chỉ không bao giờ biến mất khi chúng ở đó. Có một số biện pháp bảo vệ chống lại điều này trong pbi nhưng thực tế làchr(10)không được xử lý đúng cách làm cho chúng phần lớn vô dụng ở đây. Tất cả những gì đang được nói, tôi nghĩ rằng nó gần như là đẹp để xem. Đó là một mớ hỗn độn mã khủng khiếp diễn giải mã khủng khiếp khác, những đoạn mã bị phá vỡ trước mắt bạn, và mọi thứ vẫn hoạt động vừa đủ để có câu trả lời đúng. Có vẻ như rác đang được in nhưng nếu bạn theo dõi đủ kỹ với kiến ​​thức về nguồn, bạn có thể biết được nó đang làm gì và tại sao lại xảy ra. Tôi cảm thấy như Cypher khi tôi xem video này:I... I don’t even see the code. All I see is blonde, brunette, red-head.

Nếu không có thêm rắc rối, đây là mã không được mã hóa.

### UNTIL FURTHER NOTICE, ALL CODE YOU SEE HERE   ###
### IS JUST A SIMPLE LOWERCASE PROGRAM. ALL INPUT ###
### IS PRINTED UNALTERED UNLESS ITS ASCII CODE IS ###
### IN [65, 90], IN WHICH CASE IT IS PRINTED WITH ###
### 32 ADDED TO IT.                               ###

^w[B!0]{t[B]vb[T]^>}    # Copy entire input to Y=0
                        # (If the program ended here, it would be cat!)
vb[-1]                  # Leave a flag at the end of the copy (important later)

# Next, this program will set each of those bytes to 0 or 32, then add the input again.
# A byte needs to be set to 32 iff it's in [65, 90].
# pb can't test > or <, only == and !=.
# A workaround:

# Set each byte to max((byte - 64), 0)



w[X!0]{<        # For each byte:
    t[64]         # Set T to 64 as a loop variable
    w[T!0]{       # While T != 0:
        w[B!0]{     # While the current byte not 0:
            b[B-1]v   # Subtract one from the current cell, then go down one
                      # (guaranteed to be 0 and kill the loop)
        }
        ^[Y]        # Brush is at Y=0 or Y=1 and needs to be at Y=0.
                    # ^[Y] always brings brush to Y=0
        t[T-1]      # T--
    }
}

# Bytes that are currently 0 need to be 0.
# Bytes that are currently in [27, inf) need to be 0.
# Bytes in [1, 26] need to be 32.

# Set bytes that are equal to 0 to 27
# The only groups that have to be worried about are >26 and =<26.

# Then set each byte to max((byte - 26), 0)

w[B!-1]{         # Until we hit the flag:
    w[B=0]{b[27]}   # Set any 0 bytes to 27
    t[26]           # T as loop variable again
    w[T!0]{         # While T != 0:
        w[B!0]{       # While the current byte not 0:
            b[B-1]v     # Subtract one from the current cell, then go down one
                        # (guaranteed to be 0 and kill the loop)
        }
        ^[Y]          # Brush is at Y=0 or Y=1 and needs to be at Y=0.
                      # ^[Y] always brings brush to Y=0
        t[T-1]        # T--
    }
>}
b[0]              # Clear the flag

# Set bytes that are equal to 0 to 32
# All others to 0

w[X!0]{<          # For each byte:
    w[B!0]{       # While the current byte not 0:
        b[1]v       # Set it to 1, then go down one
                    # (guaranteed to be 0 and kill the loop)
    }
    ^[Y]          # Back to Y=0 no matter what
    w[B=0]{b[32]} # Set 0 bytes to 32
    w[B=1]{b[0]}  # Set 1 bytes to 0
}

# Any byte that had a capital letter is now 32. All others are 0.
# Add the original values to the current values to finish.

^w[B!0]{          # For each byte OF ORIGINAL INPUT:
    t[B]vb[B+T]^>   # Add it to the space below
}

### ABOVE IS THE ENTIRE LOWERCASE PROGRAM. THE    ###
### REST OF THE CODE IMPLEMENTS THE ALGORITHM.    ###

vb[1]            # Leave a flag after the end, guaranteed to be further right
                 # than anything else

<w[B!9]{         # Starting from the end, until hitting a tab:
    t[B]b[0]        # Store the last byte and erase it
    vv<[X]          # Go down two columns and all the way to the left
    w[B!0]{>}       # Go right until reaching an empty space
    b[T]            # Print the stored byte
    ^^<[X]w[B!0]{>} # Go back to the end of the first line
    <
}

b[0]              # Erase the tab
<w[X!-1]{         # For each byte in the first line:
    t[B]            # Store that byte
    vb[1]           # Mark that byte to be found later
    ^w[B!1]{>}      # Find the flag at the end
    vvw[X!-1]{      # For everything in the other line:
        w[B=T]{       # If the current byte is the same as the saved byte:
            b[0]        # Set it to 0
            <[X]^       # Go to the beginning of line 2
            w[B!1]{>}   # Find the marker for where the program is working in line 1
            ^b[0]v      # Set that byte that the program is working on to 0
            t[2]        # Stay on line 2 and start looking for a 2 (will never appear)
                        # (If this block was entered, it basically breaks the outer loop.)
        }
        <
    }
    ^[Y]v           # Ensure that the brush is on Y=1
    w[B!1]{>}       # Find the marker for where the program is working in line 1
    b[0]^<          # Erase the marker and start working on the next byte
}

t[0]              # Set T to 0. It's going to be used for counting the remaining bytes.

w[B!1]{           # Until hitting the flag at the very right:
    w[B!0]{         # If the current byte is not 0:
        t[T+1]        # Add 1 to T
        b[0]          # Set the current byte to 0
    }
    >
}
b[0]              # Clear the flag

vvw[X!-1]{        # Same as above, but for Y=2
    w[B!0]{
        t[T+1]
        b[0]
    }
    <
}

# T now contains the number that needs to be printed!!
# Now, to print out a number in decimal...

>b[11]            # A flag that shows the end of the number
                  # (so 0 digits aren't confused for other empty spaces on the canvas)
^b[T]             # The number to be converted to digits
w[B!0]{           # While the number to be converted is not 0:
    vw[B!11]{>}     # Go to the flag
    t[B]b[0]>b[T]   # Move it right
    <[X]^t[B]b[0]   # Store the number to be converted to digits to T and clear its space on the canvas
    vw[B!11]{>}<    # Go to the left of the flag
    w[T!0]{         # While T is not 0:
        t[T-1]        # T--
        b[B+1]        # B++
        w[B=11]{      # If B is 10:
            b[0]        # Set it back to 0
            ^<[X]b[B+1]   # Add 1 to a counter to be converted after
            vw[B!11]{>}<  # Go back to continue converting T
        }
    }
^<[X]}

vw[B!11]{         # Add 48 to all digits to get correct ASCII value
    b[B+48]>
}

b[0]              # Clear the flag value, 0s now appear as 48 instead of 0 so it is unnecessary

<w[B!0]{          # While there are digits on Y=2:
    w[B!0]{>}<      # Go to the last one
    t[B]            # Save it to T
    ^^<[X]          # Go to (0, 0)
    w[B!0]{>}       # Go right until finding an empty space
    b[T]            # Print the digit in T
    <[X]vvw[B!0]{>} # Go to the end of Y=2
    <b[0]           # Erase it
    <               # Repeat until finished. :)
}

C ++ 199 byte

Sử dụng một mảng để lưu trữ số lượng của từng ký tự trong chuỗi đầu tiên, trừ đi số đếm trong chuỗi thứ hai. Tiếp theo, nó tìm tổng của các giá trị tuyệt đối của các phần tử của mảng: đây là khoảng cách.

Chơi gôn

#define L(c) c<91&c>64?c+32:c
int d(char*a,char*b){int l[128];int i=128,s=0;for(;i-->0;)l[i]=0;for(;a[++i];)l[L(a[i])]++;for(i=-1;b[++i];)l[L(b[i])]--;for(i=0;++i<128;)s+=i[l]>0?i[l]:-i[l];return s;}

Ung dung:

#define L(c) (c<='Z' && c>='A' ? c+'a'-'A':c)
//convert to lower case
int dist(char a[],char b[]){
  int l[128];
  int i = 128, s = 0;

  for(;i-->0;)
    l[i]=0;

  for(;a[++i]!='\0';)
    l[L(a[i])]++;

  for(i=-1;b[++i]!='\0';)
    l[L(b[i])]--;

  for(i=0;++i<128;)
    s+=i[l]>0?i[l]:-i[l];

  return s;
}

PowerShell, 79 byte

param($a,$b)$a=[char[]]$a.ToLower();$b=[char[]]$b.ToLower();(diff $a $b).Length

Hầu như chính xác mã giống như câu trả lời của tôi trên Anagram Code Golf ... nhưng ... Tôi đang gặp phải một số hành vi kỳ lạ nếu tôi chỉ lấy ra -eq0từ câu trả lời đó, vì vậy tôi cần phải giải thích rõ ràng .ToLower()và đọc lại bên ngoài paramtuyên bố. ⁺

Giải thích cũng (hầu hết) được sao chép từ câu trả lời đó - Đưa hai đầu vào chuỗi, làm cho chúng thành chữ thường và viết lại chúng dưới dạng các mảng char. Các diffchức năng (một bí danh cho Compare-Object) mất hai mảng và trả về các chỉ tiêu khác nhau giữa hai người. Chúng tôi tận dụng điều đó bằng cách đúc lại lợi nhuận dưới dạng một mảng với (), và sau đó kiểm tra độ dài của nó.

_{⁺ Ví dụ: tôi đã nhận được kết quả không có thật param([char[]]$a,[char[]]$b)(diff $a $b).lengthtrong bài kiểm tra all lowercase./ ALL UPPERCASE!. Nếu tôi tách thủ công các mảng (ví dụ: đã chạy (diff ('a','l','l'...), nó hoạt động tốt, nhưng sẽ thất bại mỗi khi có chữ hoa / chữ thường trùng lặp với việc truyền. Tất cả mọi thứ tôi có thể đọc trên tài liệu đều diffkhông phân biệt chữ hoa chữ thường, vì vậy ... nhún vai ???}

Bash, 68 67 byte

f()(fold -w1<<<"$1"|sort)
diff -i <(f "$1") <(f "$2")|grep -c ^.\ 

Tôi nghĩ rằng điều này làm việc. Lưu ý không gian dấu trên dòng thứ hai.

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

$ ./anagram "Hello, world!" "Code golf!"
9
$ ./anagram "12345 This is some text." ".txet emos si sihT 54321"
0
$ ./anagram "All unique characters here!" "Bdfgjkmopvwxyz?"
42
$ ./anagram "This is not exactly like Levenshtein distance," "but you'll notice it is quite similar."
30
$ ./anagram "all lowercase." "ALL UPPERCASE!"
8

Perl, 52 46 byte + 3 công tắc (a, F, n) = 55 49 byte

# 49 bytes (prefix 'x' to all characters so that values() could be removed)
perl -naF -E 'END{$c+=abs for%a;say$c}$a{x.lc}+=2*$.-3 for@F'

# 55 bytes
perl -naF -E 'END{$c+=abs for values%a;say$c}$a{+lc}+=2*$.-3 for@F'

Lấy đầu vào từ STDIN với các chuỗi đầu vào trong các dòng riêng của chúng, được kết thúc bằng EOF.

Công tắc:

-aF splits each input line into characters and stores this into @F
-n  loop over all input lines
-E  Execute the script from the next arg

Mã số:

# %a is the hash counting the occurances of the lowercase characters
# $. has the line number. Thus, 2*$.-3 is -1 for line 1 and +1 for line 2
$a{+lc}+=2*$.-3 for @F

# In the end (assuming 2 lines have been read), sum up the absolute values
# from the hash %a. Note that if a character occured more times in string 1
# its value be negative, if more in string 2 then positive, otherwise 0.
END {
    $c+=abs for values %a;
    say $c
}

Đồ dùng Bash + GNU, 53

S(){ sed 's/./\L&\n/g'|sort;};S>1;S|comm -3 1 -|wc -l

sedbiến đổi thành chữ thường và chia chuỗi thành dòng cho sort. Vì chúng ta cần làm điều này hai lần nên tôi đặt nó vào một hàm. comm3 -3lọc ra các dòng có liên quan và wc -ltạo ra số.

Đầu vào là thông qua STDIN; vì hai lệnh được đọc tuần tự, bạn phải gửi EOF(Ctrl-D) hai lần, giữa các chuỗi và ở cuối. Ghi đè tập tin 1, nếu có.

Matlab, 91 byte

function r=f(s,t)
s=lower(s);t=lower(t);u=unique([s t]);r=sum(abs(histc(s,u)-histc(t,u)));

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

Điều này hoạt động như sau:

1. Chuyển đổi các chuỗi thành chữ thường.
2. Tìm các ký tự duy nhất của hai chuỗi với nhau. Đó là, xác định tất cả các ký tự từng xuất hiện trong chuỗi.
3. Tính toán biểu đồ của mỗi chuỗi. Nghĩa là, đối với mỗi chuỗi tìm thấy số lần mỗi ký tự thu được trong bước 2 xuất hiện.
4. Trừ các biểu đồ và lấy giá trị tuyệt đối của sự khác biệt. Điều này thể hiện số lần một ký tự xuất hiện trong một chuỗi nhiều hơn trong chuỗi khác.
5. Kết quả là tổng của những khác biệt tuyệt đối.

Thạch , 6 byte

Œlœ^/L

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

F #, 134 126 byte

let g=Seq.countBy Char.ToLower>>List.ofSeq
let f a b=g a@g b|>Seq.groupBy fst|>Seq.sumBy(snd>>Seq.map snd>>Seq.reduce(-)>>abs)

Giải thích :

1. Đếm số lần mỗi ký tự (hạ cấp) xuất hiện trong avà briêng biệt.
2. Nhóm các số đếm với nhau theo đặc tính chung của chúng

3. Giảm từng nhóm với -toán tử, có tác dụng sau:

   • Nếu chỉ tìm thấy một giá trị (nghĩa là ký tự chỉ xuất hiện trong một đầu vào), giá trị đó được trả về.
   • Nếu hai giá trị được tìm thấy (nghĩa là ký tự xuất hiện trong cả hai đầu vào) trừ giá trị thứ hai từ giá trị thứ nhất.

4. Tính tổng giá trị tuyệt đối của các giá trị từ bước trước.

Scala , 134 81 byte

Cảm ơn @ ASCII-chỉ cho công việc của họ.

(s,t)=>{var k::l::_=List(s,t)map(_.toLowerCase.toBuffer)
((k--l)++(l--k)).length}

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