সোমবার মিনি-গল্ফ # 3: অ্যানগ্রামের দূরত্ব

24

সোমবার মিনি-গল্ফ: সংক্ষিপ্ত কোড-গল্ফ চ্যালেঞ্জগুলির একটি সিরিজ , প্রতি সোমবার পোস্ট করা (আশাবাদী!)
(দুঃখিত এইটাকে একটু দেরি করে ফেলেছে।)

আমি নিশ্চিত যে আপনারা অধিকাংশ লোক লেভেনস্টেইন দূরত্ব শুনেছেন, দুটি স্ট্রিংয়ের মধ্যকার দূরত্ব গণনার জন্য একটি অ্যালগরিদম। ভাল, এই চ্যালেঞ্জটি আমার নিজের আবিষ্কারের * অনুরূপ একটি অ্যালগরিদম বাস্তবায়নের বিষয়ে, যাকে বলা হয় অ্যানগ্রামগ্রাম দূরত্ব । মূল পার্থক্য হ'ল চরিত্রগুলির ক্রমটি কোনও ব্যাপার নয়; পরিবর্তে, কেবল একটি অক্ষর যা একটি স্ট্রিং বা অন্যটির সাথে অনন্য meas

চ্যালেঞ্জ

চ্যালেঞ্জের লক্ষ্য হ'ল এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা দুটি স্ট্রিংয়ের মধ্যে লাগে এবং তাদের মধ্যে অ্যানগ্রামের দূরত্ব ফিরিয়ে দেয়। এটি করার প্রধান উপায় নিম্নলিখিত যুক্তি ব্যবহার করা:

  1. উভয় স্ট্রিংকে ছোট হাতের অক্ষরে রূপান্তর করুন এবং (বিকল্পভাবে) প্রত্যেকের অক্ষর বর্ণমালা অনুসারে বাছাই করুন।
  2. স্ট্রিংগুলিতে কমপক্ষে একটি সমান অক্ষর থাকা অবস্থায়, প্রতিটি স্ট্রিং থেকে এই অক্ষরের প্রথম উদাহরণটি সরিয়ে ফেলুন।
  3. অবশিষ্ট স্ট্রিংগুলির দৈর্ঘ্য যুক্ত করুন এবং ফলাফলটি ফেরত / আউটপুট দিন।

উদাহরণ

যদি ইনপুটগুলি হয়:

Hello, world!
Code golf!

তারপরে, নিম্নতর এবং সাজানো, এগুলি হয়ে যায়: (জেএসের ডিফল্ট বাছাই অনুসারে; শীর্ষস্থানগুলি নোট করুন)

 !,dehllloorw
 !cdefgloo

দুটি অক্ষরে থাকা সমস্ত অক্ষর মুছে ফেলা হচ্ছে, আমরা এখানেই শেষ করব:

,hllrw
cfg

সুতরাং, মূল দুটি স্ট্রিং = 6 + 3 = 9 এর মধ্যে অ্যানগ্রামের দূরত্ব।

বিস্তারিত

  • স্ট্রিংগুলি যে কোনও সংবেদনশীল বিন্যাসে নেওয়া যেতে পারে।
  • স্ট্রিংগুলি কেবল প্রিন্টযোগ্য এএসসিআইআই সমন্বিত থাকবে।
  • স্ট্রিংগুলিতে নিয়মিত স্পেস ব্যতীত অন্য কোনও শ্বেত স্পেস থাকবে না। (কোনও ট্যাব, নিউলাইন ইত্যাদি নেই)
  • যতক্ষণ না ফলাফল একই থাকে আপনার এই সঠিক অ্যালগরিদম ব্যবহার করার দরকার নেই।

টেস্ট-মামলা

ইনপুট 1:

Hello, world!
Code golf!

আউটপুট 1:

9

ইনপুট 2:

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

আউটপুট 2:

0

ইনপুট 3:

All unique characters here!
Bdfgjkmopvwxyz?

আউটপুট 3:

42

ইনপুট 4:

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

আউটপুট 4:

30

ইনপুট 5:

all lowercase.
ALL UPPERCASE!

আউটপুট 5:

8

স্কোরিং

এটি কোড-গল্ফ , তাই বাইট জেতে সংক্ষিপ্ততম বৈধ কোড। টাইব্রেকার সাবমিশনে যায় যা তার চূড়ান্ত বাইট গণনাটি প্রথম পৌঁছেছিল। বিজয়ী পরের সোমবার, 12 অক্টোবর নির্বাচন করা হবে। শুভকামনা!

সম্পাদনা: বিজয়ীর অভিনন্দন, @ আইস্যাক, একটি চমকপ্রদ 12 বাইটের জন্য পাইথ (আবার) ব্যবহার করে !

* যদি এই অ্যালগরিদম অন্য কোথাও ব্যবহার করা হয়েছে এবং / অথবা অন্য কোনও নাম দেওয়া হয়েছে, দয়া করে আমাকে জানান! আমি 20 মিনিটের অনুসন্ধানের সাথে এটি সন্ধান করতে পারিনি।

code-golf  string 
— ETHproductions
সূত্র
পরবর্তীকালে "আপনার এই সঠিক অ্যালগরিদম ব্যবহার করার দরকার নেই […]" যোগসূত্রটি একেবারে বিপরীত বিষয় হিসাবে যুক্ত করার জন্য "একটি প্রোগ্রাম লিখুন […] যা নীচের যুক্তি ব্যবহার করে [জিনিসগুলি করে]" এমন একটি প্রোগ্রাম লিখুন] হিসাবে বর্ণনা করা a
— ou
@ Ouডুয়ার্ড ট্রু; যে ইশারা জন্য ধন্যবাদ. আমি বিশ্বাস করি এটি এখন আরও ভাল।
— ETH প্রোডাকশনগুলি
ইতোমধ্যে আবার মঙ্গলবার। ;)
— মার্টিন ইন্ডার
@ মার্টিনবাটনার আপনি ওয়াই-ফাই ছাড়াই রাস্তায় চলার সময় একটি চ্যালেঞ্জ লিখতে খুব কষ্টকর। ;) চিন্তা করবেন না, আমি কিছুক্ষণের মধ্যে একটি নতুন প্রস্তুত করব।
— ইটিএইচ প্রডাকশন

উত্তর:

14

পাইথ, 12 বাইট

ls.-M.prR0.z

পরীক্ষা স্যুট

প্রশ্নে থাকা অপারেশনটি পাইথের ব্যাগওয়াইস বিয়োগফল অপারেটরের সমতুল্য .-, উভয় দিকেই প্রয়োগ করা হয়েছে। আমার ধারণা, আপনি এটিকে ব্যাগওয়াইজ জোর বলতে পারেন।

সমাধানটি হ'ল:

.z: 2 টি স্ট্রিংয়ের তালিকা হিসাবে ইনপুট পান।

rR0: উভয়কে ছোট হাতের মধ্যে রূপান্তর করুন।

.p: সমস্ত ক্রম গঠন, যেমন স্বাভাবিক এবং বিপরীত গঠন।

.-M: .-প্রতিটি ক্রম উপর ক্রিয়াকলাপ মানচিত্র ।

s: ফলাফল প্রতিহত করা।

l: দৈর্ঘ্য মুদ্রণ করুন।

— isaacg
সূত্র
এবং আমি ভেবেছিলাম সমস্ত উত্তর অতিরিক্ত দীর্ঘ হতে পারে .... ভাল!
— ইটিএইচ প্রডাকশনগুলি
8

জাভাস্ক্রিপ্ট (ES7), 92 বাইট

একটি বেনামী ফাংশন সংজ্ঞায়িত করে।

পরীক্ষা করতে নীচের স্নিপেটটি চালান। আপনি কোডটি সম্পাদনা করতে পারেন এবং এর আউটপুটটিকে মূলের সাথে তুলনা করতে 'টেস্ট' এ ক্লিক করতে পারেন। (আপনি যদি কোনও উন্নতি খুঁজে পান তবে একটি মন্তব্য দিন!) ইনপুটটি "Hello, world!", "Code golf!"ইনপুট বাক্সের মতো।

6 বাইট সংরক্ষণের জন্য @ETH প্রডাকশনগুলিকে ধন্যবাদ!


(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>
স্নিপেট প্রসারিত করুন

পরীক্ষার স্যুট সম্পর্কে আরও


কিভাবে এটা কাজ করে

//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
— jrich
সূত্র
আমি এক ঘন্টা ধরে অ্যারে-ভিত্তিক ES6 উত্তরে কাজ করছি, এবং কেবল এটি 122-এ নামাতে সক্ষম হয়েছি See মনে হয় আমি ভুল দিকে চেয়েছিলাম! +1
— ইটিএইচ প্রোডাকশনস
BTW, আসতে পারবে না .join("")+bসঙ্গে .join``+bকোনো প্রভাব সঙ্গে।
— ইটিএইচ প্রোডাকশনস
1
বাহ, পৃথিবীতে আপনি কোথায় এই পরীক্ষার স্যুট পেয়েছেন? উজ্জ্বল! আমি আশা করি আমি আরও তিন বা চারবার +1 করতে পারতাম ....
— ETH প্রোডাকশনগুলি
@ ইথ প্রডাকশনস আপনাকে ধন্যবাদ! : ডিআই নিজেই পরীক্ষার স্যুট তৈরি করেছিলেন। পরীক্ষা করে দেখুন আমার মেটা পোস্ট!
— ই
আমি সেখানে +1 করেছি, আশা করি এটি এখানে +5 করতে না পারার জন্য প্রস্তুত। ;)
— ইটিএইচ প্রডাকশনগুলি
6

সিজেম, 23 19 বাইট

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

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

কিভাবে এটা কাজ করে

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.
— ডেনিস
সূত্র
4

রুবি, 62

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

এখানে অবশ্যই একটি ভাল রাস্তা আছে।

সম্পাদনা: 57 টি অক্ষর আইমনোটমায়ার্ডকে এমন একটি পথ অনুসন্ধানের জন্য ধন্যবাদ যা আমি খুব অলস হয়ে গিয়েছিলাম।

#!ruby -naF|
gets.upcase!
p$F.count{|c|!$_.sub!(c.upcase){}}+~/$/
— histocrat
সূত্র
subস্ট্রিং নিতে পারেন। আপনি ব্যবহার করা যায়নি c.downcaseপরিবর্তে /#{Regexp.escape c}/i?
— মনিকা iamnotmaynard
আমার উভয় স্ট্রিং (বা সমতলভাবে
— সমতল
আহ, অবশ্যই (যদিও এটি আমার কাছে দেখে মনে হচ্ছে যে এটি করা আপনার এখনও
— কয়েকটা
4

পাইথন, 90 87 81 80 79 বাইট

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

পাইথন <3.5 সংস্করণ, 80 বাইট

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

ব্যাখ্যা

একটি বা খ প্রতিটি অক্ষরের জন্য, প্রতিটি স্ট্রিংয়ের সংখ্যার সংখ্যা গণনা করুন এবং (ধনাত্মক) পার্থক্য যুক্ত করুন।

সম্পাদনা করুন: নিয়মগুলি পুনরায় পড়ুন, অনুধাবন করা বেনামে ফাংশনগুলি গ্রহণযোগ্য, কাঁচ_আইনপুট থেকে মুক্তি পেয়ে উন্নত উত্তর। প্রথম গল্ফ, দয়া করে সৌম্য হন!

Str.lower পুনরায় সংজ্ঞায়নের উন্নতি এবং আমাকে মুদ্রণ উপলব্ধি করানোর জন্য sp3000 কে ধন্যবাদ অপ্রয়োজনীয় ছিল। স্পেসসও। এখনো শিখছি.

পাইথন> = 3.5 ব্যবহার করে সেট সংজ্ঞায়নের জন্য একটি ছোট্ট উপায় রয়েছে, যাতে পূর্ববর্তী সংস্করণগুলিতে একটি বাইট সংরক্ষণ করা যায়।

— ঐ মেগো
সূত্র
3

রেটিনা, 40 20 বাইট

মার্টিন বাটনারকে 20 বাইট সংরক্ষণ করা হয়েছে thanks

প্রতিটি লাইন তার নিজস্ব ফাইলে রাখুন এবং \nআক্ষরিক নতুন লাইনের সাথে প্রতিস্থাপন করুন ।

+i`(.)(.*\n.*)\1
$2
.
— এক নম্বর
সূত্র
2

পিবি , 648 বাইট

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

দুটি স্ট্রিংকে পৃথক করে একটি ট্যাব অক্ষরের সাথে ইনপুট নেয়।

এই ছিল একটি doozy। আসলে অ্যালগরিদম বাস্তবায়ন করা শক্ত অংশ ছিল না, এটি তুলনামূলকভাবে সহজেই এসেছিল। কিন্তু আমার দু'টি কাজ করতে হয়েছিল যা পিবিতে করা কঠিন: কেস সংবেদনশীলতা এবং আইটোয়া। আমি প্রায় শুয়ে থাকা ছোট হাতের অক্ষরে রূপান্তর করার জন্য একটি প্রোগ্রাম করেছি (নিজে 211 বাইট দীর্ঘ) এবং এই চ্যালেঞ্জটির জন্য বিশেষভাবে কাজ করার জন্য সমস্ত কিছু শেষের দিকে সামলাতে হয়েছিল।

আপনি এই প্রোগ্রামটি ইউটিউবে চালিত দেখতে পারেন! আপনি যদি কিছু করেন তবে আপনার কয়েকটি বিষয় মনে রাখা উচিত:

  • প্রোগ্রামটির এই সংস্করণটি 650 বাইটের ওজনে কিছুটা সংশোধিত হয়েছে। পার্থক্যটি হ'ল 255 -1 এর পরিবর্তে ফ্ল্যাগ মান হিসাবে ব্যবহৃত হয়, কারণ chr(-1)ওয়াচ মোডে চলাকালীন দোভাষীকে ক্র্যাশ করে দেওয়ার চেষ্টা করা হয় ।
  • এই ভিডিওটির ইনপুটটি হ'ল Hello, world!এবং Code golf.। এটি চ্যালেঞ্জের উদাহরণ ইনপুটগুলির তুলনায় কিছুটা আলাদা; আমি এটি ব্যবহার করেছি কারণ এটি সংক্ষিপ্ত ছিল তবে এটি সংশোধিত হয়েছে তাই সঠিক আউটপুটটি 9 এর পরিবর্তে 10 হবে This এটি কেবল দেখানোর জন্য যে সংখ্যাটি একাধিক সংখ্যা হলেও সঠিকভাবে মুদ্রিত হয়েছে, যা পিবিতে শক্ত।
  • দোভাষী দারুণ, এবং এটি এখানে দেখায়। উল্লেখযোগ্যভাবে, ট্যাব চরিত্রটি স্পেসিং বন্ধ করে দেয় যাতে ভিডিওর বৃহত অংশগুলির জন্য জিনিসগুলি সারিবদ্ধ না করা হয়, যখনই কোনও বাইট 10 এ সেট করা হয় তবে এটি এখনও একটি ভাষা "লাইন" হিসাবে বিবেচনা করে এমন একটি লাইন বিরতি দেখায় এবং এবং এটি স্ক্রিনটি সাফ করার পরিবর্তে কার্সারটিকে শুরুতে সরিয়ে দেয় তার অর্থ হ'ল ভিডিওতে মাঝে মধ্যে এমন অনেকগুলি চরিত্র রয়েছে যা সত্যিকার অর্থে সেখানে নেই, তারা যখন ছিল তখন থেকে কখনই দূরে সরে যায় না। পিবিআইতে এর বিরুদ্ধে কিছু সুরক্ষা রয়েছে তবে এটি সত্যchr(10)সঠিকভাবে পরিচালনা করা হয় না এগুলি এখানে বড় পরিমাণে অকেজো করে তোলে। যা যা বলা হচ্ছে, আমার মনে হয় এটি দেখতে প্রায় একরকম সুন্দর। এটি অন্যান্য ভয়াবহ কোডকে ব্যাখ্যা করার মতো ভয়াবহ কোডের একটি বিশাল গণ্ডগোল, এর টুকরোগুলি আপনার চোখের সামনে ভেঙে যাচ্ছে এবং তবুও সবকিছু সঠিক উত্তর পেতে যথেষ্ট কাজ করে। দেখে মনে হচ্ছে আবর্জনা মুদ্রিত হচ্ছে তবে আপনি উত্সটির জ্ঞানের সাথে যদি খুব ঘনিষ্ঠভাবে নজর রাখেন তবে আপনি এটি কী করছে এবং কেন কোনও বিন্দুতে তা নির্ধারণ করতে পারেন। আমি যখন এই ভিডিওটি দেখি তখন সাইফারের মতো অনুভব করি:I... I don’t even see the code. All I see is blonde, brunette, red-head.

আরও অগ্রগতি ব্যতীত, এখানে কোড রহিত।

### 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. :)
}
— undergroundmonorail
সূত্র
2

সি ++ 199 বাইট

প্রথম স্ট্রিংয়ে প্রতিটি অক্ষরের গণনা সঞ্চয় করতে একটি অ্যারে ব্যবহার করে, দ্বিতীয় স্ট্রিংয়ে গণনাটি মিনিট করে। এরপরে এটি অ্যারের উপাদানগুলির পরম মানগুলির যোগফল খুঁজে পায়: এটিই দূরত্ব।

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;
}
— MegaTom
সূত্র
1

পাওয়ারশেল, 79 বাইট

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

আনামগ্রাম কোড গল্ফে আমার উত্তর হিসাবে প্রায় একই কোডটি ... তবে ... আমি যদি কেবল -eq0উত্তরটি বাদ না দিয়ে থাকি তবে আমি কিছুটা অদ্ভুত আচরণ পাচ্ছি , সুতরাং আমি স্পষ্টভাবে বলার দরকার পড়েছিলাম.ToLower()param ঘোষণার বাইরে এবং পুনরায় আবশ্যক । + +

ব্যাখ্যাটিও (বেশিরভাগই) সেই উত্তর থেকে অনুলিপি করা হয়েছে - দুটি স্ট্রিং ইনপুট নেয়, সেগুলি ছোট করে তোলে এবং তাদের চর-অ্যারে হিসাবে পুনরায় কাস্ট করে। diffফাংশন (জন্য উপনামCompare-Object ) দুইটি অ্যারের এবং আয় আইটেম দুই মধ্যে ভিন্ন লাগে। আমরা রিটার্নটিকে অ্যারের হিসাবে পুনরায় কাস্ট করে ()এবং তার দৈর্ঘ্যটি পরীক্ষা করে তার মাধ্যমে উত্তোলন করি ।

+ + উদাহরণস্বরূপ, আমি বাজে ফলাফল পেয়ে ছিল param([char[]]$a,[char[]]$b)(diff $a $b).lengthউপর all lowercase./ ALL UPPERCASE!পরীক্ষা। যদি আমি ম্যানুয়ালি অ্যারেগুলি (যেমন, রান (diff ('a','l','l'...) আলাদা করে ফেলেছিলাম তবে এটি ভাল কাজ করেছে তবে প্রতিবার কাস্টিংয়ের সাথে মূলধন / লোয়ারকেস ওভারল্যাপ থাকলে ব্যর্থ হবে। আমি ডকুমেন্টেশনে যা কিছু পড়তে পারি তা diffডিফল্টরূপে সংবেদনশীল, তাই ... সঙ্কুচিত ???

— AdmBorkBork
সূত্র
খুব অদ্ভুত. এটি অন্য কোনও ক্ষেত্রে (এমনকি বিভিন্ন ক্ষেত্রে সংবেদনশীলতা সহ) প্রয়োজন হয় না।
— জোনাথন লিচ-পেপিন
1

বাশ, 68 67 বাইট

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

আমি মনে করি এটি কাজ করে। দ্বিতীয় লাইনের পিছনের স্থানটি নোট করুন।

পরীক্ষার মামলা

$ ./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
— ডেনিস
সূত্র
1

পার্ল, 52 46 বাইট + 3 সুইচ (এ, এফ, এন) = 55 49 বাইট

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

ইওএফ দ্বারা সমাপ্ত হওয়া, নিজস্ব লাইনে ইনপুট স্ট্রিং সহ এসটিডিএন থেকে ইনপুট নেয় T

সুইচ:

-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

কোড:

# %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
}
— svsd
সূত্র
1

বাশ + জিএনইউ ব্যবহার, 53

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

sedলোয়ারকেস এ রূপান্তর করে এবং স্ট্রিংকে লাইনে বিভক্ত করে sort। যেহেতু আমাদের এটি দুবার করা দরকার আমি এটি একটি ফাংশনে রেখেছি। comm3 -3সম্পর্কিত লাইনগুলি ফিল্টার করে এবংwc -l করে এবং সংখ্যাটি উত্পাদন করে।

ইনপুট মাধ্যমে হয় STDIN; যেহেতু দুটি কমান্ড ক্রমানুসারে পড়া হয়, আপনাকে EOFস্ট্রিংগুলির শেষে এবং শেষে দুটি বার (Ctrl-D) প্রেরণ করতে হবে । ওভাররাইট ফাইল 1, যদি উপস্থিত থাকে।

— xebtl
সূত্র
1

মতলব, 91 বাইট

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

এটি অনলাইনে চেষ্টা করুন ।

এটি নিম্নলিখিত হিসাবে কাজ করে:

  1. স্ট্রিংগুলি লোয়ার কেসে রূপান্তরিত করে।
  2. অনন্য অক্ষর সন্ধান করেদুটি স্ট্রিংয়ের একসাথে । অর্থাৎ, স্ট্রিংগুলিতে প্রদর্শিত সমস্ত অক্ষর নির্ধারণ করে।
  3. নির্ণয় করে হিস্টোগ্রাম প্রতিটি স্ট্রিং এর। এটি হ'ল প্রতিটি স্ট্রিংয়ের জন্য দ্বিতীয় ধাপে প্রাপ্ত প্রতিটি অক্ষর কতবার উপস্থিত হয় তা আবিষ্কার করে।
  4. হিস্টোগ্রামগুলি বিয়োগ করে এবং পার্থক্যের নিখুঁত মান নেয়। এটি একটি স্ট্রিংয়ে আরও কতবার অক্ষর প্রদর্শিত হয় তা উপস্থাপন করে চেয়ে অন্য চেয়ে
  5. ফলাফলটি সেই নিখুঁত পার্থক্যের সমষ্টি।
— লুইস মেন্ডো
সূত্র
এটি বেশ দীর্ঘ মনে হচ্ছে - আপনি কি এটি সর্বোত্তম?
— lirtosiast
@ থমাসকওয়া না, একেবারেই নয় :-)
— লুইস মেন্ডো
0

এফ #, 134 126 বাইট

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)

ব্যাখ্যা :

  1. প্রতিটি (নিম্নতর) অক্ষর aএবং bপৃথকভাবে প্রদর্শিত হওয়ার সংখ্যা গণনা করুন ।
  2. তাদের সাধারণ চরিত্র অনুসারে গণনাগুলি একসাথে ভাগ করুন

  3. -অপারেটরের সাথে প্রতিটি গ্রুপ হ্রাস করুন , যার নিম্নলিখিত প্রভাব রয়েছে:

    • যদি কেবল একটি মান খুঁজে পাওয়া যায় (যেমন অক্ষরটি কেবলমাত্র একটি ইনপুটটিতে উপস্থিত হয়), সেই মানটি ফেরত দেওয়া হয়।
    • যদি দুটি মান পাওয়া যায় (অর্থাত্ চরিত্রটি উভয় ইনপুটগুলিতে হাজির হয়) প্রথম থেকে দ্বিতীয় মানটি বিয়োগ করে।

  4. পূর্ববর্তী পদক্ষেপ থেকে মানগুলির পরম মানের যোগফল Sum

— pswg
সূত্র
0

স্কালা , 134 81 বাইট

কেবলমাত্র তাদের কাজের জন্য @ ASCII ধন্যবাদ Thanks

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

এটি অনলাইন চেষ্টা করুন!

— ভি। কুর্তোয়া
সূত্র
— এএসসিআইআই-
81
— এএসসিআইআই-কেবল
হ্যাঁ, আমি এটা মিস করেছি, আমার স্ক্যালাগল্ফে শেখার জিনিস আছে
— ভি।
হাহা, আমার সম্ভবত আরও কিছু শেখার আছে। প্রথমটি হচ্ছে স্কেলা: পি
— এএসসিআইআই
এই কৌশলগুলি দুর্দান্ত ছিল।
— ভি। কুর্তোয়া
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.