Abbreviations, easy: Difference between revisions
Added FreeBASIC
(add task to aarch64 assembly raspberry pi) |
(Added FreeBASIC) |
||
(30 intermediate revisions by 20 users not shown) | |||
Line 84:
{{Template:Strings}}
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">V command_table_text =
|‘Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up’
V user_words = ‘riG rePEAT copies put mo rest types fup. 6 poweRin’
F find_abbreviations_length(command_table_text)
‘ find the minimal abbreviation length for each word by counting capital letters.
a word that does not have capital letters gets it's full length as the minimum.
’
[String = Int] command_table
L(word) command_table_text.split((‘ ’, "\n"), group_delimiters' 1B)
V abbr_len = sum(word.filter(c -> c.is_uppercase()).map(c -> 1))
I abbr_len == 0
abbr_len = word.len
command_table[word] = abbr_len
R command_table
F find_abbreviations(command_table)
‘ for each command insert all possible abbreviations’
[String = String] abbreviations
L(command, min_abbr_len) command_table
L(l) min_abbr_len .. command.len
V abbr = command[0 .< l].lowercase()
abbreviations[abbr] = command.uppercase()
R abbreviations
F parse_user_string(user_string, abbreviations)
V user_words = user_string.split(‘ ’, group_delimiters' 1B).map(word -> word.lowercase())
V commands = user_words.map(user_word -> @abbreviations.get(user_word, ‘*error*’))
R commands.join(‘ ’)
V command_table = find_abbreviations_length(command_table_text)
V abbreviations_table = find_abbreviations(command_table)
V full_words = parse_user_string(user_words, abbreviations_table)
print(‘user words: ’user_words)
print(‘full words: ’full_words)</syntaxhighlight>
{{out}}
<pre>
user words: riG rePEAT copies put mo rest types fup. 6 poweRin
full words: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</pre>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program abbrEasy64.s */
Line 508 ⟶ 562:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
<pre>
Enter command (or quit to stop) : riG
Line 534 ⟶ 588:
pi@debian-buster-64:~/asm64/rosetta/asm9 $
</pre>
=={{header|Ada}}==
<syntaxhighlight lang="ada">with Ada.Characters.Handling;
with Ada.Containers.Indefinite_Vectors;
with Ada.Strings.Fixed;
with Ada.Strings.Maps.Constants;
with Ada.Text_IO;
procedure Abbreviations_Easy is
package Command_Vectors
is new Ada.Containers.Indefinite_Vectors (Index_Type => Positive,
Element_Type => String);
use Command_Vectors;
Commands : Vector;
procedure Append (Word_List : String) is
use Ada.Strings;
First : Positive := Word_List'First;
Last : Natural;
begin
loop
Fixed.Find_Token (Word_List,
Set => Maps.Constants.Letter_Set,
From => First,
Test => Inside,
First => First,
Last => Last);
exit when Last = 0;
Commands.Append (Word_List (First .. Last));
exit when Last = Word_List'Last;
First := Last + 1;
end loop;
end Append;
function Match (Word : String) return String is
use Ada.Strings;
use Ada.Characters.Handling;
Upper_Word : constant String := To_Upper (Word);
Prefix_First : Positive;
Prefix_Last : Natural;
begin
if Word = "" then
return "";
end if;
for Command of Commands loop
Fixed.Find_Token (Command, Maps.Constants.Upper_Set, Inside,
Prefix_First, Prefix_Last);
declare
Upper_Prefix : constant String := Command (Prefix_First .. Prefix_Last);
Upper_Command : constant String := To_Upper (Command);
Valid_Length : constant Boolean := Word'Length >= Upper_Prefix'Length;
Match_Length : constant Natural := Natural'Min (Word'Length,
Command'Length);
Valid_Match : constant Boolean
:= Fixed.Head (Upper_Word, Upper_Word'Length)
= Fixed.Head (Upper_Command, Upper_Word'Length);
begin
if Valid_Length and Valid_Match then
return Upper_Command;
end if;
end;
end loop;
return "*error*";
end Match;
procedure Put_Match (To : String) is
use Ada.Text_IO;
M : constant String := Match (To);
begin
Put ("Match to '"); Put (To);
Put ("' is '"); Put (M);
Put_Line ("'");
end Put_Match;
procedure A (Item : String) renames Append;
begin
A ("Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy");
A ("COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find");
A ("NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput");
A ("Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO");
A ("MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT");
A ("READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT");
A ("RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up");
Put_Match ("riG");
Put_Match ("rePEAT");
Put_Match ("copies");
Put_Match ("put");
Put_Match ("mo");
Put_Match ("rest");
Put_Match ("types");
Put_Match ("fup.");
Put_Match ("6");
Put_Match ("poweRin");
Put_Match ("");
Put_Match ("o");
end Abbreviations_Easy;</syntaxhighlight>
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
Uses Algol 68G specific is lower and to upper procedures. Does not use a hash table.
<
# table of "commands" - upper-case indicates the mminimum abbreviation #
STRING command table = "Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy "
Line 621 ⟶ 776:
# task test cases #
test expand( "riG rePEAT copies put mo rest types fup. 6 poweRin", command table );
test expand( "", command table )</
{{out}}
<pre>
Line 636 ⟶ 791:
Also note that the program should return the uppercase string (as per the requirements): <br><br>
RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT<br><br>
Also note that an ''error'' is noted by: *error*
Furthermore, a possible test case for the keyword (not abbreviated) <big> quit </big> can't be processed by this program.}}
<pre> Correction program 15/11/2020 </pre>
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program abbrEasy.s */
Line 1,027 ⟶ 1,186:
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
<pre>
Line 1,055 ⟶ 1,214:
=={{header|AutoHotkey}}==
<
str =
(
Line 1,099 ⟶ 1,258:
}
MsgBox % Trim(result)
</syntaxhighlight>
{{out}}
<pre>
Line 1,107 ⟶ 1,266:
=={{header|AWK}}==
<
BEGIN {
FS=" ";
Line 1,146 ⟶ 1,305:
</syntaxhighlight>
{{out}}
Line 1,155 ⟶ 1,314:
=={{header|C}}==
<
#include <stdbool.h>
#include <stdio.h>
Line 1,301 ⟶ 1,460:
free_command_list(commands);
return 0;
}</
{{out}}
Line 1,310 ⟶ 1,469:
=={{header|C++}}==
<
#include <cctype>
#include <iostream>
Line 1,412 ⟶ 1,571:
std::cout << "output: " << output << '\n';
return 0;
}</
{{out}}
Line 1,421 ⟶ 1,580:
=={{header|Clojure}}==
<syntaxhighlight lang="clojure">
(defn words [str]
"Split string into words"
(.split str "\\s+"))
(defn join-words [strings]
"Join words into a single string"
(clojure.string/join " " strings))
(def cmd-table
"Command Table - List of words to match against"
(words
"Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up"))
; TODO - cache word properties
(defn abbr-valid?
"Is abbr abbreviation of word?"
[abbr word]
(and (.startsWith (.toLowerCase word) (.toLowerCase abbr))
(<= (count (filter #(Character/isUpperCase %) word))
(count abbr)
(count word))))
(defn find-word-for-abbr
"Find first word matching abbreviation, or nil if not found"
[abbr]
(first (filter #(abbr-valid? abbr %) cmd-table)))
(defn solution
"Find word matching each abbreviation in input (or *error* if not found),
and join results into a string"
[str]
(join-words (for [abbr (words str)]
(if-let [word (find-word-for-abbr abbr)]
(.toUpperCase word)
"*error*"))))
;; Example Input
(print (solution "riG rePEAT copies put mo rest types fup. 6 poweRin"))
</syntaxhighlight>
{{out}}
<pre>
RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</pre>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{Trans|Go}}
<syntaxhighlight lang="delphi">
program Abbreviations_Easy;
{$APPTYPE CONSOLE}
uses
System.SysUtils;
const
_TABLE_ =
'Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy ' +
'COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find ' +
'NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput ' +
'Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO ' +
'MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT ' +
'READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT ' +
'RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up ';
function validate(commands, words: TArray<string>; minLens: TArray<Integer>):
TArray<string>;
begin
SetLength(result, 0);
if Length(words) = 0 then
exit;
for var wd in words do
begin
var matchFound := false;
var wlen := wd.Length;
for var i := 0 to High(commands) do
begin
var command := commands[i];
if (minLens[i] = 0) or (wlen < minLens[i]) or (wlen > length(command)) then
continue;
var c := command.ToUpper;
var w := wd.ToUpper;
if c.StartsWith(w) then
begin
SetLength(result, Length(result) + 1);
result[High(result)] := c;
matchFound := True;
Break;
end;
end;
if not matchFound then
begin
SetLength(result, Length(result) + 1);
result[High(result)] := 'error*';
end;
end;
end;
begin
var table := _TABLE_.Trim;
var commands := table.Split([' '], TStringSplitOptions.ExcludeEmpty);
var clen := Length(commands);
var minLens: TArray<integer>;
SetLength(minLens, clen);
for var i := 0 to clen - 1 do
begin
var count := 0;
for var c in commands[i] do
begin
if (c >= 'A') and (c <= 'Z') then
inc(count);
end;
minLens[i] := count;
end;
var sentence := 'riG rePEAT copies put mo rest types fup. 6 poweRin';
var words := sentence.Split([' '], TStringSplitOptions.ExcludeEmpty);
var results := validate(commands, words, minLens);
Write('user words: ');
for var j := 0 to Length(words) - 1 do
Write(words[j].PadRight(1 + length(results[j])));
Write(#10, 'full words: ');
Writeln(string.Join(' ', results));
Readln;
end.</syntaxhighlight>
=={{header|Euphoria}}==
<syntaxhighlight lang="euphoria">
include std/text.e -- for upper conversion
include std/console.e -- for display
Line 1,458 ⟶ 1,753:
return flatten(join(results," ")) -- convert sequence of strings into one string, words separated by a single space;
end function
</syntaxhighlight>
{{out}}
<pre>
Line 1,466 ⟶ 1,761:
=={{header|Factor}}==
<
literals math qw sequences sequences.extras splitting.extras ;
IN: rosetta-code.abbreviations-easy
Line 1,518 ⟶ 1,813:
: main ( -- ) user-input "" [ .abbr ] bi@ ;
MAIN: main</
{{out}}
<pre>
Line 1,526 ⟶ 1,821:
Full words:
</pre>
=={{header|FreeBASIC}}==
{{trans|ALGOL 68}}
<syntaxhighlight lang="vbnet">Dim As String table = "Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy " _
+ "COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find " _
+ "NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput " _
+ "Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO " _
+ "MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT " _
+ "READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT " _
+ "RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up"
Function NextWord(Byref posic As Integer, text As String) As String
' skip spaces
While posic <= Len(text) And Mid(text, posic, 1) = " "
posic += 1
Wend
' get the word
Dim word As String = ""
While posic <= Len(text) And Mid(text, posic, 1) <> " "
word += Mid(text, posic, 1)
posic += 1
Wend
Return word
End Function
Function MinABLength(comando As String) As Integer
Dim ab_min As Integer = 1
While ab_min <= Len(comando) And Ucase(Mid(comando, ab_min, 1)) = Mid(comando, ab_min, 1)
ab_min += 1
Wend
Return ab_min - 1
End Function
Function Expand(table As String, word As String) As String
If Len(word) = 0 Then
Return ""
Else
Dim As Integer word_len = Len(word)
Dim As String result = "*error*"
Dim As Integer posic = 1
Do
Dim As String comando = NextWord(posic, table)
If Len(comando) = 0 Then
Exit Do
Elseif word_len < MinABLength(comando) Or word_len > Len(comando) Then
Continue Do
Elseif Ucase(word) = Ucase(Left(comando, word_len)) Then
result = Ucase(comando)
Exit Do
End If
Loop
Return result
End If
End Function
Sub TestExpand(words As String, table As String)
Dim As String word, results = "", separator = ""
Dim As Integer posic = 1
Do
word = NextWord(posic, words)
If Len(word) = 0 Then Exit Do
results += separator + Expand(table, word)
separator = " "
Loop
Print "Input: "; words
Print "Output: "; results
End Sub
' task test cases
TestExpand("riG rePEAT copies put mo rest types fup. 6 poweRin", table)
TestExpand("", table)
Sleep</syntaxhighlight>
{{out}}
<pre>Same as ALGOL 68 entry.</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
_window = 1
begin enum 1
_userStringFld
_validateBtn
_resultsStringFld
end enum
void local fn BuildWindow
window _window, @"Abbreviations, easy", (0,0,600,268)
WindowSetContentMinSize( _window, fn CGSizeMake( 200, 268 ) )
WindowSetContentMaxSize( _window, fn CGSizeMake( 10000, 268 ) )
textfield _userStringFld,, @"riG rePEAT copies put mo rest types fup. 6 poweRin", (20,152,560,96)
TextFieldSetPlaceholderString( _userStringFld, @"Enter commands" )
ViewSetAutoresizingMask( _userStringFld, NSViewWidthSizable )
button _validateBtn,,, @"Validate", (259,117,83,32)
ViewSetAutoresizingMask( _validateBtn, NSViewMinXMargin + NSViewMaxXMargin )
textfield _resultsStringFld,,, (20,20,560,96)
TextFieldSetEditable( _resultsStringFld, NO )
TextFieldSetSelectable( _resultsStringFld, YES )
ViewSetAutoresizingMask( _resultsStringFld, NSViewWidthSizable )
end fn
local fn Commands as CFArrayRef
CFStringRef words = @"Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy "
words = fn StringByAppendingString( words, @"COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find " )
words = fn StringByAppendingString( words, @"NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput " )
words = fn StringByAppendingString( words, @"Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO " )
words = fn StringByAppendingString( words, @"MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT " )
words = fn StringByAppendingString( words, @"READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT " )
words = fn StringByAppendingString( words, @"RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up" )
end fn = fn StringComponentsSeparatedByCharactersInSet( words, fn CharacterSetWhitespaceAndNewlineSet )
local fn MinLength( string as CFStringRef ) as long
long index, minLength = 0
long length = len(string)
for index = 0 to length - 1
unichar chr = fn StringCharacterAtIndex( string, index )
if ( chr >= _"A" and chr <= _"Z" )
minLength++
else
break
end if
next
end fn = minlength
void local fn Validate
CFArrayRef commands = fn Commands
CFStringRef userString = fn ControlStringValue( _userStringFld )
CFArrayRef words = fn StringComponentsSeparatedByCharactersInSet( userString, fn CharacterSetWhitespaceAndNewlineSet )
long cmdCount = len(commands)
CFMutableStringRef results = fn MutableStringWithCapacity(0)
long wordCount = len(words)
long i, j
for i = 0 to wordCount - 1
CFStringRef result = @"*error* "
CFStringRef wd = words[i]
long wordLength = len(wd)
if ( wordLength )
for j = 0 to cmdCount - 1
CFStringRef cmd = commands[j]
if ( fn StringHasPrefix( lcase(cmd), lcase(wd) ) )
if ( wordLength >= fn MinLength(cmd) )
result = fn StringWithFormat( @"%@ ",ucase(cmd) )
break
end if
end if
next
MutableStringAppendString( results, result )
end if
next
ControlSetStringValue( _resultsStringFld, results )
end fn
void local fn DoDialog( ev as long, tag as long )
select ( ev )
case _btnClick
select ( tag )
case _validateBtn : fn Validate
end select
end select
end fn
editmenu 1
fn BuildWindow
on dialog fn DoDialog
HandleEvents
</syntaxhighlight>
=={{header|Go}}==
{{trans|Kotlin}}
<
import (
Line 1,595 ⟶ 2,066:
fmt.Print("\nfull words: ")
fmt.Println(strings.Join(results, " "))
}</
{{out}}
Line 1,605 ⟶ 2,076:
=={{header|Haskell}}==
<
import Data.Maybe (fromMaybe)
import Data.List (find, isPrefixOf)
Line 1,642 ⟶ 2,113:
let commands = map (fromMaybe "*error*" . expandAbbreviation commandTable) abbreviations
putStrLn $ unwords results
</syntaxhighlight>
=={{header|J}}==
Using the expand definition as well as its dependencies from [[Abbreviations, simple#J]]
we convert this command table into the form with the abbreviation length given as a number.
<syntaxhighlight lang="j">
COMMAND_TABLE=: noun define
Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
Line 1,663 ⟶ 2,134:
CT expand user_words
RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</
=={{header|Java}}==
<
import java.util.Map;
import java.util.Scanner;
Line 1,720 ⟶ 2,191:
}
}
</syntaxhighlight>
{{out}}
Line 1,728 ⟶ 2,199:
RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</pre>
=={{header|JavaScript}}==
=== Deno ===
Works in Browsers as well, uses ES6. Most of the hardwork was done by the RegEx engine.
<syntaxhighlight lang="javascript">
var abr=`Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up`
.split(/\W+/).map(_=>_.trim())
function escapeRegex(string) {
return string.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
}
var input = prompt();
console.log(input.length==0?null:input.trim().split(/\s+/)
.map(
(s=>abr.filter(
a=>(new RegExp('^'+escapeRegex(s),'i'))
.test(a)&&s.length>=a.match(/^[A-Z]+/)[0].length
)[0])
)
.map(_=>typeof _=="undefined"?"*error*":_).join(' ')
)
</syntaxhighlight>
=={{header|jq}}==
<syntaxhighlight lang="jq">
def commands:
"Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy " +
"COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find " +
"NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput " +
"Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO " +
"MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT " +
"READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT " +
"RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up ";
# produce a "dictionary" in the form of an array of {prefix, word} objects
def dictionary:
reduce (splits(" +") | select(length>0)) as $w ([];
. + [$w | {prefix: sub("[a-z]+";""), word: ascii_upcase} ]);
def translate($dict):
# input: a string; $command: a {prefix, word} object
def match($command):
. as $uc
| startswith($command.prefix) and ($command.word | startswith($uc));
if length==0 then ""
else ascii_upcase
| first($dict[] as $command | select( match($command) ) | $command | .word)
// "*error*"
end;
# Emit the translation of an entire "sentence"
def translation:
(commands|dictionary) as $dict
| reduce splits(" +") as $w (""; . + ($w|translate($dict)) + " ")
| sub(" $";"");
# Example:
"riG rePEAT copies put mo rest types fup. 6 poweRin"
| translation
</syntaxhighlight>
Invocation: jq -n -f abbreviations.jq
{{out}}
<pre>
"RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT"
</pre>
Line 1,734 ⟶ 2,276:
{{trans|Kotlin}}
<
"Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy " *
"COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find " *
Line 1,769 ⟶ 2,311:
result = validate(commands, minlens, words)
println("User words: ", join(lpad.(words, 11)))
println("Full words: ", join(lpad.(result, 11)))</
{{out}}
Line 1,776 ⟶ 2,318:
=={{header|Kotlin}}==
<
val r = Regex("[ ]+")
Line 1,818 ⟶ 2,360:
for (j in 0 until results.size) print("${results[j]} ")
println()
}</
{{out}}
Line 1,827 ⟶ 2,369:
=={{header|Lua}}==
<
local list1 = [[
Line 1,918 ⟶ 2,460:
start() -- run the program
</
{{out}}
Line 1,927 ⟶ 2,469:
RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[ct, FunctionMatchQ, ValidFunctionQ, ProcessString]
ct = "Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up";
ct = FixedPoint[StringReplace[{"\n" -> "", Longest[" " ..] -> " "}], ct];
ct = StringSplit[ct, " "];
FunctionMatchQ[func_String, test_String] := Module[{min, max, l},
min = StringCount[func, Alternatives @@ CharacterRange["A", "Z"]];
max = StringLength[func];
l = StringLength[test];
If[min <= l <= max,
If[StringStartsQ[func, test, IgnoreCase -> True],
True
,
False
]
,
False
]
]
ValidFunctionQ[test_String] := Module[{val},
val = SelectFirst[ct, FunctionMatchQ[#, test] &, Missing[]];
If[MissingQ[val], "*error*", ToUpperCase[val]]
]
ProcessString[test_String] := Module[{parts},
parts = StringSplit[test];
StringRiffle[ValidFunctionQ /@ parts, " "]
]
ProcessString["riG rePEAT copies put mo rest types fup. 6 poweRin"]</syntaxhighlight>
{{out}}
<pre>"RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT"</pre>
=={{header|MATLAB}} / {{header|Octave}}==
<syntaxhighlight lang="matlab">
function R = abbreviations_easy(input)
Line 1,959 ⟶ 2,538:
R = [R,' ',result];
end
</syntaxhighlight>
{{out}}
Line 1,969 ⟶ 2,548:
=={{header|Nanoquery}}==
{{trans|Java}}
<
COMMAND_TABLE = " Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy\n" +\
Line 2,018 ⟶ 2,597:
print "*error* "
end
end</
{{out}}
<pre>Please enter your command to verify: riG rePEAT copies put mo rest types fup. 6 poweRin RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT</pre>
Line 2,025 ⟶ 2,604:
{{trans|Kotlin}}
This is a translation of Kotlin solution with some modifications.
<syntaxhighlight lang="nim">
import sequtils
import strutils
Line 2,080 ⟶ 2,659:
echo ""
break
</syntaxhighlight>
{{out}}
<pre>
Line 2,098 ⟶ 2,677:
=={{header|OCaml}}==
<
Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
Line 2,144 ⟶ 2,723:
) user
in
print_endline (String.concat " " r)</
{{out}}
Line 2,151 ⟶ 2,730:
RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</pre>
=={{header|Pascal}}==
==={{header|Free Pascal}}===
{{trans|Delphi}} only modified to get the implicit declared variables and types.
<syntaxhighlight lang="pascal">
program Abbreviations_Easy;
{$IFDEF WINDOWS}
{$APPTYPE CONSOLE}
{$ENDIF}
{$IFDEF FPC}
{$MODE DELPHI}
uses
SysUtils;
{$ELSE}
uses
System.SysUtils;
{$ENDIF}
const
_TABLE_ =
'Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy ' +
'COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find ' +
'NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput ' +
'Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO ' +
'MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT ' +
'READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT ' +
'RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up ';
function validate(commands, words: TArray<string>; minLens: TArray<Integer>):
TArray<string>;
var
wd,c,command,w : String;
wdIdx,wlen,i : integer;
matchFound : boolean;
begin
SetLength(result, 0);
if Length(words) = 0 then
exit;
for wdIdx := Low(words) to High(words) do
begin
wd := words[wdIdx];
matchFound := false;
wlen := wd.Length;
for i := 0 to High(commands) do
begin
command := commands[i];
if (minLens[i] = 0) or (wlen < minLens[i]) or (wlen > length(command)) then
continue;
c := command.ToUpper;
w := wd.ToUpper;
if c.StartsWith(w) then
begin
SetLength(result, Length(result) + 1);
result[High(result)] := c;
matchFound := True;
Break;
end;
end;
if not matchFound then
begin
SetLength(result, Length(result) + 1);
result[High(result)] := 'error*';
end;
end;
end;
var
results,commands,words :TArray<string>;
table,sentence :String;
minLens: TArray<integer>;
cLen,i,j,count : integer;
c:char;
begin
table := _TABLE_.Trim;
commands := table.Split([' '], TStringSplitOptions.ExcludeEmpty);
clen := Length(commands);
SetLength(minLens, clen);
for i := 0 to clen - 1 do
begin
count := 0;
For j := length(commands[i]) downto 1 do
begin
c := commands[i][j];
if (c >= 'A') and (c <= 'Z') then
inc(count);
end;
minLens[i] := count;
end;
sentence := 'riG rePEAT copies put mo rest types fup. 6 poweRin';
words := sentence.Split([' '], TStringSplitOptions.ExcludeEmpty);
results := validate(commands, words, minLens);
Write('user words: ');
for j := 0 to Length(words) - 1 do
Write(words[j].PadRight(1 + length(results[j])));
Write(#10, 'full words: ');
// FOr fpc 3.0.4 on TIO.RUN
for j := 0 to Length(words) - 1 do
Write(results[j],' ');
// fpc 3.2.2 will do
// Writeln(string.Join(' ', results));
{$IFDEF WINDOWS}
Readln;
{$ENDIF}
end.</syntaxhighlight>
{{out|@TIO.RUN fpc 3.0.4 }}
<pre>
user words: riG rePEAT copies put mo rest types fup. 6 poweRin
full words: RIGHT REPEAT error* PUT MOVE RESTORE error* error* error* POWERINPUT</pre>
=={{header|Perl}}==
{{trans|Raku}}
<
Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
Line 2,181 ⟶ 2,871:
}
print "$inp\n$out\n"</
{{out}}
<pre>Input: riG rePEAT copies put mo rest types fup. 6 poweRin
Line 2,188 ⟶ 2,878:
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">abbrtxt</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""
Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up
"""</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">input</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"riG rePEAT copies put mo rest types fup. 6 poweRin"</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">set_min_lengths</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">ai</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">uai</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">upper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ai</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=-</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ai</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">to</span> <span style="color: #000000;">0</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">or</span> <span style="color: #000000;">ai</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]!=</span><span style="color: #000000;">uai</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">ai</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ai</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">j</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">abbrevs</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">set_min_lengths</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">substitute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">abbrtxt</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">),</span><span style="color: #000000;">no_empty</span><span style="color: #0000FF;">:=</span><span style="color: #004600;">true</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">inputs</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">input</span><span style="color: #0000FF;">,</span><span style="color: #000000;">no_empty</span><span style="color: #0000FF;">:=</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">inputs</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">ii</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">inputs</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"*error*"</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">abbrevs</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #0000FF;">{</span><span style="color: #004080;">string</span> <span style="color: #000000;">aj</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">l</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">abbrevs</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ii</span><span style="color: #0000FF;">)>=</span><span style="color: #000000;">l</span>
<span style="color: #008080;">and</span> <span style="color: #7060A8;">match</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ii</span><span style="color: #0000FF;">,</span><span style="color: #000000;">aj</span><span style="color: #0000FF;">,</span><span style="color: #000000;">case_insensitive</span><span style="color: #0000FF;">:=</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)==</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">upper</span><span style="color: #0000FF;">(</span><span style="color: #000000;">aj</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">exit</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">&</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</pre>
=={{header|PHP}}==
<syntaxhighlight lang="php">
// note this is php 7.x
$commands = 'Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Line 2,195 ⟶ 2,936:
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up';
$input = 'riG rePEAT copies put mo rest types fup. 6 poweRin';
$expect = 'RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT';
$table = makeCommandTable($commands);
$table_keys = array_keys($table);
$inputTable = processInput($input);
foreach ($inputTable as $word) {
$rs = searchCommandTable($word, $table);
if ($rs) {
$output[] = $rs;
} else {
}
}
echo 'Input: '. $input. PHP_EOL;
echo 'Output: '. implode(' ', $output). PHP_EOL;
function searchCommandTable($search, $table) {
foreach ($table as $key => $value) {
if ((strtoupper(substr($value['word'], 0, strlen($search))) === strtoupper($search)) && (strlen($search) >= $value['min_length'])) {
return $key;
}
}
return false;
}
function processInput($input) {
$input = preg_replace('!\s+!', ' ', $input);
$pieces = explode(' ', trim($input));
return $pieces;
}
function makeCommandTable($commands) {
$commands = preg_replace('!\s+!', ' ', $commands);
$pieces = explode(' ', trim($commands));
foreach ($pieces as $word) {
$rs[strtoupper($word)] = ['word'=>$word, 'min_length' => preg_match_all("/[A-Z]/", $word)];
}
return $rs;
}</syntaxhighlight>
{{Out}}
<pre>user words: riG rePEAT copies put mo rest types fup. 6 poweRin
full words: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT</pre>
=={{header|Picat}}==
{{trans|Prolog}}
{{works with|Picat}}
<syntaxhighlight lang="picat">
import util.
command_table("Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up").
validate("", _, Result) ?=>
Result = "".
validate(Word, Commands, Result), Word \= "" ?=>
member(Command, Commands),
append(Prefix, Suffix, Command),
Prefix == to_uppercase(Prefix),
Suffix == to_lowercase(Suffix),
LowWord = to_lowercase(Word),
LowPrefix = to_lowercase(Prefix),
append(LowPrefix, Other, LowWord),
LowCommand = to_lowercase(Command),
append(LowWord, _, LowCommand),
Result = to_uppercase(Command).
validate(Word, _, Result), Word \= "" =>
Result = "*error*".
main(Args) =>
command_table(Table),
Commands = split(Table),
foreach (Word in Args)
validate(Word, Commands, Result),
printf("%w ", Result)
end,
nl.
</syntaxhighlight>
{{out}}
<pre>
RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</pre>
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell"><# Start with a string of the commands #>
$cmdTableStr =
"Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up"
<# String of inputs #>
$userWordStr = "riG rePEAT copies put mo rest types fup. 6 poweRin"
$outputStr = $null
$cmdTabArray = @()
$userWordArray = @()
<# Split the strings into arrays using a space as the delimiter.
This also removes "blank" entries, which fits the requirement
"A blank input (or a null input) should return a null string." #>
$cmdTabArray = $cmdTableStr.Split(" ", [System.StringSplitOptions]::RemoveEmptyEntries)
$userWordArray = $userWordStr.Split(" ", [System.StringSplitOptions]::RemoveEmptyEntries)
<# Begins a loop to iterate through the inputs #>
foreach($word in $userWordArray)
{
$match = $false # Variable set to false so that if a match is never found, the "*error*" string can be appended
foreach($cmd in $cmdTabArray)
{
2) are abbreviations of the command
3) the abbreviations is at least the number of capital characters in the command #>
if($cmd -like "$word*" -and ($word.Length -ge ($cmd -creplace '[a-z]').Length))
{
$outputStr += $cmd.ToUpper() + " " # Adds the command in all caps to the output string
$match = $true #
break #
}
}
if($match -eq $false){ $outputStr += "*error* " } # Appends error if no match was found
}
#
"User text: " + $userWordStr
"Full text: " + $outputStr</syntaxhighlight>
{{Out}}
<pre>User text: riG rePEAT copies put mo rest types fup. 6 poweRin
Full text: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT</pre>
=={{header|
{{works with|SWI Prolog}}
<syntaxhighlight lang="prolog">
:- initialization(main).
command_table("Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up").
validate("", _, "") :- !.
validate(Word, Commands, Result) :-
member(Command, Commands),
string_concat(Prefix, Suffix, Command),
string_upper(Prefix, Prefix),
string_lower(Suffix, Suffix),
string_lower(Word, LowWord),
string_lower(Prefix, LowPrefix),
string_concat(LowPrefix, _, LowWord),
string_lower(Command, LowCommand),
string_concat(LowWord, _, LowCommand),
string_upper(Command, Result),
!.
validate(_, _, "*error*").
main :-
current_prolog_flag(argv, Args),
command_table(Table),
split_string(Table, " \t\n", "", Commands),
forall(member(Arg, Args), (
atom_string(Arg, Word),
validate(Word, Commands, Result),
format("~w ", Result)
)),
nl.
</syntaxhighlight>
{{out}}
<pre>
RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</pre>
=={{header|Python}}==
{{works with|Python|3.6}}
<syntaxhighlight lang="python">command_table_text = \
"""Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up"""
user_words = "riG rePEAT copies put mo rest types fup. 6 poweRin"
def find_abbreviations_length(command_table_text):
""" find the minimal abbreviation length for each word by counting capital letters.
a word that does not have capital letters gets it's full length as the minimum.
"""
command_table = dict()
Line 2,304 ⟶ 3,149:
command_table[word] = abbr_len
return command_table
def find_abbreviations(command_table):
Line 2,314 ⟶ 3,158:
abbreviations[abbr] = command.upper()
return abbreviations
def parse_user_string(user_string, abbreviations):
Line 2,320 ⟶ 3,163:
commands = [abbreviations.get(user_word, "*error*") for user_word in user_words]
return " ".join(commands)
command_table = find_abbreviations_length(command_table_text)
Line 2,328 ⟶ 3,170:
print("user words:", user_words)
print("full words:", full_words)</syntaxhighlight>
{{Out}}
<pre>user words: riG rePEAT copies put mo rest types fup. 6 poweRin
full words: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT</pre>
=={{header|R}}==
<syntaxhighlight lang="R">
library(stringi)
cmds_block <- "
Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput
Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO
MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT
READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT
RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up"
cmds <- cmds_block %>% trimws() %>% stri_split_regex("\\s+") %>% unlist()
check_word <- function(inputw,comw) {
inputl <- nchar(inputw)
coml <- nchar(comw)
cap_cnt <- stri_count_regex(comw,"[A-Z]")
ifelse(cap_cnt != 0 && inputl >= cap_cnt && inputl <= coml &&
stri_startswith_fixed(toupper(comw),toupper(inputw)),T,F)
}
# Inputs
intstr_list <- "riG rePEAT copies put mo rest types fup. 6 poweRin" %>%
stri_split_regex("\\s+") %>% unlist()
# Results
results <- sapply(intstr_list,\(y) {
matc <- cmds[sapply(cmds,\(x) check_word(y,x))]
ifelse(length(matc) != 0,toupper(matc[1]),"*error*")
})
print(results)
</syntaxhighlight>
{{Out}}
<pre>
riG rePEAT copies put mo rest types fup. 6 poweRin
"RIGHT" "REPEAT" "*error*" "PUT" "MOVE" "RESTORE" "*error*" "*error*" "*error*" "POWERINPUT"
</pre>
=={{header|Racket}}==
<
(define command-string
Line 2,362 ⟶ 3,250:
full-command))
"*error*"))
" ")</
{{out}}
Line 2,375 ⟶ 3,263:
Demonstrate that inputting an empty string returns an empty string in addition to the required test input.
<syntaxhighlight lang="raku"
Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find
Line 2,397 ⟶ 3,285:
put ' Input: ', $str;
put 'Output: ', join ' ', $str.words.map: &abbr-easy;
}</
{{out}}
<pre> Input: riG rePEAT copies put mo rest types fup. 6 poweRin
Line 2,405 ⟶ 3,293:
=={{header|REXX}}==
<syntaxhighlight lang
userwords= 'riG rePEAT copies put mo rest types fup. 6 poweRin'
Say 'user words: ' userwords
'COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find'
'NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput'
'Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO'
'MErge MOve MODify MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT'
'READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT'
'RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up'
Say 'full words: ' validate(userwords) /*display the result(s) To the terminal*/
/*----------------------------------------------------------------------------------*/
validate: Procedure Expose keyws
res=''
Do j=1 To words(userwords) /* loop through userwords
uword=word(userwords,j) /* get next userword
Do k=1 To words(keyws) /* loop through all keywords */
keyw=word(keyws,k)
L=verify(keyw,'abcdefghijklmnopqrstuvwxyz','M') /* pos. of first lowercase ch*/
If L==0 Then
L=length(keyw)
L=L-1
If abbrev(translate(keyw),uword,L) Then Do /* uword is an abbreviation */
res=res keyw /* add the matching keyword To the result string */
iterate j /* and proceed with the next userword if any */
End
End
res=res '*error*' /* no match found. indicate error */
End
Return strip(res) /* get rid of leading böank */
syntaxhighlight>
{{out|output|text= when using the default input:}}
<pre>
Line 2,440 ⟶ 3,337:
=={{header|Ruby}}==
<
cmd_table = File.read(ARGV[0]).split
Line 2,456 ⟶ 3,353:
puts
</syntaxhighlight>
{{out}}
<pre>
Line 2,465 ⟶ 3,362:
=={{header|Rust}}==
<
fn main() {
Line 2,498 ⟶ 3,395:
println!("{}", corrected_line);
}
</syntaxhighlight>
{{out}}
<pre>
Line 2,505 ⟶ 3,402:
=={{header|Scala}}==
<syntaxhighlight lang="scala">
object Main extends App {
implicit class StrOps(i: String) {
Line 2,538 ⟶ 3,435:
println(resultLine)
}
</syntaxhighlight>
{{out}}
<pre>
Line 2,545 ⟶ 3,442:
=={{header|Tcl}}==
<
proc appendCmd {word} {
# Procedure to append the correct command from the global list ::cmds
Line 2,584 ⟶ 3,481:
puts $result
</syntaxhighlight>
{{out}}
<pre>
Line 2,591 ⟶ 3,488:
=={{header|VBA}}==
<
Dim s As String
Dim user_words() As String
Line 2,642 ⟶ 3,539:
Debug.Print "user words:", guserstring
Debug.Print "full words:", ValidateUserWords(guserstring)
End Sub</
full words: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT </pre>
=={{header|Vedit macro language}}==
<
Buf_Switch(#10=Buf_Free)
Ins_Text("
Line 2,710 ⟶ 3,607:
}
}
Return</
{{out}}
<pre>
RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</pre>
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">import encoding.utf8
fn validate(commands []string, words []string, min_len []int) []string {
mut results := []string{}
if words.len == 0 {
return results
}
for word in words {
mut match_found := false
wlen := word.len
for i, command in commands {
if min_len[i] == 0 || wlen < min_len[i] || wlen > command.len {
continue
}
c := utf8.to_upper(command)
w := utf8.to_upper(word)
if c.index(w) or {-1} ==0 {
results << c
match_found = true
break
}
}
if !match_found {
results << "*error*"
}
}
return results
}
fn main() {
mut table := "Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy " +
"COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find " +
"NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput " +
"Join SPlit SPLTJOIN LOAD Locate CLocate LOWercase UPPercase LPrefix MACRO " +
"MErge MODify MOve MSG Next Overlay PARSE PREServe PURge PUT PUTD Query QUIT " +
"READ RECover REFRESH RENum REPeat Replace CReplace RESet RESTore RGTLEFT " +
"RIght LEft SAVE SET SHift SI SORT SOS STAck STATus TOP TRAnsfer Type Up "
table = table.trim_space()
commands := table.fields()
clen := commands.len
mut min_len := []int{len: clen}
for i in 0..clen {
mut count := 0
for c in commands[i].split('') {
if c >= 'A' && c <= 'Z' {
count++
}
}
min_len[i] = count
}
sentence := "riG rePEAT copies put mo rest types fup. 6 poweRin"
words := sentence.fields()
results := validate(commands, words, min_len)
for j in 0..words.len {
print("${words[j]} ")
}
print("\nfull words: ")
println(results.join(" "))
}</syntaxhighlight>
{{out}}
<pre>
riG rePEAT copies put mo rest types fup. 6 poweRin
full words: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT
</pre>
Line 2,720 ⟶ 3,685:
{{libheader|Wren-fmt}}
{{libheader|Wren-str}}
<
import "./str" for Str
var table =
Line 2,777 ⟶ 3,742:
}
System.write("\nfull words: ")
System.print(results.join(" "))</
{{out}}
Line 2,786 ⟶ 3,751:
=={{header|Yabasic}}==
<
data "COUnt COVerlay CURsor DELete CDelete Down DUPlicate Xedit EXPand EXTract Find"
data "NFind NFINDUp NFUp CFind FINdup FUp FOrward GET Help HEXType Input POWerinput"
Line 2,831 ⟶ 3,796:
return n
end sub
</syntaxhighlight>
=={{header|zkl}}==
Rather more brute force than I'd like but hashing the command table is
just too much code. And the table is so small...
<
#<<<
"Add ALTer BAckup Bottom CAppend Change SCHANGE CInsert CLAst COMPress COpy
Line 2,859 ⟶ 3,824:
}
"*error*"
.concat(" ").println();</
{{out}}
<pre>
|