Montag Minigolf: Eine Reihe von kurzen Code-Golf- Herausforderungen, die (hoffentlich!) Jeden Montag veröffentlicht werden.
_{(Sorry, das ist ein bisschen spät.)}

Ich bin sicher, die meisten von Ihnen haben von Levenshtein distance gehört , einem Algorithmus zur Berechnung des Abstands zwischen zwei Saiten. Nun, bei dieser Herausforderung geht es darum, einen ähnlichen Algorithmus meiner eigenen Erfindung *, genannt Anagramm-Distanz, zu implementieren . Der wesentliche Unterschied besteht darin , dass die Reihenfolge der Zeichen keine Rolle spielt; Stattdessen werden nur die Zeichen gemessen, die für die eine oder die andere Zeichenfolge eindeutig sind.

Herausforderung

Das Ziel der Herausforderung ist es, ein Programm oder eine Funktion zu schreiben, die zwei Zeichenfolgen enthält und den Anagrammabstand zwischen ihnen zurückgibt. Der wichtigste Weg, dies zu tun, ist die folgende Logik zu verwenden:

1. Konvertieren Sie beide Strings in Kleinbuchstaben und (optional) sortieren jeweils alphabetisch Charaktere ein.
2. Während die Saiten mindestens ein Gleichheitszeichen enthalten, aus jeder Zeichenfolge, die die erste Instanz dieses Zeichen entfernen.
3. Addieren Sie die Längen der verbleibenden Zeichenfolgen und geben Sie das Ergebnis aus.

Beispiel

Wenn die Eingaben sind:

Hello, world!
Code golf!

Dann kleingeschrieben und sortiert, diese werden: (von JS-Standard Art, beachten Sie die führenden Leerzeichen)

 !,dehllloorw
 !cdefgloo

Entfernen alle Zeichen, die in beiden Strings sind wir am Ende mit:

,hllrw
cfg

Somit wird das anagramm Abstand zwischen den ursprünglichen beiden Strings = 6 + 3 = 9.

Einzelheiten

• Die Zeichenfolgen können in jedem vernünftigen Format aufgenommen werden.
• Die Zeichenfolgen bestehen nur aus druckbarem ASCII.
• Die Zeichenfolgen selbst enthalten keine anderen Leerzeichen als normale Leerzeichen. (Keine Tabulatoren, Zeilenumbrüche usw.)
• Sie müssen nicht genau diesen Algorithmus verwenden, solange die Ergebnisse die gleichen sind.

Testfälle

Eingang 1:

Hello, world!
Code golf!

Ausgang 1:

9

Eingang 2:

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

Ausgang 2:

0

Eingang 3:

All unique characters here!
Bdfgjkmopvwxyz?

Ausgang 3:

42

Eingang 4:

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

Ausgang 4:

30

Eingang 5:

all lowercase.
ALL UPPERCASE!

Ausgang 5:

8

Wertung

Dies ist Code-Golf , so kürzester gültigen Code in Bytes gewinnt. Tiebreaker geht an Unterwerfung , die zuerst seine letzte Byte - Zählung erreicht. Der Gewinner wird am kommenden Montag, den 12. Oktober, ermittelt. Viel Glück!

Bearbeiten: Herzlichen Glückwunsch an den Gewinner, @isaacg, mit Pyth (wieder) für erstaunliche 12 Bytes!

_{* Wenn dieser Algorithmus an anderer Stelle verwendet wurde und / oder einen anderen Namen hat, lassen Sie es mich bitte wissen! Ich konnte es mit einer 20-minütigen Suche nicht finden.}

Pyth, 12 Bytes

ls.-M.prR0.z

Testsuite

Die fragliche Operation ist äquivalent zu Pyths bagwise Subtraktionsoperator .-, der in beide Richtungen angewendet wird. Man könnte es bagwise xor nennen, nehme ich an.

Die Lösung ist:

.z: Eingabe als Liste von 2 Zeichenketten erhalten.

rR0: beide in Kleinbuchstaben umwandeln.

.p: Bilden Sie alle Permutationen, dh normal und umgekehrt.

.-M: .-Ordnen Sie den Vorgang jeder Bestellung zu.

s: Verketten Sie die Ergebnisse.

l: Länge drucken.

JavaScript (ES7), 92 Byte

Definiert eine anonyme Funktion.

Führen Sie zum Testen das folgende Snippet aus. Sie können den Code bearbeiten und auf "Testen" klicken, um die Ausgabe mit dem Original zu vergleichen. (Hinterlasse einen Kommentar, wenn du eine Verbesserung findest!) Die Eingabe erfolgt wie "Hello, world!", "Code golf!"im Eingabefeld.

Vielen Dank an @ETHproductions für die Einsparung von 6 Bytes!

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

Mehr zur Testsuite

Wie es funktioniert

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

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

Versuchen Sie es online in dem CJam Dolmetscher .

Wie es funktioniert

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.

Rubin, 62

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

Es muss einen besseren Weg geben.

Edit: 57 Zeichen dank iamnotmaynard, der einen Pfad untersucht, zu dem ich zu faul war.

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

Python, 90 87 81 80 79 Bytes

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-Version, 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)))

Erläuterung

Zählen Sie für jedes Zeichen in a oder b die Anzahl der Vorkommen in jeder Zeichenfolge auf und addieren Sie die (positive) Differenz.

Bearbeiten: Regeln neu lesen, erkannte anonyme Funktionen sind akzeptabel, verbesserte Antwort durch Wegfall von raw_input. Erster Golf, bitte sei sanft!

Dank an sp3000 für die Verbesserung der Neudefinition von str.lower und die Erkenntnis, dass das Drucken unnötig war. Auch Leerzeichen. Ich lerne immernoch.

Mit python> = 3.5 können Sets auf kürzere Weise definiert werden, sodass ein Byte gegenüber früheren Versionen gespeichert werden kann.

Retina, 40 bis 20 Bytes

20 Bytes gespart dank Martin Büttner.

Platzieren Sie jede Zeile in einer eigenen Datei und ersetzen Sie die \ndurch eine wörtliche neue Zeile.

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

pb , 648 bytes

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

Nimmt Eingaben mit einem Tabulatorzeichen vor, das die beiden Zeichenfolgen voneinander trennt.

Dieser war ein Trottel. Den Algorithmus tatsächlich zu implementieren, war nicht der schwierige Teil, der relativ einfach zu bewältigen war. Aber ich musste zwei Dinge tun, die in pb schwierig zu tun sind: Groß- und Kleinschreibung und itoa. Ich hatte zufällig ein Programm zum Konvertieren in Kleinbuchstaben, das nur herumlag (selbst 211 Bytes lang), und alles andere wurde ans Ende geheftet, um die Arbeit speziell für diese Herausforderung zu erledigen.

Sie können dieses Programm auf YouTube sehen! Es gibt ein paar Dinge, die Sie beachten sollten, wenn Sie dies tun:

• Diese Version des Programms ist leicht modifiziert und hat ein Gewicht von 650 Bytes. Der einzige Unterschied besteht darin, dass 255 anstelle von -1 als Flag-Wert verwendet wird, da chr(-1)der Interpreter beim Versuch, zu drucken, abstürzt, wenn er im Überwachungsmodus ausgeführt wird.
• Die Eingabe in diesem Video ist Hello, world!und Code golf.. Dies unterscheidet sich geringfügig von einem der Beispieleingaben in der Challenge. Ich habe es verwendet, weil es kurz war, aber es so modifiziert, dass die richtige Ausgabe 10 statt 9 ist. Dies soll nur zeigen, dass die Zahl korrekt gedruckt wird, auch wenn es sich um mehrere Ziffern handelt, was in pb hart ist.
• Der Dolmetscher ist schrecklich und es zeigt sich hier. Insbesondere wird der Abstand durch das Tabulatorzeichen verringert, sodass große Teile des Videos nicht aneinandergereiht werden. Wenn ein Byte auf 10 gesetzt wird, wird ein Zeilenumbruch angezeigt, obwohl die Sprache es immer noch als eine "Zeile" ansieht Die Tatsache, dass der Cursor nur an den Anfang bewegt wird, anstatt den Bildschirm zu löschen, bedeutet, dass das Video gelegentlich eine Reihe von Zeichen enthält, die nicht wirklich vorhanden sind. Es gibt einige Schutzmaßnahmen dagegen in pbi, aber die Tatsache, dasschr(10)wird nicht richtig gehandhabt macht sie hier weitgehend unbrauchbar. Trotzdem finde ich es fast schön, das zu sehen. Es ist ein riesiges Durcheinander von schrecklichem Code, der anderen schrecklichen Code interpretiert, Teile davon werden vor Ihren Augen zerstört, und doch funktioniert alles gerade genug, um die richtige Antwort zu erhalten. Es sieht so aus, als würde Müll gedruckt, aber wenn Sie mit Kenntnis der Quelle genau hinschauen, können Sie jederzeit erkennen, was er tut und warum. Ich fühle mich wie Cypher, wenn ich dieses Video anschaue:I... I don’t even see the code. All I see is blonde, brunette, red-head.

Ohne weiteres ist hier der Code ungolfed.

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

Verwendet ein Array, um die Anzahl der Zeichen in der ersten Zeichenfolge zu speichern, und minimiert die Anzahl in der zweiten Zeichenfolge. Als nächstes wird die Summe der absoluten Werte der Elemente des Arrays ermittelt: Dies ist der Abstand.

Golf gespielt:

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

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

Fast derselbe Code wie meine Antwort auf Anagram Code Golf ... aber ... ich bekomme ein seltsames Verhalten, wenn ich -eq0die Antwort einfach abschneide , so dass ich es nötig habe, .ToLower()außerhalb der paramDeklaration explizit eine Neufassung vorzunehmen . ⁺

Erklärung auch (meistens) aus dieser Antwort kopiert - Nimmt die beiden Zeichenfolgeneingaben auf, macht sie klein und wandelt sie in Zeichen-Arrays um. Die diffFunktion (ein Alias ​​fürCompare-Object ) nimmt die beiden Arrays und gibt Elemente zurück, die sich zwischen den beiden unterscheiden. Wir nutzen dies, indem wir die Rückgabe als Array mit umwandeln ()und dann ihre Länge überprüfen.

_{⁺ Ich habe zum Beispiel falsche Ergebnisse param([char[]]$a,[char[]]$b)(diff $a $b).lengthfür den all lowercase./ ALL UPPERCASE!-Test erhalten. Wenn ich die Arrays manuell aussortierte (z. B. lief (diff ('a','l','l'...), funktionierte es einwandfrei, schlug jedoch jedes Mal fehl, wenn sich das Casting mit Groß- / Kleinschreibung überschnitt. Alles, was ich in der Dokumentation lesen kann, besagt, dass diffstandardmäßig zwischen Groß- und Kleinschreibung unterschieden wird. Also ... Achselzucken ???}

Bash, 68 67 Bytes

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

Ich denke das funktioniert. Beachten Sie das nachstehende Leerzeichen in der zweiten Zeile.

Testfälle

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

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

Übernimmt die Eingabe von STDIN mit den Eingabezeichenfolgen in ihren eigenen Zeilen, die von EOF abgeschlossen werden.

Schalter:

-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

Code:

# %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-Utils, 53

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

sedWandelt in Kleinbuchstaben um und teilt die Zeichenfolge in Zeilen für sort. Da wir das zweimal machen müssen, habe ich es in eine Funktion eingefügt. comm3 -3filtert die relevanten Zeilen heraus und wc -lerzeugt die Nummer.

Die Eingabe erfolgt über STDIN; Da zwei Befehle nacheinander gelesen werden, müssen Sie EOFzweimal (Strg-D) zwischen den Zeichenfolgen und am Ende senden . Überschreibt die Datei 1, falls vorhanden.

Matlab, 91 Bytes

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

Probieren Sie es online aus .

Das funktioniert wie folgt:

1. Konvertiert die Zeichenfolgen in Kleinbuchstaben.
2. Findet die eindeutigen Zeichen der beiden Zeichenfolgen zusammen. Das heißt, bestimmt alle Zeichen, die jemals in den Zeichenfolgen erscheinen.
3. Berechnet das Histogramm jeder Zeichenfolge. Das heißt, für jede Zeichenfolge wird ermittelt, wie oft jedes der in Schritt 2 erhaltenen Zeichen angezeigt wird.
4. Subtrahiert die Histogramme und berechnet den absoluten Wert der Differenzen. Dies gibt an, wie oft ein Zeichen in einer Zeichenfolge mehr vorkommt als in der anderen.
5. Das Ergebnis ist die Summe dieser absoluten Differenzen.

Gelee , 6 Bytes

Œlœ^/L

Probieren Sie es online!

F #, 134 126 Bytes

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)

Erklärung :

1. Zählen Sie, wie oft jedes Zeichen (in Kleinbuchstaben) in angezeigt wird a und vorkommtb getrennt .
2. Gruppieren Sie die Zählungen nach ihrem gemeinsamen Charakter

3. Reduzieren Sie jede Gruppe mit dem -Operator, was folgende Auswirkungen hat:

   • Wird nur ein Wert gefunden (dh das Zeichen ist nur in einer Eingabe enthalten), wird dieser Wert zurückgegeben.
   • Wenn zwei Werte gefunden werden (dh das Zeichen ist in beiden Eingaben enthalten), subtrahieren Sie den zweiten Wert vom ersten.

4. Summieren Sie den absoluten Wert der Werte aus dem vorherigen Schritt.

Scala , 134 81 Bytes

Danke @ ASCII-only für die Arbeit.

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

Probieren Sie es online!