Wordle comparison: Difference between revisions

=={{header|C}}==

{{trans|Wren}}

#include <stdlib.h>

#include <string.h>

}

return 0;

 

{{out}}

 

=={{header|FreeBASIC}}==

Dim As Integer n, i, k

Dim As String resultado

End If

Next i

{{out}}

<pre>ALLOW v LOLLY => [1, 1, 2, 0, 0] => yellow yellow green grey grey

=={{header|Go}}==

{{trans|Wren}}

 

import (

fmt.Printf("%s v %s => %v => %v\n", pair[0], pair[1], res, res2)

}

 

{{out}}

 

=={{header|Haskell}}==

import Data.List (intercalate, mapAccumL)

import qualified Data.Map.Strict as M

color 2 = "green"

color 1 = "amber"

{{Out}}

<pre>Target -> Guess -> Scores

Implementation (brute force):

 

yw=.gr=. I.x=y

key=. '#' gr} x

end.

2 gr} 1 yw} (#y)#0

 

A bit more efficient (about 3 times faster on task example, which might matter if a few microseconds was important):

 

yw=. ;(] , ({.~1<.#)@-.)&.>/(<@I.y=/~x#~y~:x),<I.x=y

2 (I.x=y)} 1 yw} (#y)#0

assert 2 2 2 2 2-: 'robin' wrdcmp 'robin'

assert 0 0 2 1 0-: 'mamma' wrdcmp 'nomad'

 

Explanation:

Task example:

 

 

=={{header|JavaScript}}==

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>ALLOW -> LOLLY -> [1,1,2,0,0] -> amber amber green gray gray

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

def wordle($answer; $guess):

| wordle(.[0]; .[1]) as $res

| ($res | map(colors[.])) as $res2

{{out}}

As for [[#Wren]].

=={{header|Julia}}==

{{trans|Wren}}

function wordle(answer, guess)

res2 = [colors[i + 1] for i in res]

println("$pair0 v $pair1 => $res => $res2")

<pre>

ALLOW v LOLLY => [1, 1, 2, 0, 0] => ["yellow", "yellow", "green", "grey", "grey"]

 

=={{header|Perl}}==

 

use strict; # https://rosettacode.org/wiki/Wordle_comparison

print "@$test => @{[ qw( green yellow grey )

[map ord, split //, s/.*\n//r =~ tr/\0\1/\2/cr] ]}\n";

{{out}}

<pre>

<small>Aside: You may be mildly surprised to see the 2nd for loop limit being clobbered like this, but you ''cannot'' change the limit mid-loop in Phix (an explicit exit would be far clearer) and hence you ''can'' do this.<br>

In practice the for loop takes a private copy of the value of the limit, be that n or more significantly say length(s), and ignores any changes you might subsequently make to it.</small>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">wordle</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">answer</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">guess</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s v %s =&gt; %v =&gt; %v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">answer</span><span style="color: #0000FF;">,</span><span style="color: #000000;">guess</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rac</span><span style="color: #0000FF;">})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

 

{{trans|Go}}

Pairs = [["ALLOW", "LOLLY"],

["BULLY", "LOLLY"],

Presentation[I] := [to_lowercase(Guess[I])] ++ "*"

end

 

{{out}}

 

=={{header|Python}}==

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Target -> Guess -> Scores

=={{header|Quackery}}==

 

[ over i^ peek = while

2 rot i^ poke

$ "ROBIN" $ "SONIC" wordle-compare echo cr

$ "ROBIN" $ "ROBIN" wordle-compare echo cr

 

{{out}}

=={{header|Raku}}==

Updated to add a proof of concept matching for similarity where commonly found on spoofing domain names. Of course this is just the tip of the iceberg (only comparing results after decomposition) and there are way too many [https://util.unicode.org/UnicodeJsps/confusables.jsp Unicode homoglyphs] that can only be matched using a [http://www.unicode.org/Public/security/8.0.0/confusables.txt lookup table/database].

 

sub wordle (\answer,\guess where [==] (answer,guess)».chars ) {

say .[0]~' vs '~.[1]~"\t"~ wordle .[0],.[1] for (

<ALLOW LOLLY>, <ROBIN ALERT>, <ROBIN SONIC>, <ROBIN ROBIN>, <BULLY LOLLY>,

{{out}}

<pre>

 

=={{header|Swift}}==

case grey

case yellow

print("\(pair.0) v \(pair.1) => \(result)")

}

 

{{out}}

 

=={{header|Tailspin}}==

templates wordle

sink removeFirst

 

['ALLOW', 'LOLLY'] -> wordle -> !OUT::write

 

{{out}}

=={{header|Vlang}}==

{{trans|Go}}

n := guess.len

if n != answer.len {

println("${pair[0]} v ${pair[1]} => $res => $res2\n")

}

 

{{out}}

 

=={{header|Wren}}==

 

var wordle = Fn.new { |answer, guess|

var res2 = res.map { |i| colors[i] }.toList

System.print("%(pair[0]) v %(pair[1]) => %(res) => %(res2)")

 

{{out}}

 

=={{header|XPL0}}==

 

proc ShowColors(Result);

ShowColors(Wordle("ROBIN", "SONIC"));

ShowColors(Wordle("ROBIN", "ROBIN"));

 

{{out}}

=={{header|Yabasic}}==

{{trans|Phix}}

// by Galileo, 02/2022

 

print

next

{{out}}

<pre>ALLOW v LOLLY => yellow yellow green grey grey