ABC problem: Difference between revisions

 

;Example:

True

>>> can_make_word("BARK")

True

>>> can_make_word("CONFUSE")

 

{{Template:Strings}}

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

{{trans|Python}}

I word == ‘’

R 0B

R 1B

 

 

=={{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

YREGS

NN EQU (BLOCKS-WORDS)/L'WORDS number of words

{{out}}

<pre>

 

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

jmp test

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

wrdcommon: db 'COMMON$'

wrdsquad: db 'SQUAD$'

 

{{out}}

{{trans|8080 Assembly}}

 

bits 16

org 100h

.cmn: db 'COMMON$'

.squad: db 'SQUAD$'

 

{{out}}

 

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

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

\ You are given a collection of ABC blocks

bye

;

 

=={{header|ABAP}}==

REPORT z_rosetta_abc.

 

WRITE:/ COND string( WHEN word_maker=>can_make_word( word = 'SQUAD' letter_blocks = blocks ) = abap_true THEN 'True' ELSE 'False' ).

WRITE:/ COND string( WHEN word_maker=>can_make_word( word = 'CONFUSE' letter_blocks = blocks ) = abap_true THEN 'True' ELSE 'False' ).

{{out}}

<pre>

True

True

</pre>

 

Using #HASH-OFF

</pre>

FUNCTION bCAN_MAKE_WORD(zWord: STRING): BOOLEAN

VAR sBlockCount: SHORT

RETURN OCCURS(zUsedBlocks, ",") = sWordLength

ENDFUNCTION

{{out}}

<pre>

</pre>

 

use Ada.Characters.Handling;

 

end loop;

end Abc_Problem;

 

{{out}}

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

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

 

# construct the list of blocks #

 

)

Output:

<pre>

 

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

begin

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

testCanSpell( "confuse", 7 )

end

{{out}}

<pre>

 

=={{header|Apex}}==

if (String.isEmpty(word)) {

return true;

System.debug('"COMMON": ' + canMakeWord(blocks, 'COMMON'));

System.debug('"SQuAd": ' + canMakeWord(blocks, 'SQuAd'));

{{out}}

<pre>"": 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"}

 

end repeat

return false

 

===Functional===

use framework "Foundation"

 

set my text item delimiters to dlm

s

{{Out}}

<pre> '' -> true

'SQUAD' -> true

'conFUsE' -> true</pre>

 

=={{header|Astro}}==

if ls.isempty:

return true

 

for s in test:

 

=={{header|AutoHotkey}}==

 

'''Function'''

o := {}

loop, parse, blocks, `n, `r

added := 1

}

 

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

(

BO

loop, parse, wordlist, `n

out .= A_LoopField " - " isWordPossible(blocks, A_LoopField) "`n"

 

{{out}}

 

=={{header|BaCon}}==

 

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

 

PRINT word$, IIF$(LEN(word$) = count-AMOUNT(block$), "True", "False") FORMAT "%-10s: %s\n"

{{out}}

<pre>

=={{header|BASIC}}==

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

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

' ABC_Problem '

 

END FUNCTION

 

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

20 W$ = "BARK" : GOSUB 100

30 W$ = "BOOK" : GOSUB 100

100 B$="BOXKDQCPNAGTRETGQDFSJWHUVIANOBERFSLYPCZM"

110 FOR I=1 TO LEN(W$)

210 NEXT I

220 PRINT W$" -> YES"

230 RETURN

240 PRINT W$" -> NO"

{{out}}

<pre>A -> YES

SQUAD -> YES

CONFUSE -> YES</pre>

 

==={{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$

90 STOP

100 NEXT J

{{in}}

<pre>A</pre>

{{out}}

<pre>YES</pre>

 

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

@echo off

::abc.bat

 

:END

 

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

{{works with|BBC BASIC for Windows}}

PROCcan_make_word("A")

PROCcan_make_word("BARK")

ENDWHILE

IF word$>"" PRINT "False" ELSE PRINT "True"

 

{{out}}

Confuse -> True

</pre>

 

=={{header|Bracmat}}==

( can-make-word

= ABC blocks

& can-make-word'SQUAD

& can-make-word'CONFUSE

{{out}}

<pre>A yes

=={{header|C}}==

Recursive solution. Empty string returns true.

#include <ctype.h>

 

 

return 0;

{{out}}

<pre>

</pre>

 

===Regex===

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.

return true;

}

{{out}}

<pre>

</pre>

'''Unoptimized'''

using System.Linq;

 

}

}

{{out}}

<pre>

{{Works with|C++11}}

Build with:

#include <vector>

#include <string>

std::cout << w << ": " << std::boolalpha << can_make_word(w,vals) << ".\n";

}

 

{{out}}

<b>module.ceylon</b>

 

module rosetta.abc "1.0.0" {}

 

<b>run.ceylon</b>

 

shared void run() {

printAndCanMakeWord("A", blocks);

myRemainingLetterIndexes)

else false;

 

{{out}}

=={{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))

(doseq [word ["A" "BARK" "Book" "treat" "COMMON" "SQUAD" "CONFUSE"]]

 

{{out}}

SQUAD: true

CONFUSE: true</pre>

 

=={{header|CoffeeScript}}==

 

canMakeWord = (word="") ->

# Expect true, true, false, true, false, true, true, true

for word in ["A", "BARK", "BOOK", "TREAT", "COMMON", "squad", "CONFUSE", "STORM"]

 

{{out}}

CONFUSE -> true

STORM -> true</pre>

 

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

(defun word-possible-p (word blocks)

(cond

collect (word-possible-p

(subseq word 1)

 

{{out}}

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

{{Works with|BlackBox Component Builder}}

MODULE ABCProblem;

IMPORT

END ABCProblem.

Execute: ^Q ABCProblem.CanMakeWord A BARK BOOK TREAT COMMON SQUAD confuse~

{{out}}

confuse:> $TRUE

</pre>

 

=={{header|D}}==

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

foreach (word; "" ~ "A BARK BoOK TrEAT COmMoN SQUAD conFUsE".split)

writefln(`"%s" %s`, word, canMakeWord(word, blocks));

{{out}}

<pre>"" true

===@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

foreach (word; "" ~ "A BARK BoOK TrEAT COmMoN SQUAD conFUsE".split)

writefln(`"%s" %s`, word, canMakeWord(word, blocks));

 

===Recursive Version===

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];

immutable word = "abba";

writefln(`"%s" %s`, word, blocks2.canMakeWord(word));

{{out}}

<pre>"" true

===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];

immutable word = "abba";

writefln(`"%s" %s`, word, blocks2.canMakeWord(word));

The output is the same.

 

=={{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}

 

readln;

end.

 

{{out}}

Can make CONFUSE

</pre>

 

=={{header|Dyalect}}==

{{trans|Swift}}

 

var blocks = [

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

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

for c in strUp {

blocks[j] = ""

break

}

}

for str in [ "A", "BARK", "BooK", "TrEaT", "comMON", "sQuAd", "Confuse" ] {

print("\"\(str)\" \(canOrNot(blockable(str))) be spelled with blocks.")

 

{{out}}

"sQuAd" can be spelled with blocks.

"Confuse" can be spelled with blocks.</pre>

 

=={{header|EchoLisp}}==

(lib 'list) ;; list-delete

 

(spell (string-rest word) (list-delete blocks block))))))

{{out}}

<pre>

=={{header|Ela}}==

{{trans|Haskell}}

 

:::IO

 

mapM_ (\w -> putLn (w, not << null $ abc blocks (map char.upper w)))

 

{{out}}

 

=={{header|Elena}}==

import system'collections;

import extensions;

import extensions'routines;

var list := ArrayList.load(blocks);

{

var index := list.indexOfElement

e.next();

{

console.printLine("can make '",word,"' : ",word.canMakeWordFrom(blocks));

}

{{out}}

<pre>

{{trans|Erlang}}

{{works with|Elixir|1.3}}

def can_make_word(word, avail) do

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

blocks = ~w(BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM)c

~w(A Bark Book Treat Common Squad Confuse) |>

 

{{out}}

Squad: true

Confuse: true

</pre>

 

=={{header|Erlang}}==

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

 

main(_) -> lists:map(fun(W) -> io:fwrite("~s: ~s~n", [W, can_make_word(W)]) end,

["A","Bark","Book","Treat","Common","Squad","Confuse"]).

 

{{Out}}

 

=={{header|ERRE}}==

PROGRAM BLOCKS

 

CANMAKEWORD("Confuse")

END PROGRAM

 

=={{header|Euphoria}}==

implemented using OpenEuphoria

include std/text.e

 

 

if getc(0) then end if

{{out}}

<pre>

=={{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

 

List.iter (fun w -> printfn "Using the blocks we can make the word '%s': %b" w (spell_word_with blocks w)) words

{{out}}

<pre>h:\RosettaCode\ABC\Fsharp>RosettaCode "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM" a bark book threat common squad confuse

h:\RosettaCode\ABC\Fsharp>RosettaCode "US TZ AO QA" Auto

Using the blocks we can make the word 'AUTO': true</pre>

 

=={{header|Factor}}==

kernel math math.statistics qw sequences sets unicode ;

IN: rosetta-code.abc-problem

show-blocks header input [ result ] each ;

 

{{out}}

<pre>

=={{header|FBSL}}==

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

#APPTYPE CONSOLE

SUB MAIN()

RETURN TRUE

END FUNCTION

{{out}}

<pre>

Press any key to continue...

</pre>

 

=={{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

!

end subroutine ucase

 

 

===But if backtracking might be needed===

 

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.

END DO

END

Output: the first column of T/F is the report from CANBLOCK, the second is the expected answer from the example, and the third is whether the two are in agreement.

<pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>A true

SQUAD true

CONFUSE true</pre>

 

=={{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"]

Next

 

Output:

<pre>

 

=={{header|Go}}==

 

import (

fmt.Println(word, sp(word))

}

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

def blocks

 

word.every { letter -> blocksLeft.remove(blocksLeft.find { block -> block.contains(letter) }) }

}

 

Test:

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

 

['', 'A', 'BARK', 'book', 'treat', 'COMMON', 'SQuAd', 'CONFUSE'].each {

println "'${it}': ${a.canMakeWord(it)}"

 

{{out}}

=={{header|Harbour}}==

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

 

LOCAL cStr

NEXT

 

{{out}}

<pre>

 

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)

 

main :: IO ()

main = mapM_ (\w -> print (w, not . null $ abc blocks (map toUpper w)))

 

{{out}}

Or, in terms of the bind operator:

 

 

spellWith :: [String] -> String -> [[String]]

spellWith _ [] = [[]]

where

go b

| otherwise = []

 

 

main :: IO ()

main =

mapM_

{{Out}}

<pre>("",True)

 

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]

}

}

 

Sample run:

"CONFUSE" can be spelled with blocks.

->

</pre>

 

=={{header|J}}==

'''Solution:'''

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

for_c. cols do.

)

 

'''Examples:'''

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

 

"COmMOn" F

"SqUAD" T

 

'''Tacit version'''

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

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

 

{{out}}

Another approach might be:

 

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

 

need=: #/.~ word,word

relevant=: (x +./@e."1 word) # x

+./(((#need){. #/.~)"1 candidates) */ .>:need

 

Example use:

 

1

Blocks canform 1{::ExampleWords

1

Blocks canform 6{::ExampleWords

 

Explanation:

For example:

 

1

word

ANN

AAA

 

 

=={{header|Java}}==

{{trans|C}}

{{works with|Java|1.6+}}

import java.util.Collections;

import java.util.List;

return false;

}

{{out}}

<pre>"": true

====Imperative====

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

 

function CheckWord(blocks, word) {

for(var i = 0;i<words.length;++i)

console.log(words[i] + ": " + CheckWord(blocks, words[i]));

 

Result:

 

====Functional====

 

var strBlocks =

return strWords.split(' ').map(solution).join('\n');

 

{{Out}}

bark -> BO NA RE XK

BooK: [no solution]

COMMON: [no solution]

squAD -> FS DQ HU NA QD

 

===ES6===

====Imperative====

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

"CONFUSE"

].forEach(word => console.log(`${word}: ${isWordPossible(word)}`));

 

Result:

====Functional====

{{Trans|Haskell}}

 

 

// spellWith :: [(Char, Char)] -> [Char] -> [[(Char, Char)]]

[]

spellWith(

deleteBy(

);

})();

 

 

 

 

 

// deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]

 

 

{{Out}}

<pre>["",true]

 

=={{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

else .[1:] | abc($blks)

end

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

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

| ("A", "BARK","BOOK","TREAT","COMMON","SQUAD","CONFUSE")

{{Out}}

A : true

=={{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";

can spell CONFUSE

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

 

function abc(str::AbstractString, list)

@printf("%-8s | %s\n", str, abc(str, list))

end

 

{{out}}

CONFUSE | true</pre>

 

=={{header|Kotlin}}==

{{trans|Java}}

fun run() {

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

}

 

return true

 

var i = 0

forEach { b ->

return false

}

}

 

{{out}}

<pre>"": true

SQuAd: true

CONFUSE: true</pre>

 

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

===Recursive solution===

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

print

wend

end function

{{out}}

<pre>

</pre>

===Procedural solution===

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

print

LetterOK=1

end sub

{{out}}

<pre>

 

=={{header|Logo}}==

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

 

]

 

 

{{Out}}

SQUAD: true

CONFUSE: true</pre>

 

=={{header|Lua}}==

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

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

end

print(found)

 

{{Output}}

 

 

Module ABC {

can_make_word("A")

}

ABC

 

{{out}}

CONFUSE True

</pre >

 

=={{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"],

end proc:

 

{{out}}

<pre>

 

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

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

ClearAll[DoStep,ABCBlockQ]

DoStep[opts_List]:=Flatten[DoStep@@@opts,1]

ABCBlockQ[str_String]:=(FixedPoint[DoStep,{{Characters[ToLowerCase[str]],blocks,{}}}]=!={})

{{Out}}

<pre>

</pre>

 

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

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

k = k+1;

end

{{out}}

<pre>Can make word A.

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

iswordpossible "confuse"

true

 

 

=== Non-recursive ===

fn isWordPossible2 word =

(

) else return false

)

 

Both versions are good for this example, but the non-recursive version won't work if the blocks are more random, because it just takes the first found block, and the recursive version decides which one to use.

Then:

 

iswordpossible "water"

true

iswordpossible2 "water"

false

 

Non-recursive version quickly decides that it's not possible, even though it clearly is.

 

=={{header|Mercury}}==

:- interface.

:- import_module io.

io.format("can_make_word(""%s"") :- %s.\n",

[s(W), s(if P then "true" else "fail")], !IO)),

 

Note that 'P', in the foldl near the end, is not a boolean variable, but a zero-arity currying of can_make_word (i.e., it's a 'lambda' that takes no arguments and then calls can_make_word with all of the already-supplied arguments).

 

=={{header|MiniScript}}==

swap = function(list, index1, index2)

print out + ": " + canMakeWord(val, allBlocks)

end for

 

=={{header|Nim}}==

 

 

 

 

{{Out}}

 

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

Works with oo2c Version 2

MODULE ABCBlocks;

IMPORT

Out.String("confuse: ");Out.Bool(CanMakeWord("confuse"));Out.Ln;

END ABCBlocks.

Output:

<pre>

=={{header|Objeck}}==

{{trans|Java}}

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

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

arr[j] := tmp;

}

<pre>

"": true

 

=={{header|OCaml}}==

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

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

"SQUAD", true;

"CONFUSE", true;

 

{{Out}}

=={{header|Oforth}}==

 

 

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

]

false

 

{{out}}

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

 

 

/* List of blocks */

RETURN TRUE.

END FUNCTION.

 

{{out}}

SQUAD = yes

CONFUSE = yes

</pre>

 

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

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

 

}

 

 

Output:<pre>A 1

{{works with|Free Pascal|2.6.2}}

 

#!/usr/bin/instantfpc

//program ABCProblem;

TestABCProblem('SQUAD');

TestABCProblem('CONFUSE');

 

{{out}}

=={{header|Perl}}==

Recursive solution that can handle characters appearing on different blocks:

use warnings;

use strict;

}

return

<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);

my @blocks2 = qw(US TZ AO QA);

is(can_make_word('auto', @blocks2), 1);

 

=={{header|Phix}}==

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

{{out}}

<pre>

=={{header|PHP}}==

 

<?php

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

echo canMakeWord($word) ? "True" : "False";

echo "\r\n";

{{out}}

<pre>

Confuse: True

</pre>

 

=={{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)

(println Word (abc Word *Blocks) (abcR Word *Blocks)) )

 

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

===version 1===

 

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

end;

 

<pre>

A true

 

===version 2===

abc: Proc Options(main);

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

End;

 

{{out}}

<pre>'$' cannot be spelt.

'SQUAD' can be spelt in 8 ways.

'CONFUSE' can be spelt in 32 ways.</pre>

 

=={{header|PowerBASIC}}==

Works with PowerBASIC 6 Console Compiler

 

#DIM ALL

'

END IF

END FUNCTION

{{out}}

<pre>$ FALSE

 

=={{header|PowerShell}}==

.Synopsis

ABC Problem

{

test-blocks -testword $word -Verbose

{{out}}

<pre>

Works with SWI-Prolog 6.5.3

 

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

 

( select([H, _], L, L1); select([_, H], L, L1)),

can_makeword(L1, T).

{{out}}

<pre> ?- abc_problem.

{{works with|SWI Prolog 7}}

 

abathslib(protelog/composer) ]).

 

%% These rules, removing remaining constraints from the store, are just cosmetic:

'clean up blocks' @ word_built \ block(_) <=> true.

 

 

Demonstration:

 

true.

?- can_build_word("BARK").

true.

?- can_build_word("CONFUSE").

 

=={{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 "

 

PrintN(can_make_word("SqUAD"))

PrintN(can_make_word("COnFUSE"))

 

===PureBasic: Recursive===

 

Macro test(t)

test("a") : test("BaRK") : test("BOoK") : test("TREAt")

test("cOMMON") : test("SqUAD") : test("COnFUSE")

{{out}}

<pre>a = True

 

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

'''

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

["", "a", "baRk", "booK", "treat",

"COMMON", "squad", "Confused"]))

 

{{out}}

 

===Python: Recursive===

 

def _abc(word, blocks):

if __name__ == '__main__':

for word in [''] + 'A BARK BoOK TrEAT COmMoN SQUAD conFUsE'.split():

 

{{out}}

 

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

if not w: return []

 

 

for w in ", A, bark, book, treat, common, SQUAD, conFUsEd".split(', '):

 

{{out}}

'conFUsEd' -> ['CP', 'BO', 'NA', 'FS', 'HU', 'FS', 'RE', 'DQ']

</pre>

 

=={{header|R}}==

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

"COMMON",

"SQUAD",

 

{{out}}

===Without recursion===

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

x <- toupper(x)

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

"COMMON",

"SQUAD",

{{out}}

<pre>$A

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

 

(define block-strings

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

(check-false (can-make-word? "COMMON"))

(check-true (can-make-word? "SQUAD"))

 

{{out}}

{{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;

for <A BaRK BOoK tREaT COmMOn SqUAD CoNfuSE> {

say "$_ &can-spell-word($_, @b)";

{{out}}

<pre>A True

 

=={{header|RapidQ}}==

dim InWord as string

 

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

showmessage "Can make: " + InWord + " = " + iif(CanMakeWord(InWord, Blocks), "True", "False")

{{out}}

<pre>Can make: A = TRUE

 

=={{header|Red}}==

test: func [ s][

p: copy "BOXKDQCPNAGTRETGQDFSJWHUVIANOBERFSLYPCZM"

print reduce [ pad copy word 8 ":" test word]

]

{{out}}

<pre>

conFUsE : true

</pre>

 

=={{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'

end /*try*/ /* [↑] end of a "TRY" permute. */

say right( arg(1), 30) right( word( "can't can", (n==L) + 1), 6) 'be spelt.'

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

===version 2===

* 10.01.2014 Walter Pachl counts the number of possible ways

* 12.01.2014 corrected date and output

used.w=1

End

{{out}}

<pre>'' cannot be spelt.

 

=={{header|Ring}}==

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

 

if found = false return false ok

next

{{Out}}

<pre>

>>> can_make_word("CONFUSE")

True

</pre>

 

=={{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|

puts "#{word.inspect}: #{res}"

end

{{Out}}

<pre>

 

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

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