Abbreviations, simple: Difference between revisions

{{Template:Strings}}

<br><br>

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program abbrSimple64.s */

ldr x5,[x6,#command_min]

cmp x5,#0 // minimum = zéro ?

cmp x4,x5 // input < command capital letters

blt 4f // no correct

add x3,x3,#1 // else increment counter

mov x7,x1 // and save address command

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

<pre>

Enter command (or <ctrl-c> to stop) : riG

*error*

Enter command (or <ctrl-c> to stop) : put

Enter command (or <ctrl-c> to stop) : mo

MOVE

pi@debian-buster-64:~/asm64/rosetta/asm9 $

</pre>

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

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

 

# returns the next word from text, updating pos #

 

# task test cases #

{{out}}

<pre>

Also note that &nbsp; <big> put </big> &nbsp; isn't an error. }}

 

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program abbrSimple.s */

/* store list of command in a file */

 

/* REMARK 1 : this program use routines in a include file

ldr r5,[r6,#command_min]

cmp r5,#0 @ minimum = zéro ?

blt 4f @ no correct

add r3,r3,#1 @ else increment counter

mov r7,r1 @ and save address command

/***************************************************/

.include "../affichage.inc"

<pre>

Enter command (or <ctrl-c> to stop) : riG

*error*

Enter command (or <ctrl-c> to stop) : put

Enter command (or <ctrl-c> to stop) : mo

MOVE

Enter command (or <ctrl-c> to stop) : 6

*error*

Enter command (or <ctrl-c> to stop) : ^C

</pre>

 

=={{header|C}}==

#include <stdbool.h>

#include <stdio.h>

free_command_list(commands);

return 0;

 

{{out}}

 

=={{header|C++}}==

#include <cctype>

#include <iostream>

std::cout << "output: " << output << '\n';

return 0;

 

{{out}}

output: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT

</pre>

 

=={{header|Crystal}}==

"add 1 alter 3 backup 2 bottom 1 Cappend 2 change 1 Schange Cinsert 2 Clast 3

compress 4 copy 2 count 3 Coverlay 3 cursor 3 delete 3 Cdelete 2 down 1 duplicate

puts "Output:"

puts parse_user_input(user_input, cmds)

 

{{out}}

 

=={{header|D}}==

{

import std.array: split, join;

writeln("Output: ", new Abbreviations(table).expand(input));

}

{{out}}

<pre>

Output: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT

</pre>

 

=={{header|Factor}}==

kernel literals math math.parser multiline sequences

splitting.extras unicode ;

: main ( -- ) input "" [ show-commands ] bi@ ;

 

{{out}}

<pre>

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

include FMS-SILib.f

 

run RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT ok

 

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

printResults(words, results)

}

 

{{out}}

=={{header|Haskell}}==

{{Trans|Python}}

import Data.Char (isDigit, toUpper)

import Data.Maybe (maybe)

unAbbrev

"riG rePEAT copies put mo rest types fup. 6 poweRin"

{{Out}}

<pre>"RIGHT REPEAT *error PUT MOVE RESTORE *error *error *error POWERINPUT"

 

=={{header|J}}==

compress 4 copy 2 count 3 Coverlay 3 cursor 3 delete 3 Cdelete 2 down 1 duplicate

3 xEdit 1 expand 3 extract 3 find 1 Nfind 2 Nfindup 6 NfUP 3 Cfind 2 findUP 3 fUP 2

refresh renum 3 repeat 3 replace 1 Creplace 2 reset 3 restore 4 rgtLEFT right 2 left

2 save set shift 2 si sort sos stack 3 status 4 top transfer 3 type 1 up 1

 

 

=={{header|Java}}==

{{Trans|C++}}

 

public class Abbreviations {

private List<Command> commands = new ArrayList<>();

}

 

{{out}}

{{Trans|Haskell}}

{{Trans|Python}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>Abbreviation tests:

'' ->

''</pre>

 

=={{header|Julia}}==

const commandtable = """

add 1 alter 3 backup 2 bottom 1 Cappend 2 change 1 Schange Cinsert 2 Clast 3

 

teststring("riG rePEAT copies put mo rest types fup. 6 poweRin")

riG rePEAT copies put mo rest types fup. 6 poweRin

RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT

 

=={{header|Kotlin}}==

 

private const val table = "" +

println("full words: ${results.joinToString(" ")}")

}

 

{{out}}

full words: RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT

</pre>

 

=={{header|MiniScript}}==

" compress 4 copy 2 count 3 Coverlay 3 cursor 3 delete 3 Cdelete 2 down 1 duplicate" +

" 3 xEdit 1 expand 3 extract 3 find 1 Nfind 2 Nfindup 6 NfUP 3 Cfind 2 findUP 3 fUP 2" +

output.push check(word)

end for

 

{{out}}

<pre>RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT</pre>

 

=={{header|Nim}}==

{{Trans|Python}}

Adapted from Python version with several modifications.

import parseutils

import strutils

echo ""

break

 

{{out}}

 

=={{header|OCaml}}==

 

let table_as_string =

replace 1 Creplace 2 reset 3 restore 4 rgtLEFT right 2 left 2 \

save set shift 2 si sort sos stack 3 status 4 top \

 

The interesting part below is the '''compare''' function.

but for the latter, we need to ensure that the word corresponds to the abbreviation

(the abbreviation is a substring of the word and the abbreviation length is sufficient).

type t = { word : string ; min : int }

let compare e1 e2 =

end

 

 

The few functions below are used to build the table from the string at the beginning.

List.filter (fun w -> w <> "" && w <> " ") strs

 

split_on_char ' ' table_as_string

|> clean_strings

 

Finally, here is the function looking for a word :

let w = uppercase_ascii w in

try

let inputs = ["riG";"rePEAT";"copies";"put";"mo";"rest";"types";"fup.";"6";"poweRin"] in

check table inputs;

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

add 1 alter 3 backup 2 bottom 1 Cappend 2 change 1 Schange Cinsert 2 Clast 3

compress 4 copy 2 count 3 Coverlay 3 cursor 3 delete 3 Cdelete 2 down 1 duplicate

}

 

{{out}}

<pre>Input: riG rePEAT copies put mo rest types fup. 6 poweRin

 

=={{header|Phix}}==

{{out}}

<pre>

====Procedural====

{{works with|Python|3.6}}

 

command_table_text = """add 1 alter 3 backup 2 bottom 1 Cappend 2 change 1 Schange Cinsert 2 Clast 3

print("user words:", user_words)

print("full words:", full_words)

{{out}}

<pre>input: ""

====Composition of pure functions====

{{Works with|Python|3.7}}

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Simple abbreviations:

 

=={{header|Racket}}==

(require srfi/13)

 

(validate-string "riG rePEAT copies put mo rest types fup. 6 poweRin")

"RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT")

{{out}}

<pre>input: ""

Demonstrate that inputting an empty string returns an empty string in addition to the required test input.

 

add 1 alter 3 backup 2 bottom 1 Cappend 2 change 1 Schange Cinsert 2 Clast 3

compress 4 copy 2 count 3 Coverlay 3 cursor 3 delete 3 Cdelete 2 down 1 duplicate

put ' Input: ', $str;

put 'Output: ', join ' ', $str.words.map: &abbr-simple;

{{out}}

<pre> Input: riG rePEAT copies put mo rest types fup. 6 poweRin

 

=={{header|REXX}}==

 

'compress 4 copy 2 count 3 Coverlay 3 cursor 3 delete 3 Cdelete 2 down 1 duplicate',

'3 xEdit 1 expand 3 extract 3 find 1 Nfind 2 Nfindup 6 NfUP 3 Cfind 2 findUP 3 fUP 2',

'forward 2 get help 1 hexType 4 input 1 powerInput 3 join 1 split 2 spltJOIN load',

'locate 1 Clocate 2 lowerCase 3 upperCase 3 Lprefix 2 macro merge 2 modify 3 move 2',

'refresh renum 3 repeat 3 replace 1 Creplace 2 reset 3 restore 4 rgtLEFT right 2 left',

'2 save set shift 2 si sort sos stack 3 status 4 top transfer 3 type 1 up 1'

 

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

<pre>

 

=={{header|Ruby}}==

compress 4 copy 2 count 3 Coverlay 3 cursor 3 delete 3 Cdelete 2 down 1 duplicate

3 xEdit 1 expand 3 extract 3 find 1 Nfind 2 Nfindup 6 NfUP 3 Cfind 2 findUP 3 fUP 2

 

puts ar.join(" ")

{{out}}

<pre>RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT

{{works with|Rust|1.35.0}}

cargo clippy and cargo fmt run against it

 

// The plan here is to build a hashmap of all the commands keyed on the minimum number of

let correct_output = "RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT";

assert_eq!(output_text, correct_output)

{{out}}

<pre>

 

=={{header|Scala}}==

object Main extends App {

implicit class StrOps(i: String) {

println(resultLine)

}

{{out}}

<pre>

RIGHT REPEAT *error* PUT MOVE RESTORE *error* *error* *error* POWERINPUT

</pre>

=={{header|Tcl}}==

 

# Procedure to append the correct command from the global list ::cmds

# for the word given as parameter to the global list ::result.

 

puts "user words: $words"

{{out}}<pre>./abbreviations_simple.tcl

user words: riG rePEAT copies put mo rest types fup. 6 poweRin

 

=={{header|VBA}}==

Dim s As String

Dim user_words() As String

Debug.Print "full words:", ValidateUserWords(guserstring)

End Sub

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

 

{{libheader|Wren-str}}

Based on an older version of the Go entry.

 

var table =

}

System.write("\nfull words: ")

 

{{out}}

 

=={{header|Yabasic}}==

c$ = c$ + " compress 4 copy 2 count 3 Coverlay 3 cursor 3 delete 3 Cdelete 2 down 1 duplicate"

c$ = c$ + " 3 xEdit 1 expand 3 extract 3 find 1 Nfind 2 Nfindup 6 NfUP 3 Cfind 2 findUP 3 fUP 2"

next

 

 

{{out}}

 

=={{header|zkl}}==

#<<<

"add 1 alter 3 backup 2 bottom 1 Cappend 2 change 1 Schange Cinsert 2 Clast 3

n+=c.len();

}

{{out}}

<pre>