Abbreviations, automatic: Difference between revisions

{{trans|Python}}

V words = line.split(‘ ’)

V word_count = words.len

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program abbrAuto64.s */

=={{header|Ada}}==

with Ada.Strings.Fixed;

with Ada.Strings.Maps;

=={{header|Amazing Hopper}}==

#include <jambo.h>

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program abbrAuto.s */

=={{header|AutoHotkey}}==

len := prev := 0

Days := StrSplit(line, " ")

return len

}</syntaxhighlight>

(

Sunday Monday Tuesday Wednesday Thursday Friday Saturday

=={{header|AWK}}==

# syntax: GAWK -f ABBREVIATIONS_AUTOMATIC.AWK ABBREVIATIONS_AUTOMATIC.TXT

{ dow_arr[NR] = $0 }

=={{header|C}}==

{{trans|C#}}

#include <stdlib.h>

#include <string.h>

=={{header|C sharp|C#}}==

using System.Collections.Generic;

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

{{trans|C#}}

#include <iostream>

#include <fstream>

=={{header|COBOL}}==

{{works with|GnuCOBOL|3.1.2.0}}

PROGRAM-ID. AUTO-ABBREVIATIONS.

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

It uses the standard library split-sequence to split the string into words.

(defun max-mismatch (list)

(if (cdr list)

=={{header|D}}==

{{trans|Kotlin}}

import std.exception;

import std.range;

{{libheader| System.IOUtils}}

{{Trans|Kotlin}}

program Abbreviations_Automatic;

The output is of the set of abbreviations. These are not sorted correctly and some encoding errors remain.

-module(abbreviateweekdays).

-export([ main/0 ]).

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

===The function===

let fN g=let rec fN n=if g|>List.map(fun(g:string)->g.[0..n])|>Set.ofList|>Set.count=(List.length g) then (n+1) else fN(n+1)

fN 0

</syntaxhighlight>

===The Task - Demonstrate the function===

fN ["Sunday"; "Monday"; "Tuesday"; "Wednesday"; "Thursday"; "Friday"; "Saturday"] // -> 2

fN ["Sondag"; "Maandag"; "Dinsdag"; "Woensdag"; "Donderdag"; "Vrydag"; "Saterdag"] // -> 2

As a concatenative language, Factor is uniquely suited for factoring words into smaller words. Assuming lexical/dynamic variables are not used, factoring is a cut-and-paste job that can be performed almost anywhere there is whitespace.

sequences sets splitting ;

IN: rosetta-code.abbreviations-automatic

=={{header|Go}}==

{{trans|Kotlin}}

import(

=={{header|Groovy}}==

{{trans|Java}}

static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("days_of_week.txt"), "utf-8"))

=={{header|Haskell}}==

import qualified Data.Set as S

=={{header|J}}==

abbreviation_length =: monad define

N =. # y

=={{header|Java}}==

{{trans|D}}

import java.nio.file.Files;

import java.nio.file.Path;

===Procedural===

The list of the names was edited and embedded in the HTML-Document with a <script>-tag, where it is accessible as an array called $list.

Array.prototype.hasDoubles = function() {

let arr = this.slice();

{{Works with|MacOS JXA}}

"use strict";

=={{header|Julia}}==

Sunday Monday Tuesday Wednesday Thursday Friday Saturday

Sondag Maandag Dinsdag Woensdag Donderdag Vrydag Saterdag

===Original O(''n²'') solution===

where ''n'' is the number of strings in each line.

import java.io.File

===Alternative O(''n log n'') solution based on sorting===

import kotlin.math.max

=={{header|Ksh}}==

#!/bin/ksh

=={{header|Lua}}==

local wa = {}

for i in string.gmatch(line, "%S+") do

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

(*This function gives all 'heads' of str of length 1 to maxLength. Since the input data was formatted to use underscores in place of spaces, there is an edge case where distinct abbreviations derived from the input data would actually not be distinct in the 'real' abbreviations. See further comments below regarding the difference between my output and the output of other solutions.*)

Abbreviations[maxLength_Integer][str_String]:=Array[StringTake[StringPadRight[str,maxLength,"_"],#]&,maxLength];

We provide two solutions, one consisting to build the abbreviations for each language and stopping when all of them are different, the second sorting the list of day names for each language and adjusting the abbreviation length to make sure that two consecutive day names are different. The second method should be more efficient, but it doesn’t really matters here.

===Using a set===

import sets

import unicode

</syntaxhighlight>

===Using a sorted list===

import algorithm

import unicode

=={{header|Objeck}}==

{{trans|Java}}

use Collection;

Output is the same as for Raku.

{{trans|Raku}}

use utf8;

binmode STDOUT, ":utf8";

The file abbrev_auto.txt was manually created from the task description. The following code

assumes a more recent version of get_text() that strips any leading utf8 bom by default (0.8.0+).

<span style="color: #008080;">constant</span> <span style="color: #000000;">lines</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">get_text</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"abbrev_auto.txt"</span><span style="color: #0000FF;">,</span><span style="color: #004600;">GT_LF_STRIPPED</span><span style="color: #0000FF;">)</span>

=={{header|Picat}}==

{{works with|Picat}}

import util.

=={{header|Prolog}}==

{{works with|SWI Prolog}}

sort(Day_names, Sorted_names),

minimum_abbreviation_length(Sorted_names, Min_length, 1).

=={{header|PureBasic}}==

#TZ="|"

#FZ="@"

{{works with|Python|3.6}}

{{trans|Kotlin}}

words = line.split()

word_count = len(words)

===Functional===

In terms of generators:

from itertools import (accumulate,

repeat)

The generic primitives are curried, allowing for more flexible composition:

{{Works with|Python|3}}

from itertools import (accumulate, chain)

=={{header|Racket}}==

(require racket/set)

Note that this is using a previous version of the date file that has erroneous duplicate day names (see line 90). Since the effort was already expended to catch such problems, it may as well be demonstrated.

return Nil unless my @words = $string.words;

return $_ if @words».substr(0, $_).Set == @words for 1 .. @words».chars.max;

=={{header|Red}}==

Red []

;; read and convert data to a string - to char conversion is neccessary to avoid

=={{header|REXX}}==

parse arg uw /*obtain optional arguments from the CL*/

iFID= 'ABBREV_A.TAB' /*name of the file that has the table. */

=={{header|Ruby}}==

File.read("daynames.txt").each_line do |line|

=={{header|Rust}}==

* Abbreviations from tintenalarm.de

*/

===Functional programmed===

====build.sbt====

scalaVersion := "2.13.0"

version := "0.1"

libraryDependencies += "com.lihaoyi" %% "os-lib" % "0.3.0"</syntaxhighlight>

====AbbreviationsAuto.scala====

private val wd = os.pwd

=={{header|SenseTalk}}==

put 1 into abbreviationLength

put the number of items in days into len

end repeat

end AbbreviationsAutomatic</syntaxhighlight>

put the defaultStringEncoding into savedEncoding

=={{header|Tcl}}==

set f [open abbreviations_automatic_weekdays.txt]

set lines [split [read -nonewline $f] \n]

=={{header|Transd}}==

MainModule : {

=={{header|TSE SAL}}==

STRING PROC FNStringGetExpressionRegularCharacterMetaEscapeS( STRING inS )

STRING s[255] = inS

=={{header|VBA}}==

Function :

Dim myVar As Variant, I As Integer, Flag As Boolean, myColl As Collection, Count As Integer

myVar = Split(strLine, " ")

End Function</syntaxhighlight>

To call it :

Dim Nb As Integer, s As String, Result() As String, c As Integer

Nb = FreeFile

=={{header|VBScript}}==

sub print(s) wscript.stdout.writeline s :end sub

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Sub Main()

=={{header|Vlang}}==

{{trans|Go}}

fn distinct_strings(strs []string) []string {

{{libheader|Wren-seq}}

{{libheader|Wren-fmt}}

import "/pattern" for Pattern

import "/seq" for Lst

=={{header|Yabasic}}==

a = open("days_of_week.txt", "r")

=={{header|zkl}}==

zkl doesn't grok UTF-8 so I'm using a byte by byte check. It works surprisingly well.

.pump(List,Void.Filter,fcn(day){

d,N,m := day.split(),d.len(),(0).max(d.apply("len")); // N==7