Comma quibbling: Difference between revisions

Note: Assume words are non-empty strings of uppercase characters for this task.

<br><br>

 

=={{header|360 Assembly}}==

COMMAQUI CSECT

USING COMMAQUI,R13 base register

CJ DS CL1

YREGS

{{out}}

<pre>

</pre>

 

 

=={{header|Ada}}==

 

procedure Comma_Quibble is

Argument(Argument_Count) & "}");

end case;

 

{{out}}

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

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

# separated by ", ", except for the last which is separated from the rest by #

# " and ". The list is enclosed by braces #

test to list( "ABC" );

test to list( "ABC DEF" );

{{out}}

<pre>: {}

 

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

 

% returns a list of the words contained in wordString, separated by ", ", %

testToList( "ABC DEF G H" );

 

{{out}}

<pre>

ABC DEF G H : {ABC, DEF, G and H}</pre>

 

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}

on quibble(xs)

if length of xs > 1 then

on |words|(s)

words of s

{{Out}}

<pre>{}

{Jack and Jill}

{Loner}</pre>

 

=={{header|Astro}}==

 

 

 

=={{header|AutoHotkey}}==

MsgBox % quibble(["ABC"])

MsgBox % quibble(["ABC", "DEF"])

}

return "{" . s . "}"

{{out}}

<pre>{}

 

=={{header|AWK}}==

for (i = 1; i < n - 1; i++) s = s a[i] ", "

i = n - 1; if (i > 0) s = s a[i] " and "

n = split("ABC DEF", c); print quibble(c, n)

n = split("ABC DEF G H", d); print quibble(d, n)

{{out}}

<pre>{}

 

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

setlocal enabledelayedexpansion

 

echo {!output!}

goto :EOF

{{out}}

<pre>{}

 

Press any key to continue . . .</pre>

 

=={{header|Bracmat}}==

& ABC:?L2

& ABC DEF:?L3

& whl

' (!names:%?name ?names&out$(!name concat$!!name))

{{out}}

<pre>L1 {}

 

=={{header|C}}==

#include <string.h>

#include <stdlib.h>

}

return EXIT_SUCCESS;

{{Out}}

<pre>{}

 

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

using System.Linq;

 

#endregion

}

{{out}}

<pre>

 

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

 

template<class T>

}

return 0;

{{out}}

<pre>

 

=={{header|Clojure}}==

(let [sep (if (pos? (count sq)) " and " "")]

(apply str

 

(test quibble)

{{out}}

<pre>{}

{ABC, DEF, G and H}

</pre>

 

=={{header|COBOL}}==

{{works with|OpenCOBOL|2.0}}

IDENTIFICATION DIVISION.

PROGRAM-ID. comma-quibbling-test.

MOVE FUNCTION CONCATENATE("{", str) TO str

.

 

{{out}}

 

=={{header|CoffeeScript}}==

'{' +

(most.join ', ') +

console.log quibble(s) for s in [ [], ["ABC"], ["ABC", "DEF"],

["ABC", "DEF", "G", "H" ] ]

{{out}}

<pre>{}

{ABC and DEF}

{ABC, DEF, G and H}</pre>

 

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

(defun quibble (&rest args)

(format t "{~{~a~#[~; and ~:;, ~]~}}" args))

(quibble "ABC" "DEF")

(quibble "ABC" "DEF" "G" "H")

{{out}}

<pre>{}

{ABC}

 

=={{header|D}}==

 

string quibbler(in string[] seq) pure /*nothrow*/ {

["ABC", "DEF", "G", "H"]])

test.quibbler.writeln;

{{out}}

<pre>{}

 

===Alternative Version===

 

enum quibbler = (in string[] a) pure =>

[[], ["ABC"], ["ABC", "DEF"], ["ABC", "DEF", "G", "H"]]

.map!quibbler.writeln;

{{out}}

<pre>["{}", "{ABC}", "{ABC and DEF}", "{ABC, DEF, G and H}"]</pre>

=={{header|DCL}}==

$ gosub comma_quibbling

$ write sys$output return_string

$ done2:

$ return_string = return_string + "}"

{}out}}

<pre>$ @comma_quibbling

{ABC, DEF, G and H}</pre>

 

=={{header|Déjà Vu}}==

"}" )

if lst:

!. comma-quibble [ "ABC" ]

!. comma-quibble [ "ABC" "DEF" ]

{{out}}

<pre>"{}"

"{ABC and DEF}"

"{ABC, DEF, G and H}"</pre>

 

=={{header|EchoLisp}}==

(lib 'match)

 

("ABC" "DEF") ----> "{ ABC and DEF }"

("ABC" "DEF" "G" "H") ----> "{ ABC, DEF, G and H }"

 

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def generate( list ), do: "{#{ generate_content(list) }}"

Enum.each([[], ["ABC"], ["ABC", "DEF"], ["ABC", "DEF", "G", "H"]], fn list ->

IO.inspect RC.generate(list)

 

{{out}}

 

=={{header|Erlang}}==

-module( comma_quibbling ).

 

With_commas = [X ++ "," || X <- T],

string:join(lists:reverse([Last, "and", Second_to_last | With_commas]), " ").

{{out}}

<pre>

</pre>

 

let rec inner = function

| [] -> ""

quibble ["ABC"; "DEF"]

quibble ["ABC"; "DEF"; "G"]

Output from testing (in F# Interactive 3.0, Open Source version):

> quibble [];;

val it : string = "{}"

val it : string = "{ABC, DEF and G}"

> quibble ["ABC"; "DEF"; "G"; "H"];;

 

 

 

{{out}}

 

 

 

=={{header|Fortran}}==

Subroutine QUIBBLE doesn't have to worry about this because it works with TEXT as a parameter, whatever its size (various integer limits apply) however, it too has the same problem because it locates the start and end positions of each word, and, how many words are going to be found? So once again, the arrays are made "surely large enough" for the expected class of problem. The first stage is to locate the words separated by any amount of "white space", which, thanks to the inability to rely on the evaluation of compound boolean expressions (of the form <code>IF (''in bounds'' & ''Array indexing'')</code>) in the "shortcut" manner, employs a battery of IF-statements. Fortran does not offer a data type "list of ..." so there is no prospect of placing the words into such an entity then inserting commas and "and" elements into the list to taste. Instead, the list of words is represented by a sequence of values in ordinary arrays.

 

CHARACTER*(*) TEXT !The text, delimited by spaces.

LOGICAL OXFORDIAN !Just so.

 

Closedown

Output:

<pre>

 

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

 

Print "Press any key to quit the program"

Sleep

 

{{out}}

{ABC and DEF}

{ABC, DEF, G and H}

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=8edc63b206a1de50dd104cd12486ac03 Click this link to run this code]'''

Dim sInput As String[] = ["", "ABC", "ABC DEF", "ABC DEF G H"]

Dim sTemp As String

Next

 

Output:

<pre>

=={{header|Go}}==

The blog mentioned code maintenence. The idea here is to make the code easy for maintainers to understand by making it correspond as directly as possible to the problem description.

 

import (

fmt.Println(q([]string{"ABC", "DEF"}))

fmt.Println(q([]string{"ABC", "DEF", "G", "H"}))

{{out}}

<pre>

 

=={{header|Groovy}}==

'''Testing:'''

println "Verifying commaQuibbling($input) == $expected"

assert commaQuibbling(input) == expected

{{out}}

<pre>Verifying commaQuibbling([]) == {}

 

=={{header|Haskell}}==

where quibbles [] = ""

quibbles [a] = a

[[], ["ABC"], ["ABC", "DEF"], ["ABC", "DEF", "G", "H"]] ++

(map words ["One two three four", "Me myself I", "Jack Jill", "Loner" ])

{{Out}}

<pre>

 

Or, defining just two cases, and drawing more on standard libraries than on hand-crafted pattern-matching and recursion:

 

quibble :: [String] -> String

 

main :: IO ()

main =

mapM_ (putStrLn . (`intercalate` ["{", "}"]) . quibble) $

{{Out}}

<pre>{}

 

The following works in both languages:

every write(quibble([] | ["ABC"] | ["ABC","DEF"] | ["ABC","DEF","G","H"]))

end

while s := pull(A)||join||s do join := if *join = 0 then " and " else ", "

return "{"||s||"}"

 

Sample run:

 

=={{header|J}}==

withoutLast2=: ([: # _2&}.) {. ]

 

'''Testing:'''

quibble every Tests

{}

{ABC}

{ABC and DEF}

 

Alternative implementation:

 

 

(same results)

 

=={{header|Java}}==

 

public static String quibble(String[] words) {

System.out.println(quibble(new String[]{"ABC", "DEF", "G", "H"}));

}

 

{{out}}

=={{header|JavaScript}}==

===ES5===

return "{" +

words.slice(0, words.length-1).join(",") +

console.log(quibble(s));

}

{{out}}

<pre>{}

{{Trans|Haskell}}

Composing from a set of generic functions:

'use strict';

 

 

// quibble :: [String] -> String

const quibble = xs =>

)

) : concat(xs);

 

 

 

 

 

 

 

 

// map :: (a -> b) -> [a] -> [b]

 

// reverse :: [a] -> [a]

const reverse = xs =>

 

 

// tail :: [a] -> [a]

 

 

// unlines :: [String] -> String

 

 

{{Out}}

<pre>{}

{Jack and Jill}

{Loner}</pre>

 

=={{header|jq}}==

{{works with|jq|1.4}}

if length == 0 then ""

elif length == 1 then .[0]

else (.[0:length-1] | join(", ")) + " and " + .[length-1]

end

'''Example''':

{{Out}}

{}

{ABC}

{ABC and DEF}

{ABC, DEF, G and H}

 

=={{header|Julia}}==

 

 

 

=={{header|Kotlin}}==

 

fun commaQuibble(s: String): String {

)

for (input in inputs) println("${input.padEnd(24)} -> ${commaQuibble(input)}")

 

{{out}}

["ABC", "DEF"] -> {ABC and DEF}

["ABC", "DEF", "G", "H"] -> {ABC, DEF, G and H}

</pre>

 

=={{header|Lasso}}==

 

local(collection =

}

 

 

Output:

 

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

do

read in$

 

data "END" 'Sentinel for EOD.

{{Out}}

<pre>

 

=={{header|Logo}}==

output cond [

[ [empty? :list] :result ]

]

 

{{out}}

<pre>{}

 

=={{header|Lua}}==

local outString, join = "{"

for strNum = 1, #strTab do

{"ABC", "DEF", "G", "H"}

}

{{out}}

<pre>{}

{ABC and DEF}

{ABC, DEF, G and H}</pre>

 

=={{header|Maple}}==

uses StringTools;

Fence( proc()

end if

end(), "{", "}" )

 

Check it on the required inputs:

"{}"

 

> Quibble( ["ABC", "DEF", "G", "H"] );

"{ABC, DEF, G and H}"

 

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

ToString@{StringJoin@@

Replace[Riffle[{words}, ", "],

{{out}}

<pre>

In[5]:= quibble["ABC","DEF","G","H"]

Out[5]= {ABC, DEF, G and H}

</pre>

 

=={{header|MAXScript}}==

fn separate words: =

(

)

)

Output:

separate words:#()

"{}"

separate words:#("ABC","DEF","G","H")

"{ABC, DEF, G and H}"

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

end lst

return

{{out}}

<pre>

 

=={{header|Nim}}==

result = ""

for i, c in s:

var s = @[@[], @["ABC"], @["ABC", "DEF"], @["ABC", "DEF", "G", "H"]]

for i in s:

 

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

{{works with|oo2c}}

MODULE CommaQuibbling;

IMPORT

Out.String(":> ");Out.String(str);Out.Ln

END CommaQuibbling.

{{out}}

<pre>

$ bin/CommaQuibbling ABC DEF G H

:> {ABC, DEF, G and H}

</pre>

 

=={{header|Oforth}}==

 

| i s |

StringBuffer new "{" <<

i s == ifTrue: [ " and " << ]

]

 

{{out}}

[ [], ["ABC"], ["ABC", "DEF"], ["ABC", "DEF", "G", "H"] ] map(#quibbing) .

[{}, {ABC}, {ABC and DEF}, {ABC, DEF, G and H}]

</pre>

 

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

 

if(#v==0, return("{}"));

if(#v==1, return(Str("{"v[1]"}")));

comma(["ABC"])

comma(["ABC", "DEF"])

Output:

<pre>%1 = "{}"

%3 = "{ABC and DEF}"

%4 = "{ABC, DEF, G and H}"</pre>

=={{header|Pascal}}==

 

program CommaQuibbling;

 

 

type

 

{ TCommaQuibble }

property CommaQuibble: string read GetCommaquibble write SetCommaQuibble;

end;

 

{ TCommaQuibble }

procedure TCommaQuibble.SetCommaQuibble(AValue: string);

begin

end;

 

function TCommaQuibble.GetCommaquibble: string;

begin

begin

end;

end;

 

begin

 

for TestString in TestData do

begin

writeln(Quibble.CommaQuibble);

end;

Output:

<Pre>

 

=={{header|Perl}}==

return "{$_}" for

@_ < 2 ? "@_" :

 

print comma_quibbling(@$_), "\n" for

{{out}}

<pre>{}

'''Perl 5.01 version and other approach:'''

 

my $last = pop // '';

return '{'. (@_ ? (join ', ', @_).' and '.$last : $last).'}';

 

say for map {comma_quibbling(@$_)}

{{out}}

<pre>{}

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|PHP}}==

 

 

 

 

 

}

foreach ($tests as $test) {

echo quibble($test) . PHP_EOL;

{{out}}

<pre>{}

 

=={{header|PicoLisp}}==

(let H (head -1 L)

(prinl

(and H " and ")

(last L)

Output:

<pre>{}

{ABC and DEF}

{ABC, DEF, G and H}</pre>

 

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

quib: Proc Options(main);

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

Return('{'!!result!!'}');

End;

{{out}}

<pre>

{ABC and DEF}

{ABC, DEF, G and H}

</pre>

 

=={{header|PowerShell}}==

function Out-Quibble

{

"{" + $outStr -f $text + "}"

}

Out-Quibble

Out-Quibble "ABC"

Out-Quibble "ABC", "DEF"

Out-Quibble "ABC", "DEF", "G", "H"

{{Out}}

<pre>

</pre>

What it might look like when working with a file:

$file = @'

 

Out-Quibble -Text ($line -split ", ")

}

{{Out}}

<pre>

{{works with|SWI-Prolog|7.1}}

 

words_serialized(Words, Serialized),

atomics_to_string(["{",Serialized,"}"], Bracketed).

( words_series(Words, Series),

format('~w ~15|=> ~w~n', [Words, Series]))

 

{{Out}}

[] => {}

[ABC] => {ABC}

[ABC,DEF] => {ABC and DEF}

[ABC,DEF,G,H] => {ABC, DEF, G and H}

 

=={{header|PureBasic}}==

EnableExplicit

 

CloseConsole()

EndIf

 

{{out}}

hence the replace is done on the reverse of the intermediate string

then reversed back.

return '{%s}' % ', '.join(sequence)[::-1].replace(',', 'dna ', 1)[::-1]

 

Input: ['ABC', 'DEF'] -> Output: '{ABC and DEF}'

Input: ['ABC', 'DEF', 'G', 'H'] -> Output: '{ABC, DEF, G and H}'

 

===Python: Counted replacement===

replace() will replace nothing if the count of items to replace is zero, (and negative integer counts act to replace all occurrences).

This combines with the length of the input sequence to allow this to work:

return '{%s}' % ' and '.join(s).replace(' and ', ', ', len(s) - 2)

 

for seq in ([], ["ABC"], ["ABC", "DEF"], ["ABC", "DEF", "G", "H"]):

 

{{out}}

 

===Python: Functional===

return ('{' +

(', '.join(s[:-1]) + ' and ' if len(s) > 1 else '') +

Input: ['ABC', 'DEF'] -> Output: '{ABC and DEF}'

Input: ['ABC', 'DEF', 'G', 'H'] -> Output: '{ABC, DEF, G and H}'

 

=={{header|Racket}}==

(define (sub-quibbling words)

(match words

 

(for ((input '([] ["ABC"] ["ABC" "DEF"] ["ABC" "DEF" "G" "H"])))

{{out}}

<pre>() -> {}

("ABC" "DEF") -> {ABC and DEF}

("ABC" "DEF" "G" "H") -> {ABC, DEF, G and H}</pre>

 

=={{header|REBOL}}==

===Straightforward implementation===

 

comma-quibbling: func [block] [

 

foreach t [[] [ABC] [ABC DEF] [ABC DEF G H]] [print comma-quibbling t]

{{out}}

<pre>{}

{ABC, DEF, G and H}</pre>

===Alternative (more efficient) version with oxford comma switch===

 

; builds string instead of using an intermediate block

print "Now with Oxford comma"

foreach t test [print comma-quibbling/oxford t]

{{out}}

<pre>{}

{ABC and DEF}

{ABC, DEF, G, and H}</pre>

 

=={{header|REXX}}==

===version 1:===

say quibbling('ABC')

say quibbling('ABC DEF')

'and' word(list,words(list))

End

{{out}}

<pre>

</pre>

===version 2:===

say quibbling('ABC')

say quibbling('ABC DEF')

result=result 'and' word.wn

End

{{output}}

<pre>

===version 3:===

{{trans|NetRexx}}

 

i_ = 0

lst = overlay(' ', insert('and', lst, lc), lc)

lst = space(lst, 1) -- remove extra spaces

{{out}}

<pre>

["ABC", 'DEF'] : {ABC and DEF}

[ABC, DEF, G, H] : {ABC, DEF, G and H}

</pre>

 

=={{header|Ruby}}==

%w<{ }>.join(a.length < 2 ? a.first :

"#{a[0..-2].join(', ')} and #{a[-1]}")

[[], %w<ABC>, %w<ABC DEF>, %w<ABC DEF G H>].each do |a|

puts comma_quibbling(a)

{{out}}

<pre>{}

{ABC and DEF}

{ABC, DEF, G and H}</pre>

 

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

[""ABC""]

[""ABC"", ""DEF""]

next i

print a$

{{out}}

<pre>[] ==> {}

 

=={{header|Rust}}==

fn quibble(seq: &[&str]) -> String {

match seq.len() {

println!("{}", quibble(&["ABC", "DEF", "G", "H"]));

}

{{out}}

<pre>

 

=={{header|Scala}}==

case m if m.isEmpty => "{}"

case m if m.length < 3 => m.mkString("{", " and ", "}")

println( quibble( List("ABC","DEF") ) )

println( quibble( List("ABC","DEF","G","H") ) )

{{out}}

<pre>{}

=={{header|Scheme}}==

 

(define (quibble . args)

(display "{")

(quibble "ABC" "DEF")

(quibble "ABC" "DEF" "G" "H")

 

{{out}}

{ABC, DEF, G and H}

</pre>

 

=={{header|Seed7}}==

 

const func string: quibble (in array string: input) is func

writeln(quibble([] ("ABC", "DEF")));

writeln(quibble([] ("ABC", "DEF", "G", "H")));

 

{{out}}

{ABC, DEF, G and H}

</pre>

 

=={{header|Sidef}}==

}

 

[<>, <ABC>, <ABC DEF>, <ABC DEF G H>].each { |w|

{{out}}

<pre>{}

 

=={{header|Standard ML}}==

fun quib [] = ""

| quib [x] = x

val t_quibble_2 = quibble ["ABC", "DEF"] = "{ABC and DEF}"

val t_quibble_3 = quibble ["ABC", "DEF", "G", "H"] = "{ABC, DEF, G and H}"

=={{header|Swift}}==

 

func quibbling(var words:[String]) {

for word in inputs {

quibbling(word)

{{out}}

<pre>

 

=={{header|Tcl}}==

return \{[join [lreplace $lst end-1 end [join [lrange $lst end-1 end] " and "]] ", "]\}

}

foreach input { {} {"ABC"} {"ABC" "DEF"} {"ABC" "DEF" "G" "H"} } {

puts [commaQuibble $input]

{{out}}

<pre>

=={{header|TXR}}==

 

(tree-bind (: last . lead) (reverse list)

 

=={{header|UNIX Shell}}==

 

quibble

quibble ABC

quibble ABC DEF

{{out}}

<pre>{}

{ABC and DEF}

{ABC, DEF, G and H}</pre>

 

=={{header|VBScript}}==

arr = Split(s,",")

If s = "" Then

WScript.StdOut.WriteLine

WScript.StdOut.Write Quibble("ABC,DEF,G,H")

{{out}}

<pre>{}

{ABC and DEF}

{ABC, DEF, G and H}</pre>

 

=={{header|XLISP}}==

I like the Oxford comma; but specifications are specifications. So this implementation produces the required output by default. It also, however, allows an optional <tt>OXFORD-COMMA</tt> parameter: pass a true value, and you won't find yourself saying things like "I want to thank my parents, Ayn Rand and God".

(define final

(if (and (caddr inputs) oxford-comma)

(print (quibble '("ABC") t))

(print (quibble '("ABC" "DEF") t))

{{out}}

<pre>"{}"

 

=={{header|XPL0}}==

 

proc Quibble(N, S);

for I:= 0 to 4 do

if I#3 then [Quibble(I, ["ABC", "DEF", "G", "H"]); CrLf(0)]

 

{{out}}

=={{header|zkl}}==

This is a cheese ball solution that replies on no commas in the inputs

if(list.len()<2) text;

else{

String(text[0,z]," and ",text[z+2,*])

}

List.toString("*") converts List(1,2,3) to "L(1,2,3)" with all elements; without the *, long lists are shortened to L(1,2,3,...)

{{out}}

 

=={{header|ZX Spectrum Basic}}==

20 DATA 1,"ABC"

30 DATA 2,"ABC","DEF"

1090 NEXT i

1100 PRINT "{";s$;"}"