Abbreviations, automatic: Difference between revisions

{{trans|Python}}

V words = line.split(‘ ’)

V word_count = words.len

print()

{{out}}

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

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

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program abbrAuto64.s */

.include "../includeARM64.inc"

<pre>

Nom du fichier : listDays.txt

=={{header|Ada}}==

with Ada.Strings.Fixed;

with Ada.Strings.Maps;

Process (Get_Line);

end loop;

{{out}}

<pre style="height: 20ex;">

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

#include <jambo.h>

End If

End

{{out}}

<pre>

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program abbrAuto.s */

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

.include "../affichage.inc"

<pre>

Nom du fichier : listDays.txt

=={{header|AutoHotkey}}==

len := prev := 0

Days := StrSplit(line, " ")

}

return len

(

Sunday Monday Tuesday Wednesday Thursday Friday Saturday

}

MsgBox % result

{{out}}

<pre>2 > Su Mo Tu We Th Fr Sa

=={{header|AWK}}==

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

{ dow_arr[NR] = $0 }

}

function max(x,y) { return((x > y) ? x : y) }

{{out}}

<pre style="height:45ex">

=={{header|C}}==

{{trans|C#}}

#include <stdlib.h>

#include <string.h>

return 0;

{{out}}

<pre> 2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

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

using System.Collections.Generic;

}

}

{{out}}

<pre style="height:45ex"> 2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

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

{{trans|C#}}

#include <iostream>

#include <fstream>

return 0;

{{out}}

<pre style="height:45ex"> 2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

=={{header|COBOL}}==

{{works with|GnuCOBOL|3.1.2.0}}

PROGRAM-ID. AUTO-ABBREVIATIONS.

CLOSE DOW.

STOP RUN.

{{out}}

<pre style="height:45ex">

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

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

(defun max-mismatch (list)

(if (cdr list)

((null row) t)

(format t "~d ~a~%" (1+ (max-mismatch (SPLIT-SEQUENCE:split-sequence #\Space row))) row) ))

{{out}}

=={{header|D}}==

{{trans|Kotlin}}

import std.exception;

import std.range;

}

}

{{out}}

<pre style="height:45ex"> 2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

{{libheader| System.IOUtils}}

{{Trans|Kotlin}}

program Abbreviations_Automatic;

end;

Readln;

=={{header|Erlang}}==

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

-module(abbreviateweekdays).

-export([ main/0 ]).

{ok, Device} = (file:open("weekdays.txt", read)),

read_lines(Device, 1).

{{out}}

<pre>

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

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

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

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

fN ["Ehud"; "Segno"; "Maksegno"; "Erob"; "Hamus"; "Arbe"; "Kedame"] // -> 2

fN ["Al_Ahad"; "Al_Ithinin"; "Al_Tholatha'a"; "Al_Arbia'a"; "Al_Kamis"; "Al_Gomia'a"; "Al_Sabit";] // -> 5

=={{header|Factor}}==

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 "day-names.txt" utf8 [ body ] with-file-reader ;

{{out}}

<pre style="height:45ex">

=={{header|Go}}==

{{trans|Kotlin}}

import(

}

}

{{out}}

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

}

}

{{out}}

<pre> 2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

=={{header|Haskell}}==

import qualified Data.Set as S

]

. return

{{Out}}

<pre>2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

=={{header|J}}==

abbreviation_length =: monad define

N =. # y

L =. abbreviation_length&> a

((' ',~":)&> L) ,"1 lines

<pre>

=={{header|Java}}==

{{trans|D}}

import java.nio.file.Files;

import java.nio.file.Path;

}

}

{{out}}

<pre style="height:45ex"> 2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

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

document.write(`<p>(${l}): ${days.join('. ')}.</p>`);

}

{{out}}

{{Works with|MacOS JXA}}

"use strict";

// MAIN ---

return main();

{{Out}}

<pre>2: Su,Mo,Tu,We,Th,Fr,Sa

=={{header|Julia}}==

Sunday Monday Tuesday Wednesday Thursday Friday Saturday

Sondag Maandag Dinsdag Woensdag Donderdag Vrydag Saterdag

processweek(text)

(Showing first 10 lines.)

Sunday Monday Tuesday Wednesday Thursday Friday Saturday => ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"], which are length 2

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

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

import java.io.File

}

}

{{out}}

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

import kotlin.math.max

.forEach(::println)

}

{{out}}

=={{header|Ksh}}==

#!/bin/ksh

(( $((RANDOM%100+1))<=5 )) && { printf "%d. " $((i+1)) ; langs[i].print_wk ;}

{{out}}<pre>

15. (4) Dium Dill Dima Dime Dijo Dive Diss

=={{header|Lua}}==

local wa = {}

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

end

end

{{out}}

<pre style="height:45ex"> 2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

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

RequiredAbbreviationLength[""]="";

RequiredAbbreviationLength[input_String]:=Max[StringLength/@ShortestUniqueAbbreviations[StringSplit[input]]];

{{out}}

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

else:

echo line

===Using a sorted list===

import algorithm

import unicode

else:

echo line

{{out}}

<pre style="height:45ex">

=={{header|Objeck}}==

{{trans|Java}}

use Collection;

};

}

{{out}}

Output is the same as for Raku.

{{trans|Raku}}

use utf8;

binmode STDOUT, ":utf8";

while ($_ = <$fh>) {

print "$.) " . auto_abbreviate($_) . ' ' . $_;

=={{header|Phix}}==

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>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=={{header|Picat}}==

{{works with|Picat}}

import util.

end

end.

{{out}}

<pre style="height:45ex">

=={{header|Prolog}}==

{{works with|SWI Prolog}}

sort(Day_names, Sorted_names),

minimum_abbreviation_length(Sorted_names, Min_length, 1).

main:-

{{out}}

=={{header|PureBasic}}==

#TZ="|"

#FZ="@"

While CompareLetters(txt,letters) : letters+1 : Wend

ProcedureReturn letters

{{out}}

<pre style="height:45ex"> 2: Sunday Monday Tuesday Wednesday Thursday Friday Saturday

{{works with|Python|3.6}}

{{trans|Kotlin}}

words = line.split()

word_count = len(words)

print()

{{out}}

===Functional===

In terms of generators:

from itertools import (accumulate,

repeat)

if __name__ == '__main__':

{{out}}

<pre style="height:45ex">

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

{{Works with|Python|3}}

from itertools import (accumulate, chain)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

=={{header|Racket}}==

(require racket/set)

["" ""]

[(and s (app string-split ss)) (format "~a ~a" (abbr-length ss) s)]))

{{out}}

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;

# Testing

{{out}}

<pre style="height:40ex;overflow:scroll;">1) 2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

=={{header|Red}}==

Red []

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

print [min line] ;; print automatically reduces all words in block

]

{{Out}}

<pre>

=={{header|REXX}}==

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

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

leave m /*a good abbreviation length was found.*/

end /*m*/

{{out|output|text=&nbsp; when using the default input file containing the complete list of words:}}

<pre style="height:45ex">

=={{header|Ruby}}==

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

puts "Minimum size: #{abbr.values.max_by(&:size).size}", abbr.inspect, "\n"

end

{{out}}

<pre>Minimum size: 2

=={{header|Rust}}==

* Abbreviations from tintenalarm.de

*/

}

num

{{out}}

<pre style="height:45ex">

===Functional programmed===

====build.sbt====

scalaVersion := "2.13.0"

version := "0.1"

homepage := Some(url("http://rosettacode.org/wiki/Abbreviations,_automatic#Scala"))

====AbbreviationsAuto.scala====

private val wd = os.pwd

.foreach(line => println(processLine(line)))

{{out}}

<pre style="height:45ex"> ""

=={{header|SenseTalk}}==

put 1 into abbreviationLength

put the number of items in days into len

add 1 to abbreviationLength

end repeat

put the defaultStringEncoding into savedEncoding

close file myFile

{{out}}

<pre>

=={{header|Tcl}}==

set f [open abbreviations_automatic_weekdays.txt]

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

incr i

puts "$i $days"

{{out}}

<pre>2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

=={{header|Transd}}==

MainModule : {

(lout (+ len 1) " " days))

) ) )

<pre style="height:45ex">

2 [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]

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

STRING PROC FNStringGetExpressionRegularCharacterMetaEscapeS( STRING inS )

STRING s[255] = inS

GotoBufferId( bufferI )

END

{{out}} <pre>

2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

=={{header|VBA}}==

Function :

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

myVar = Split(strLine, " ")

Loop While Not Flag

MinimalLenght = Count

To call it :

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

Nb = FreeFile

Wend

Close #Nb

{{out}}

<pre style="height:45ex">2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

=={{header|VBScript}}==

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

f.close

{{out}}

<pre>

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

{{trans|C#}}

Sub Main()

End Sub

{{out}}

<pre> 2 Sunday Monday Tuesday Wednesday Thursday Friday Saturday

=={{header|Vlang}}==

{{trans|Go}}

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

}

}

{{out}}

{{libheader|Wren-seq}}

{{libheader|Wren-fmt}}

import "/pattern" for Pattern

import "/seq" for Lst

}

i = i + 1

{{out}}

=={{header|Yabasic}}==

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

until(s)

return d

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

return(m,day); // no match nowhere

});

{{out}}

<pre style="height:45ex">