ABC problem: Difference between revisions

;Example:

True

>>> can_make_word("BARK")

=={{header|11l}}==

{{trans|Python}}

I word == ‘’

R 0B

=={{header|360 Assembly}}==

The program uses one ASSIST macro (XPRNT) to keep the code as short as possible.

ABC CSECT

USING ABC,R13 base register

=={{header|8080 Assembly}}==

jmp test

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

{{trans|8080 Assembly}}

bits 16

org 100h

=={{header|8th}}==

\ ========================================================================================

\ You are given a collection of ABC blocks

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program problemABC64.s */

</pre>

=={{header|ABAP}}==

REPORT z_rosetta_abc.

=={{header|Action!}}==

CHAR ARRAY sideA="BXDCNGRTQFJHVAOEFLPZ"

CHAR ARRAY sideB="OKQPATEGDSWUINBRSYCM"

Using #HASH-OFF

</pre>

FUNCTION bCAN_MAKE_WORD(zWord: STRING): BOOLEAN

VAR sBlockCount: SHORT

</pre>

use Ada.Characters.Handling;

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

# construct the list of blocks #

=={{header|ALGOL W}}==

begin

% Returns true if we can spell the word using the blocks, %

=={{header|Apex}}==

if (String.isEmpty(word)) {

return true;

=={{header|APL}}==

{{works with|Dyalog APL|16.0}}

{{out}}

<pre> )COPY dfns ucase

=={{header|AppleScript}}==

===Imperative===

"jw", "hu", "vi", "an", "ob", "er", "fs", "ly", "pc", "zm"}

===Functional===

use framework "Foundation"

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program problemABC.s */

=={{header|Arturo}}==

[B O] [X K] [D Q] [C P] [N A] [G T] [R E]

[T G] [Q D] [F S] [J W] [H U] [V I] [A N]

=={{header|Astro}}==

if ls.isempty:

return true

'''Function'''

o := {}

loop, parse, blocks, `n, `r

'''Test Input''' (as per question)

(

BO

=={{header|BaCon}}==

DATA "A", "BARK", "BOOK", "TREAT", "Common", "Squad", "Confuse"

=={{header|BASIC}}==

Works with:VB-DOS, QB64, QBasic, QuickBASIC

' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '

' ABC_Problem '

==={{header|Commodore BASIC}}===

{{trans|Sinclair ZX-81 BASIC}}

20 W$ = "BARK" : GOSUB 100

30 W$ = "BOOK" : GOSUB 100

The above greedy algorithm works on the sample data, but fails on other data - for example, it will declare that you cannot spell the word ABBA using the blocks (AB),(AB),(AC),(AC), because it will use the two AB blocks for the first two letters "AB", leaving none for the second "B". This recursive solution is more thorough about confirming negatives and handles that case correctly:

110 MS=100:REM MAX STACK DEPTH

120 DIM BL$(MS):REM BLOCKS LEFT

==={{header|Sinclair ZX81 BASIC}}===

Works with 1k of RAM. A nice unstructured algorithm. Unfortunately the requirement that it be case-insensitive is moot, because the ZX81 does not support lower-case letters.

20 INPUT W$

30 FOR I=1 TO LEN W$

=={{header|Batch File}}==

@echo off

::abc.bat

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PROCcan_make_word("A")

PROCcan_make_word("BARK")

=={{header|BCPL}}==

let canMakeWord(word) = valof

=={{header|BQN}}==

Matches ← ⊑⊸(⊑∘∊¨)˜ /⊣ # blocks matching current letter

Others ← <˘∘⍉∘(»⊸≥∨`)∘(≡⌜)/¨<∘⊣ # blocks without current matches

=={{header|Bracmat}}==

( can-make-word

= ABC blocks

=={{header|C}}==

Recursive solution. Empty string returns true.

#include <ctype.h>

This Method uses regular expressions to do the checking. Given that n = length of blocks string and

m = length of word string, then CheckWord's time complexity comes out to about m*(n - (m-1)/2).

using System.IO;

// Needed for the method.

</pre>

'''Unoptimized'''

using System.Linq;

{{Works with|C++11}}

Build with:

#include <vector>

#include <string>

<b>module.ceylon</b>

module rosetta.abc "1.0.0" {}

</syntaxhighlight>

<b>run.ceylon</b>

shared void run() {

printAndCanMakeWord("A", blocks);

=={{header|Clojure}}==

A translation of the Haskell solution.

(def blocks

(-> "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM" (.split " ") vec))

=={{header|CLU}}==

rslt: array[char] := array[char]$predict(1,string$size(s))

for c: char in string$chars(s) do

=={{header|CoffeeScript}}==

canMakeWord = (word="") ->

=={{header|Comal}}==

0020 blocks$:=" BOXKDQCPNAGTRETGQDFSJWHUVIANOBERFSLYPCZM"

0030 FOR i#:=1 TO LEN(word$) DO

=={{header|Common Lisp}}==

(defun word-possible-p (word blocks)

(cond

=={{header|Component Pascal}}==

{{Works with|BlackBox Component Builder}}

MODULE ABCProblem;

IMPORT

=={{header|Cowgol}}==

include "strings.coh";

{{trans|Python}}

A simple greedy algorithm is enough for the given sequence of blocks. canMakeWord is true on an empty word because you can compose it using zero blocks.

bool canMakeWord(in string word, in string[] blocks) pure /*nothrow*/ @safe {

===@nogc Version===

The same as the precedent version, but it avoids all heap allocations and it's lower-level and ASCII-only.

bool canMakeWord(in string word, in string[] blocks) nothrow @nogc

This version is able to find the solution for the word "abba" given the blocks AB AB AC AC.

{{trans|C}}

alias Block = char[2];

===Alternative Recursive Version===

This version doesn't shuffle the input blocks, but it's more complex and it allocates an array of indexes.

alias Block = char[2];

=={{header|Delphi}}==

Just to be different I implemented a block as a set of (2) char rather than as an array of (2) char.

{$APPTYPE CONSOLE}

=={{header|Draco}}==

proc nonrec ucase(char c) char:

{{trans|Swift}}

var blocks = [

"BO", "XK", "DQ", "CP", "NA", "GT", "RE", "TG", "QD", "FS",

=={{header|EchoLisp}}==

(lib 'list) ;; list-delete

=={{header|Ela}}==

{{trans|Haskell}}

:::IO

=={{header|Elena}}==

ELENA 5.0

import system'collections;

import extensions;

{{trans|Erlang}}

{{works with|Elixir|1.3}}

def can_make_word(word, avail) do

can_make_word(String.upcase(word) |> to_charlist, avail, [])

=={{header|Erlang}}==

-export([can_make_word/1, can_make_word/2, blocks/0]).

=={{header|ERRE}}==

PROGRAM BLOCKS

=={{header|Euphoria}}==

implemented using OpenEuphoria

include std/text.e

=={{header|F_Sharp|F#}}==

<p>This solution does not depend on the order of the blocks, neither on the symmetry of blocks we see in the example block set. (Symmetry: if AB is a block, an A comes only with another AB|BA)</p>

let rec look_for_right_candidate candidates noCandidates c rest =

match candidates with

=={{header|Factor}}==

kernel math math.statistics qw sequences sets unicode ;

IN: rosetta-code.abc-problem

=={{header|FBSL}}==

This approach uses a string, blanking out the pair previously found. Probably faster than array manipulation.

#APPTYPE CONSOLE

SUB MAIN()

{{works with|gforth|0.7.3}}

variable blocks

: allotblocks ( -- ) here blockslist dup allot here over - swap move blocks ! ;

=={{header|Fortran}}==

Attempts to write the word read from unit 5. Please find the output, bash command, and gfortran compilation instructions as commentary at the start of the source, which starts right away!

!Compilation started at Thu Jun 5 01:52:03

!

The following source begins with some support routines. Subroutine PLAY inspects the collection of blocks to make various remarks, and function CANBLOCK reports on whether a word can be spelled out with the supplied blocks. The source requires only a few of the F90 features. The MODULE protocol eases communication, but the key feature is that subprograms can now declare arrays of a size determined on entry via parameters. Previously, a constant with the largest-possible size would be required.

MODULE PLAYPEN !Messes with a set of alphabet blocks.

INTEGER MSG !Output unit number.

=={{header|FreeBASIC}}==

' compile with: fbc -s console

=={{header|FutureBasic}}==

include "NSLog.incl"

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=ae860292d4588b3627d77c85bcc634ee Click this link to run this code]'''

Dim sCheck As String[] = ["A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSE"]

Dim sBlock As String[] = ["BO", "XK", "DQ", "CP", "NA", "GT", "RE", "TG", "QD", "FS", "JW", "HU", "VI", "AN", "OB", "ER", "FS", "LY", "PC", "ZM"]

=={{header|Go}}==

import (

=={{header|Groovy}}==

Solution:

def blocks

Test:

"JW", "HU", "VI", "AN", "OB", "ER", "FS", "LY", "PC", "ZM"])

=={{header|Harbour}}==

Harbour Project implements a cross-platform Clipper/xBase compiler.

LOCAL cStr

The following function returns a list of all the solutions. Since Haskell is lazy, testing whether the list is null will only do the minimal amount of work necessary to determine whether a solution exists.

import Data.Char (toUpper)

Or, in terms of the bind operator:

import Data.List (delete)

Works in both languages:

blocks := ["bo","xk","dq","cp","na","gt","re","tg","qd","fs",

"jw","hu","vi","an","ob","er","fs","ly","pc","zm",&null]

=={{header|J}}==

'''Solution:'''

'rows cols'=. i.&.> $y

for_c. cols do.

abc=: *./@(+./)@reduce@(e."1~ ,)&toupper :: 0:</syntaxhighlight>

'''Examples:'''

ExampleWords=: <;._2 'A BaRK BOoK tREaT COmMOn SqUAD CoNfuSE '

'''Tacit version'''

uppc=:(-32*96&<*.123&>)&.(3&u:)

reduc=: ] delElem 1 i.~e."0 1

Another approach might be:

ExampleWords=: ;: 'A BaRK BOoK tREaT COmMOn SqUAD CoNfuSE '

Example use:

1

Blocks canform 1{::ExampleWords

For example:

1

word

{{trans|C}}

{{works with|Java|1.6+}}

import java.util.Collections;

import java.util.List;

====Imperative====

The following method uses regular expressions and the string replace function to allow more support for older browsers.

function CheckWord(blocks, word) {

====Functional====

var strBlocks =

})('A bark BooK TReAT COMMON squAD conFUSE');</syntaxhighlight>

{{Out}}

bark -> BO NA RE XK

BooK: [no solution]

===ES6===

====Imperative====

let blocks = characters.split(" ").map(pair => pair.split(""));

====Functional====

{{Trans|Haskell}}

"use strict";

=={{header|jq}}==

# when_index(cond;ary) returns the index of the first element in ary

# that satisfies cond; it uses a helper function that takes advantage

end

end;</syntaxhighlight>

["BO","XK","DQ","CP","NA","GT","RE","TG","QD","FS",

"JW","HU","VI","AN","OB","ER","FS","LY","PC","ZM"] as $blocks

=={{header|Jsish}}==

Based on Javascript ES5 imperative solution.

/* ABC problem, in Jsish. Can word be spelled with the given letter blocks. */

var blocks = "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM";

=={{header|Julia}}==

function abc(str::AbstractString, list)

=={{header|Kotlin}}==

{{trans|Java}}

fun run() {

println("\"\": " + blocks.canMakeWord(""))

=={{header|Liberty BASIC}}==

===Recursive solution===

print "Rosetta Code - ABC problem (recursive solution)"

print

</pre>

===Procedural solution===

print "Rosetta Code - ABC problem (procedural solution)"

print

=={{header|Logo}}==

[J W] [H U] [V I] [A N] [O B] [E R] [F S] [L Y] [P C] [Z M]]

=={{header|Lua}}==

{"B","O"}; {"X","K"}; {"D","Q"}; {"C","P"};

{"N","A"}; {"G","T"}; {"R","E"}; {"T","G"};

Module ABC {

can_make_word("A")

=={{header|Maple}}==

local blocks, i, j, word, letterFound;

blocks := Array([["B", "O"], ["X", "K"], ["D", "Q"], ["C", "P"], ["N", "A"], ["G", "T"], ["R", "E"], ["T", "G"],

=={{header|Mathematica}} / {{header|Wolfram Language}}==

blocks=Partition[Characters[ToLowerCase["BOXKDQCPNAGTRETGQDFSJWHUVIANOBERFSLYPCZM"]],2];

ClearAll[DoStep,ABCBlockQ]

=={{header|MATLAB}} / {{header|Octave}}==

combos = ['BO' ; 'XK' ; 'DQ' ; 'CP' ; 'NA' ; 'GT' ; 'RE' ; 'TG' ; 'QD' ; ...

'FS' ; 'JW' ; 'HU' ; 'VI' ; 'AN' ; 'OB' ; 'ER' ; 'FS' ; 'LY' ; ...

Recursively checks if the word is possible if a block is removed from the array.

-- This is the blocks array

global GlobalBlocks = #("BO","XK","DQ","CP","NA", \

'''Output:'''

iswordpossible "a"

true

=== Non-recursive ===

fn isWordPossible2 word =

(

Then:

iswordpossible "water"

true

=={{header|Mercury}}==

:- interface.

:- import_module io.

=={{header|MiniScript}}==

swap = function(list, index1, index2)

=={{header|Nim}}==

{{works with|Nim|0.20.0}}

func canMakeWord(blocks: seq[string]; word: string): bool =

=={{header|Oberon-2}}==

Works with oo2c Version 2

MODULE ABCBlocks;

IMPORT

=={{header|Objeck}}==

{{trans|Java}}

function : Main(args : String[]) ~ Nil {

blocks := ["BO", "XK", "DQ", "CP", "NA",

=={{header|OCaml}}==

('B', 'O'); ('X', 'K'); ('D', 'Q'); ('C', 'P');

('N', 'A'); ('G', 'T'); ('R', 'E'); ('T', 'G');

=={{header|Oforth}}==

["BO","XK","DQ","CP","NA","GT","RE","TG","QD","FS","JW","HU","VI","AN","OB","ER","FS","LY","PC","ZM"]

=={{header|OpenEdge/Progress}}==

/* List of blocks */

=={{header|Order}}==

#include <order/lib.h>

=={{header|PARI/GP}}==

WORDS = ["A","Bark","BOOK","Treat","COMMON","SQUAD","conFUSE"];

{{works with|Free Pascal|2.6.2}}

#!/usr/bin/instantfpc

//program ABCProblem;

=={{header|Perl}}==

Recursive solution that can handle characters appearing on different blocks:

use warnings;

use strict;

}</syntaxhighlight>

<p>Testing:

my @blocks1 = qw(BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM);

</syntaxhighlight>

===Regex based alternate===

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

=={{header|Phix}}==

Recursive solution which also solves the extra problems on the discussion page.

<span style="color: #004080;">sequence</span> <span style="color: #000000;">blocks</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">words</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">used</span>

=={{header|PHP}}==

<?php

$words = array("A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "Confuse");

=={{header|Picat}}==

Showing both a Picat style version (check_word/2) and a Prolog style recursive version (check_word2/2). go2/0 generates all possible solutions (using fail/0) to backtrack.

test_it(check_word),

test_it(check_word2),

=={{header|PicoLisp}}==

Mapping and recursion.

'((B O) (X K) (D Q) (C P) (N A) (G T) (R E)

(T G) (Q D) (F S) (J W) (H U) (V I) (A N)

=={{header|PL/I}}==

===version 1===

declare word character (20) varying, blocks character (200) varying initial

===version 2===

abc: Proc Options(main);

/* REXX --------------------------------------------------------------

=={{header|PL/M}}==

/* ABC PROBLEM ON $-TERMINATED STRING */

Works with PowerBASIC 6 Console Compiler

#DIM ALL

'

=={{header|PowerShell}}==

.Synopsis

ABC Problem

Works with SWI-Prolog 6.5.3

maplist(abc_problem, ['', 'A', bark, bOOk, treAT, 'COmmon', sQuaD, 'CONFUSE']).

{{works with|SWI Prolog 7}}

abathslib(protelog/composer) ]).

Demonstration:

true.

?- can_build_word("BARK").

=={{header|PureBasic}}==

===PureBasic: Iterative===

#LETTERS = "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM "

===PureBasic: Recursive===

Macro test(t)

===Python: Iterative, with tests===

'''

Note that this code is broken, e.g., it won't work when

===Python: Recursive===

def _abc(word, blocks):

===Python: Recursive, telling how===

if not w: return []

=={{header|q}}==

The possibility of ‘backtracking’, discussed in the FORTRAN solution above (and not tested by the example set) makes this a classic tree search: wherever there is a choice of blocks from which to pick the next letter, each choice must be tested.

WORDS:string`A`BARK`BOOK`TREAT`COMMON`SQUAD`CONFUSE

any(1_s).z.s/:b(til count b)except/:where found] }</syntaxhighlight>

{{out}}

1101011b</syntaxhighlight>

The first expression tests whether the string <code>s</code> is empty. If so, the result is true. This matches two cases: either the string is empty and can be made from any set of blocks; or all its letters have been matched and there is nothing more to check.

To meet the requirement for case-insensitivity and to display the results, apply the above within a wrapper.

cmwi:{(`$x), `false`true cmw . upper each(x;y) }</syntaxhighlight>

{{out}}

A true

bark true

This solution assumes the constraint that if a letter appears on more than one block those blocks are identical (as in the example set) so backtracking is not required.

$ "JWHUVIANOBERFSLYPCZM"

join ] constant is blocks ( --> $ )

This solution does not assume the constraint that if a letter appears on more than one block those blocks are identical (as in the example set) so backtracking is required.

witheach

[ over -1 peek

Vectorised function for R which will take a character vector and return a logical vector of equal length with TRUE and FALSE as appropriate for words which can/cannot be made with the blocks.

c("X","K"),

c("D","Q"),

===Without recursion===

Second version without recursion and giving every unique combination of blocks for each word:

x <- toupper(x)

charList <- strsplit(x, character(0))

So '(can-make-word? "")' is true for me.

(define block-strings

(list "BO" "XK" "DQ" "CP" "NA"

{{works with|rakudo|6.0.c}}

Blocks are stored as precompiled regexes. We do an initial pass on the blockset to include in the list only those regexes that match somewhere in the current word. Conveniently, regexes scan the word for us.

my @regex = @blocks.map({ my @c = .comb; rx/<@c>/ }).grep: { .ACCEPTS($word.uc) }

can-spell-word $word.uc.comb.list, @regex;

=={{header|RapidQ}}==

dim InWord as string

=={{header|Red}}==

test: func [ s][

p: copy "BOXKDQCPNAGTRETGQDFSJWHUVIANOBERFSLYPCZM"

=={{header|REXX}}==

===version 1===

list= 'A bark bOOk treat common squaD conFuse' /*words can be: upper/lower/mixed case*/

blocks= 'BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM'

===version 2===

* 10.01.2014 Walter Pachl counts the number of possible ways

* 12.01.2014 corrected date and output

=={{header|Ring}}==

Words = [ :A, :BARK, :BOOK, :TREAT, :COMMON, :SQUAD, :CONFUSE ]

=={{header|Ruby}}==

This one uses a case insensitive regular expression. The 'sub!' method substitutes the first substring it finds and returns nil if nothing is found.

words.each do |word|

=={{header|Run BASIC}}==

makeWord$ = "A,BARK,BOOK,TREAT,COMMON,SQUAD,Confuse"

b = int((len(blocks$) /3) + 1)

=={{header|Rust}}==

This implementation uses a backtracking search.

fn rec_can_make_word(index: usize, word: &str, blocks: &[&str], used: &mut[bool]) -> bool {

=={{header|Scala}}==

protected class Block(face1: Char, face2: Char) {

=={{header|Scheme}}==

In R5RS:

'((#\B #\O) (#\X #\K) (#\D #\Q) (#\C #\P) (#\N #\A)

(#\G #\T) (#\R #\E) (#\T #\G) (#\Q #\D) (#\F #\S)

=={{header|Seed7}}==

const func boolean: canMakeWords (in array string: blocks, in string: word) is func

=={{header|SenseTalk}}==

put [

end CanMakeWord</syntaxhighlight>

"A",

"BARK",

=={{header|SequenceL}}==

===Recursive Search Version===

import <Utilities/Sequence.sl>;

===RegEx Version ===

import <Utilities/Sequence.sl>;

import <RegEx/RegEx.sl>;

=={{header|Sidef}}==

{{trans|Perl}}

blocks.map! { |b| b.uc.chars.sort.join }.freq!

Tests:

var b2 = %w(US TZ AO QA)

=={{header|Simula}}==

BEGIN

=={{header|Smalltalk}}==

Recursive solution. Tested in Pharo.

ABCPuzzle>>test

#('A' 'BARK' 'BOOK' 'TreaT' 'COMMON' 'sQUAD' 'CONFuSE') do: [ :each |

=={{header|SNOBOL4}}==

{{works with|SNOBOL4, SPITBOL for Linux}}

* Program: abc.sbl,

* To run: sbl -r abc.sbl

=={{header|SPAD}}==

{{works with|FriCAS, OpenAxiom, Axiom}}

blocks:List Tuple Symbol:= _

[(B,O),(X,K),(D,Q),(C,P),(N,A),(G,T),(R,E),(T,G),(Q,D),(F,S), _

=={{header|Standard ML}}==

val BLOCKS = [(#"B",#"O"), (#"X",#"K"), (#"D",#"Q"), (#"C",#"P"), (#"N",#"A"), (#"G",#"T"),

(#"R",#"E"), (#"T",#"G"), (#"Q",#"D"), (#"F",#"S"), (#"J",#"W"), (#"H",#"U"), (#"V",#"I"),

=={{header|Swift}}==

func Blockable(str: String) -> Bool {

{{works with|Swift|3.0.2}}

func canMake(word: String) -> Bool {

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

proc abc {word {blocks {BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM}}} {

=={{header|TUSCRIPT}}==

set result = *

loop word = words

=={{header|TXR}}==

(defvar blocks '((B O) (X K) (D Q) (C P) (N A) (G T) (R E) (T G)

(Q D) (F S) (J W) (H U) (V I) (A N) (O B) (E R)

This is example is a slight modification of the C and C++ examples. To avoid warning "<bold>warning: ISO C++11 does not allow conversion from string literal to 'char *' [-Wwritable-strings]</bold> the strings added to char were individually prefixed with (char*). Swap is used instead of SWAP. Return 0 was not not needed.

#include <Core/Core.h>

#include <stdio.h>

{{works with|bash}}

if [[ $1 ]]; then

can_build_word_rec "$1" BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM

'''String-based solution'''

···

http://rosettacode.org/wiki/ABC_Problem

'''Collection-based solution'''

···

http://rosettacode.org/wiki/ABC_Problem

=={{header|VBA}}==

Option Explicit

{{trans|Go}}

{{libheader|Wren-fmt}}

var r // recursive

=={{header|XPL0}}==

char Side1, Side2;

=={{header|Yabasic}}==

sub canMake(letters$, word$)

=={{header|zkl}}==

{{trans|C}}

"JW", "HU", "VI", "AN", "OB", "ER", "FS", "LY", "PC", "ZM", );

=={{header|zonnon}}==

module Main;

type

=={{header|ZX Spectrum Basic}}==

20 READ p

30 FOR c=1 TO p