Pazartesi Mini Golf: Her Pazartesi yayınlanan (umarım!) Bir dizi kısa kod golf mücadelesi.
_{(Üzgünüm, bu biraz geç oldu.)}

İnsanların çoğunun Levenshtein mesafesini duyduğuna eminim , iki tel arasındaki mesafeyi hesaplamak için bir algoritma. Eh, bu zorluk anagram uzaklık denilen kendi buluşum * ile benzer bir algoritma uygulamaktır . En büyük fark, karakterlerin sırasının önemli olmamasıdır; bunun yerine, yalnızca bir dizeye veya diğerine özgü karakterler ölçülür.

Meydan okuma

Bu zorluğun amacı iki dizgede geçen ve aralarındaki anagram mesafesini döndüren bir program veya işlev yazmaktır. Bunu yapmanın ana yolu aşağıdaki mantığı kullanmaktır:

1. Her iki dizeyi de küçük harfe dönüştürün ve (isteğe bağlı olarak) her birinin karakterini alfabetik olarak sıralayın.
2. Dizeler en az bir eşit karakter içeriyorsa da, bu karakterin ilk örneğini her dizeden kaldırın.
3. Kalan dizelerin uzunluklarını ekleyin ve sonucu geri verin / verin.

Örnek

Girişler:

Hello, world!
Code golf!

Sonra, daha küçük harflerle sıralanır, bunlar şöyle olur: (JS'nin varsayılan sıralaması;

 !,dehllloorw
 !cdefgloo

Her iki dizedeki karakterlerin hepsini de kaldırarak bitiriyoruz:

,hllrw
cfg

Böylece, orijinal iki karakter arasındaki anagram mesafesi = 6 + 3 = 9.

ayrıntılar

• Teller herhangi bir makul biçimde alınabilir.
• Dizeler yalnızca yazdırılabilir ASCII'den oluşacaktır.
• Dizelerin kendileri normal boşluklardan başka bir boşluk içermez. (Sekme yok, yeni satır yok, vb.)
• Sonuçlar aynı olduğu sürece bu kesin algoritmayı kullanmanıza gerek yoktur.

Test-vakalar

Giriş 1:

Hello, world!
Code golf!

Çıkış 1:

9

Giriş 2:

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

Çıkış 2:

0

Giriş 3:

All unique characters here!
Bdfgjkmopvwxyz?

Çıkış 3:

42

Giriş 4:

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

Çıkış 4:

30

Giriş 5:

all lowercase.
ALL UPPERCASE!

Çıkış 5:

8

puanlama

Bu kod-golf , bayt cinsinden geçerli en kısa koddur. Tiebreaker ilk önce son bayt sayısına ulaşan gönderime gidiyor. Kazanan, 12 Ekim Pazartesi günü seçilecek. İyi şanslar!

Düzenleme: Kazanan, @isaacg, 12 bayt şaşırtıcı için Pyth (tekrar) kullanarak tebrikler !

_{* Bu algoritma başka bir yerde kullanılmışsa ve / veya başka bir isim verilmişse, lütfen bana bildirin! 20 dakikalık bir aramayla bulamadım.}

Pyth, 12 bayt

ls.-M.prR0.z

Test odası

Söz konusu işlem, Pyth'ın .-her iki yönde de uygulanmış olan bagwise çıkarma operatörüne eşittir . Bagwise xor diyebilirsiniz, sanırım.

Çözüm şudur:

.z: 2 dizgenin listesi olarak girdi al.

rR0: ikisini de küçük harfe dönüştürün.

.p: Tüm permütasyonları oluşturun, yani normal ve ters.

.-M: .-İşlemi her siparişte eşleyin.

s: Sonuçları birleştirin.

l: Uzunluğu yazdırın.

JavaScript (ES7), 92 bayt

Anonim bir işlev tanımlar.

Test etmek için aşağıdaki pasajı çalıştırın. Çıktıyı orijinalle karşılaştırmak için kodu düzenleyebilir ve 'Test'i tıklayabilirsiniz. (Bir iyileştirme bulursanız bir yorum yapın!) Giriş, "Hello, world!", "Code golf!"giriş kutusundaki gibidir.

6 byte tasarrufu için @ETHproductions'e teşekkürler!

(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>

Test paketi hakkında daha fazla bilgi

Nasıl çalışır

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

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

CJam tercümanında çevrimiçi olarak deneyin .

Nasıl çalışır

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){}}+~/$/

Daha iyi bir yol olmalı.

Düzenleme: Iamnotmaynard sayesinde çok tembel olduğum bir yolu araştıran 57 karakter.

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

Python, 90 87 81 80 79 bayt

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

Python <3.5 sürümü, 80 bayt

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

açıklama

A veya b'deki her karakter için, her dizedeki oluşum sayısını sayın ve (pozitif) farkı ekleyin.

Düzenleme: Kuralları yeniden okudum, anonim işlevler kabul edilebilir, raw_input'tan kurtularak daha iyi yanıtlar aldı. İlk golf, lütfen nazik ol!

İçi daha küçük olanı yeniden tanımlamanın ve baskının farkına varmamın iyileştirilmesi için sp3000'e teşekkürler. Ayrıca boşluklar. Hala öğreniyorum.

Python> = 3.5 kullanılarak kümeleri tanımlamanın daha kısa bir yolu vardır, bu nedenle önceki sürümlere bir bayt kaydedilebilir.

Retina, 40 20 bayt

Martin Büttner sayesinde 20 bayt kurtarıldı.

Her satırı kendi dosyasına yerleştirin ve \ndeğişmez bir yeni satırla değiştirin .

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

pb , 648 bayt

^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]<}

İki dizeyi ayıran bir sekme karakteriyle girdi alır.

Bu bir sarhoş oldu. Aslında algoritmayı uygulamak, nispeten kolay olan zor kısım değildi. Fakat pb'de yapılması zor olan iki şeyi yapmak zorunda kaldım: Büyük küçük harf duyarlılığı ve itoa. Sadece etrafta yatarak (kendisi 211 byte uzunluğunda) küçük harfe dönüştürmek için bir programa sahiptim ve bu zorluğun üstesinden gelmek için bu işi yapmak için başka her şey yoluna girmişti.

Bu programın YouTube'da yayınlanmasını izleyebilirsiniz! Yapmanız gereken aklınızda bulundurmanız gereken birkaç şey var:

• Programın bu sürümü hafifçe değiştirilmiş, 650 byte ağırlığında. Tek fark, 255'in -1 yerine bayrak değeri olarak kullanılmasıdır, çünkü yazdırmaya chr(-1)çalışmak izleme modunda çalışırken tercümanı kilitler.
• Bu videoda girdidir Hello, world!veCode golf. . Bu, mücadeledeki örnek girdilerden birinden biraz farklıdır; Kısa kullandığı için değiştirdim, ancak değiştirildi, böylece 9 yerine doğru çıktı 10 olacaktı. Bu, pb'de zor olan birden çok basamak olsa bile, sayının doğru yazdırıldığını göstermek içindir.
• Tercüman berbat ve burada gösterir. Özellikle, sekme karakteri boşluğu atar, böylece videonun büyük bölümleri için sıraya konmaz, bir bayt 10 olarak ayarlandığında, dil hala bir "satır" olarak kabul etse bile satır sonu gösterir. Ekranı silmek yerine imleci başlangıç ​​noktasına hareket ettirdiği gerçeği, videoda zaman zaman gerçekte orada bile olmayan bir dizi karakter olduğu anlamına gelir; Pbi'de buna karşı bazı korumalar var;chr(10)Düzgün bir şekilde kullanılmadığı zaman, onları burada büyük oranda işe yaramaz kılar. Tüm söylenenler, sanırım izlemek neredeyse güzel. Diğer korkunç kodları, gözlerinin önünden parçalarını parçalayan çok korkunç bir kod karışıklığı, ama yine de her şey doğru cevabı bulmaya yetecek kadar çalışıyor. Çöp basılıyor gibi gözüküyor, ancak kaynağın bilgisiyle yeterince yakından izlerseniz ne yaptığını ve nedenini her noktada yapabilirsiniz. Bu videoyu izlerken, Cypher gibi hissediyorum:I... I don’t even see the code. All I see is blonde, brunette, red-head.

Daha fazla uzatmadan, işte kod çözülmemiş kod.

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

Her karakterin sayımını birinci dizgede saklamak için bir dizi kullanır, ikinci dizgede sayımı küçültür. Daha sonra dizinin elemanlarının mutlak değerlerinin toplamını bulur: bu mesafedir.

golfed:

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

Ungolfed:

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

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

Anagram Code Golf'daki cevabımla neredeyse aynı kod ... ama ... -eq0bu cevaptan koparsam garip bir davranış alıyorum , bu yüzden açıkça .ToLower()ve parambildirimin dışında bırakmaya ihtiyacım var . ⁺

Açıklama ayrıca (çoğunlukla) bu cevaptan kopyalanmıştır - İki dize girişini alır, küçük harf yapar ve bunları yeniden karakter dizileri haline getirir. diffFonksiyonu (için bir takma Compare-Object) iki dizi ve getiri ikisi arasında farklı öğeler sürer. Geri dönüşü bir dizi olarak tekrar kullanarak ()ve uzunluğunu kontrol ederek bunu kaldırabiliriz .

_{⁺ Örneğin param([char[]]$a,[char[]]$b)(diff $a $b).length, all lowercase./ ALL UPPERCASE!testinde sahte sonuçlar alıyordum . Dizileri manuel olarak ayırırsam (örneğin, koştum (diff ('a','l','l'...), iyi çalıştı, ancak döküm ile büyük / küçük harf çakışması olduğunda her zaman başarısız olacaktı. Dokümantasyonda okuyabildiğim her şey diff, varsayılan olarak büyük / küçük harf duyarlı olmadığını belirtir , bu yüzden ... shrug ???}

Bash, 68 67 bayt

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

Ben düşünüyorum bu çalışır. İkinci satırdaki arkadaki boşluğa dikkat edin.

Test durumları

$ ./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 bayt + 3 anahtar (a, F, n) = 55 49 bayt

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

Giriş dizgileri STDIN'den kendi satırlarında, EOF ile sonlanan girdiyi alır.

Anahtarlar:

-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

Kod:

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

Bash + GNU yardımcı programları, 53

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

sedküçük harfe dönüştürür ve dizgiyi satırlara böler sort. Bunu iki kez yapmamız gerektiğinden, bir fonksiyona soktum. comm3 -3ilgili satırları filtreler wc -lve sayıyı üretir.

Giriş STDIN; iki komut sırayla okunduğundan EOF, dizelerin arasına ve sonuna iki kez (Ctrl-D) göndermelisiniz . 1Varsa, dosyanın üzerine yazar .

Matlab, 91 bayt

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

Çevrimiçi deneyin .

Bu aşağıdaki gibi çalışır:

1. Dizeleri küçük harfe dönüştürür.
2. Benzersiz karakterleri bulurİki dizenin birlikte . Yani, dizelerde görünen tüm karakterleri belirler.
3. Histogramı hesaplarHer dize . Yani, her dize için 2. adımda elde edilen karakterlerin her birinin kaç kez göründüğünü bulur.
4. Çıkarır histogramlar ve farkların mutlak değerini alır. Bir karakter bir dizede kaç kere göründüğü Bu temsil daha .
5. Sonuç, bu mutlak farklılıkların toplamıdır.

Jöle , 6 bayt

Œlœ^/L

Çevrimiçi deneyin!

F #, 134 126 bayt

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)

Açıklama :

1. Her bir (küçük harf) karakterin göründüğü sayısı aveb ayrı ayrı .
2. Sayıları ortak karakterlerine göre gruplayın

3. Her grubu -aşağıdaki etkiye sahip olan operatörle azaltın :

   • Sadece bir değer bulunursa (yani karakter sadece bir girişte gözüküyorsa), bu değer döndürülür.
   • İki değer bulunursa (yani, her iki girişte de karakter belirdi ise), ikinci değeri ilk olandan çıkarın.

4. Önceki adımdaki değerlerin mutlak değerini toplayın.

Scala , 134 81 bayt

ASCII @ çalışmaları için sadece @ teşekkürler.

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

Çevrimiçi deneyin!