Braille Translator Challenge

This discussion has inspired me to create a generalized function capable of locating a 2D array within a 2D array and returning a 2D array from the Moore neighborhood.

Excel has plenty of functions geared towards working with 1D arrays. Lookup functions return 1D arrays and shaping functions can return 2D arrays, but will only accept 1D array inputs.

What if the grid could be left as-is and a generalized function could still pull the return?

Consider this demo:

// Signature of draft

Navigate2Dλ=
LAMBDA(
    lookup_kernel,        // 2D array (Will also accept 1D arrays)
    match_array_2D,    // 2D arrays only
    [return_direction], // Moore neighborhood - 1 to 9. 5 is center. If omitted, defaults to 8 (below)
    [return_height],   // If these two parameters are omitted, defaults to height x width of the lookup kernel
    [return_width],

It's working smoothly so far. It's locating Cities using convolution windowing.  I'll have more to share when it's finalized.

My original (unedited) no Let, no Lambda solutions:

//Part 1:

=CONCAT(XLOOKUP(BYROW(WRAPROWS(LEN(TOCOL(T5:BS7,,1)),6),CONCAT),BYROW(WRAPROWS(LEN(TOCOL((B4:Q6,B8:Q10,B12:Q14,B16:Q18),,1)),6),CONCAT),TOCOL((B3:Q3,B7:Q7,B11:Q11,B15:Q15),1)))

//Part 2:

=IF(--MID(CONCAT(XLOOKUP(MID(T16,SEQUENCE(LEN(T16)),1),TOCOL((B3:Q3,B7:Q7,B11:Q11,B15:Q15),1),BYROW(WRAPROWS(LEN(TOCOL((B4:Q6,B8:Q10,B12:Q14,B16:Q18),,1)),6),CONCAT))),WRAPCOLS(SEQUENCE(LEN(T16)*6),3),1),B4,"")

I took advantage of the fact that TOCOL can accept a non-contiguous range reference, which it processes by area. The 3x2 Braille blocks are converted to 6-digit binary codes, which are used to perform the character lookup. In part 2, the lookup is reversed, whereby each character in the phrase is replaced with its corresponding 6-digit code, then MID is used with a sequence array to extract the individual binary digits and produce the 2D array.

My attempt at generalizing it (somewhat); plus, an alternative approach for part 2:

//Part 1:

=BRA2TXT(T5:BS7, TOCOL((B3:Q3,B7:Q7,B11:Q11,B15:Q15),1), BRA2BIN((B4:Q6,B8:Q10,B12:Q14,B16:Q18)))

//Part 2:

=BRA2TXT(T16, TOCOL((B3:Q3,B7:Q7,B11:Q11,B15:Q15),1), BRA2BIN((B4:Q6,B8:Q10,B12:Q14,B16:Q18)), 1)

//Where:

BRA2BIN = LAMBDA(ref,
    BYROW(WRAPROWS(LEN(TOCOL(ref, , 1)), 6), CONCAT)
);

BRA2TXT = LAMBDA(phrase,chr_array,bin_array,[text_to_braille],
    IF(
        text_to_braille,
        IF(--MID(XLOOKUP(MID(phrase, NUM3x2(phrase, 1), 1), chr_array, bin_array), NUM3x2(phrase), 1), "●", ""),
        CONCAT(XLOOKUP(BRA2BIN(phrase), bin_array, chr_array))
    )
);

NUM3x2 = LAMBDA(txt,[opt],
    TRANSPOSE(1 + IF(opt, QUOTIENT, MOD)(SEQUENCE(LEN(txt) * 2, 3, 0), 6))
);

In part 2 of this version, the text phrase is exploded in a Kronecker product fashion, whereby every character is extracted 6 times each, which in turn lookup their corresponding 6-digit codes in a 3x2 block. MID is then lifted over the resulting array, extracting just a single binary digit from each code.

I'm using a modular approach to solve both parts. You'll find all Lambdas in the AFE module of the workbook. The one I cannot share at present is Proto2Dλ, which is a generalized 2D lookup (Lookup values can be found in 2D array). I haven't finalized the function but it will be a part of my library in the future.

/*
Part 1

=LET(
    // Re-tile 2D arrays, make phrase concise
    remap, BlockMapλ(Alphabet, 4, 2),
    ph, BYROW(BlockMapλ(Phrase, 3, 2), ARRAYTOTEXT),

    // Letters/characters from Braille alphabet
    letter, TAKE(remap, , 1),

    // Braille dots
    braille, BYROW(DROP(remap, , 2), ARRAYTOTEXT),

    // Lookup phrase, return letters, make consise
    result, CONCAT(XLOOKUP(ph, braille, letter)),
    ph
)



Part 2

=LET(
    // Expansion kernels
    kernel, {0, 0; 1, 1; 2, 2},
    kernel_b, {0, 1; 0, 1; 0, 1},

    // Phrase ~ array
    ex, Explodeλ(phrase2),

    // Mesh grid
    i, MGridλ(Alphabet),
    j, MGridλ(Alphabet, 1),

    // 2D lookup: letter ~ alphabet ~ i/j
    x, 1 + Proto2Dλ(ex, Alphabet, i),
    y, Proto2Dλ(ex, Alphabet, j),

    // Expand indices using kernels
    r, Zoomλ(x, kernel),
    c, Zoomλ(y, kernel_b),

    // Get results
    final, TEXT(INDEX(Alphabet, r, c), ";;;@"),
    final
)

*/

This was fun.  I created a few LAMBDA functions to work together:

BrailRows,WRAPROWS(TOROW(HSTACK(B4:Q6,B8:Q10,B12:Q14,B16:Q18),,1),6), 

BrailText,TAKE(WRAPROWS(HSTACK($B$3:$Q$3,$B$7:$Q$7,$B$11:$Q$11,$B$15:$Q$15),2),,1), 

Brail2Char,LAMBDA(dots,IF((ROWS(dots)<>3)+(COLUMNS(dots)<>2),"*",INDEX(BrailText,XMATCH(6,MMULT(--(TOROW(dots,,1)=BrailRows),SEQUENCE(6,,,0)))))), 

BrailLinesToText,LAMBDA(lines,IF((MOD(ROWS(lines),3)<>0)+(MOD(COLUMNS(lines),2)<>0),"*",CONCAT(MAKEARRAY(ROWS(lines)/3,COLUMNS(lines)/2,LAMBDA(r,c,Brail2Char(TAKE(DROP(lines,3*(r-1),2*(c-1)),3,2))))))), 

Char2Brail,LAMBDA(c,IFERROR(LET(a,WRAPCOLS(CHOOSEROWS(BrailRows,XMATCH(c,BrailText)),3),IF(a=0,"",a)),"*")), 

Line2Brail,LAMBDA(l,DROP(REDUCE("",MID(l,SEQUENCE(LEN(l)),1),LAMBDA(p,q,HSTACK(p,Char2Brail(q)))),,1)),

I apologize I didn't clean this up by my Excel Labs plug-in isn't working right now...

Basically

BrailRows is just a reference for the brail answer key formatted as rows

BrailText is the corresponding character for each row (i.e. make it easy to add more characters)

Brail2Char will take a single grid of dots and convert it to the corresponding character

BrailLinesToText will take a whole line or even multiple lines of Brail and convert it to a single string output

Char2Brail will output the Brail grid of dots give a character

Line2Brail will take a string of characters and output the line of Brail dots

here is an image of the results:

and on the right side in cell BU is using the input from the gray area just to show it can take multi-line input

I see a couple other answers have been submitted that look interesting, I will have to check them out too.

Hi djclements​,

(I have not used the LAMBDA function in my formula)

I applied the first formula to cell AF10.

=LET(
     data, B3:Q18,
   phrase, T5:BS7,
           CONCAT(XLOOKUP(BYCOL(WRAPCOLS(BYCOL(phrase, ARRAYTOTEXT), 2), ARRAYTOTEXT),
           HSTACK(BYCOL(WRAPCOLS(BYCOL(CHOOSEROWS(data, {2,3,4}), ARRAYTOTEXT), 2), ARRAYTOTEXT),
                  BYCOL(WRAPCOLS(BYCOL(CHOOSEROWS(data, {6,7,8}), ARRAYTOTEXT), 2), ARRAYTOTEXT),
                  BYCOL(WRAPCOLS(BYCOL(CHOOSEROWS(data, {10,11,12}), ARRAYTOTEXT), 2), ARRAYTOTEXT),
                  BYCOL(WRAPCOLS(BYCOL(CHOOSEROWS(data, {14,15,16}), ARRAYTOTEXT), 2), ARRAYTOTEXT)),
           HSTACK(
                  TOROW(CHOOSEROWS(data, 1), 1),
                  TOROW(CHOOSEROWS(data, 5), 1),
                  TOROW(CHOOSEROWS(data, 9), 1),
                  TOROW(CHOOSEROWS(data, 13), 1)
))))

The second formula is the same as the first formula, but instead of T5:BS7, T19:BS21 should be inserted in the formula.

Try it and let me know.

IlirU

Part1: 

=LET(b,HSTACK(B4:Q6,B8:Q10,B12:Q14,B16:Q18),a,IF(b="",0,b),c,HSTACK(CHAR(SEQUENCE(,26,97)),TOROW(F15:Q15,1)),l,LAMBDA(i,DROP(REDUCE(0,SEQUENCE(COLUMNS(i)/2,,,2),LAMBDA(x,y,HSTACK(x,CONCAT(CHOOSECOLS(i,y,y+1))))),,1)),CONCAT(XLOOKUP(l(IF(T5:BS7="",0,T5:BS7)),l(a),c)))

Part2: 

=LET(b,HSTACK(B4:Q6,B8:Q10,B12:Q14,B16:Q18),a,IF(b="",0,b),c,HSTACK(CHAR(SEQUENCE(,26,97)),TOROW(F15:Q15,1)),l,LAMBDA(i,DROP(REDUCE(0,SEQUENCE(COLUMNS(i)/2,,,2),LAMBDA(x,y,HSTACK(x,CONCAT(CHOOSECOLS(i,y,y+1))))),,1)),d,REGEXEXTRACT(T16,".",1),e,XLOOKUP(d,c,l(a)),r,DROP(REDUCE(0,e,LAMBDA(x,y,HSTACK(x,WRAPROWS(REGEXEXTRACT(y,".",1),2)))),,1),SUBSTITUTE(r,0,))