Comma quibbling: Difference between revisions

 

=={{header|11l}}==

R S words.len

0

print(quibble([‘ABC’]))

print(quibble([‘ABC’, ‘DEF’]))

{{out}}

<pre>

 

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

COMMAQUI CSECT

USING COMMAQUI,R13 base register

CJ DS CL1

YREGS

{{out}}

<pre>

=={{header|8080 Assembly}}==

 

jmp demo

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

db 'ABC$DEF$$'

db 'ABC$DEF$G$H$$'

 

{{out}}

{ABC and DEF}

{ABC, DEF, G and H}</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 : {ABC and DEF}

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

 

=={{header|Arturo}}==

]

 

loop sentences 'sentence [

print quibble sentence

{{out}}

<pre>{}

{ABC}

 

=={{header|Astro}}==

let result = s.join(' and ').replace(|| and ||, ", ", length(s) - 1)

return "{ $result }"

 

for i in s:

 

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

 

=={{header|BCPL}}==

 

// Add a character to the end of a string

words!2 := "G" ; words!3 := "H" ; words!4 := 0

writef("%S*N", quibble(words, buf))

{{out}}

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

 

=={{header|Cowgol}}==

 

sub quibble(words: [[uint8]],

print(quibble(&w3[0], @sizeof w3, LOMEM)); print_nl();

print(quibble(&w4[0], @sizeof w4, LOMEM)); print_nl();

 

{{out}}

 

=={{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 and DEF}

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

=={{header|Delphi}}==

See [[#Pascal|Pascal]].

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

 

===One Way===

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"];;

===or Another===

====The Function====

let quibble quibbler quibblee = Seq.zip quibblee quibbler //Sorry, just too good a line to miss, back in my Latin classes

====The Task====

let fN n = quibble (List.mapi(fun n _->match n with 0->"" |1-> " and " |_->", ") n |> List.rev) n

printf "{"; fN ["ABC"; "DEF"; "G"; "H"] |> Seq.iter(fun(n,g)->printf "%s%s" n g); printfn"}"

printf "{"; fN ["ABC"] |> Seq.iter(fun(n,g)->printf "%s%s" n g); printfn"}"

printf "{"; fN [] |> Seq.iter(fun(n,g)->printf "%s%s" n g); printfn"}"

{{out}}

<pre>

=={{header|Factor}}==

This example uses the <code>inverse</code> vocabulary, which builds on the concept of invertible quotations as the basis for pattern matching. It is discussed at length in this approachable [http://micsymposium.org/mics_2009_proceedings/mics2009_submission_72.pdf paper].

: (quibble) ( seq -- seq' )

 

{ } qw{ ABC } qw{ ABC DEF } qw{ ABC DEF G H }

{{out}}

<pre>

=={{header|Forth}}==

The efficient and beautiful way to solve the task is to keep a sliding triplet of consequent words. First we unconditionally read the first two words; if there are none, "read" gives us an empty word. Then we read the input stream, typing third to last word together with a comma. When the loop ends, we have two (possible empty) words on the stack, and the only thing left to do is to output it accordingly.

: read bl parse ;

: not-empty? ( c-addr u -- c-addr u true | false ) ?dup-if true else drop false then ;

quibble ABC DEF

quibble ABC DEF G H

 

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

 

// MAIN ---

return main();

{{Out}}

<pre>{}

 

Alternative implementation:

function quibble(words) {

var words2 = words.join()

return '{'+words4+'}';

}

 

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

{{works with|Julia|0.6}}

if isempty(arr) rst = "" else rst = "$(arr[end])" end

if length(arr) > 1 rst = join(arr[1:end-1], ", ") * " and " * rst end

@show quibble(["ABC"])

@show quibble(["ABC", "DEF"])

 

{{Out}}

 

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

=={{header|M2000 Interpreter}}==

===Using string as argument===

Module Checkit {

function f$ {

}

Checkit

 

===Using String functions only===

 

Module Checkit {

function f$ {

}

Checkit

 

===Using array as argument===

Module Checkit {

function f$(ar) {

}

Checkit

{{out}}

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

=={{header|MATLAB}} / {{header|Octave}}==

 

function r = comma_quibbling(varargin)

if isempty(varargin)

end

end;

 

 

 

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

=={{header|Objeck}}==

 

function : Quibble(words : String[]) ~ String {

text := "{";

Quibble(words)->PrintLine();

}

 

Output:

=={{header|OCaml}}==

 

 

let quibble list =

["ABC"; "DEF"];

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

 

{{works with|Core|v0.9.116.03+91}}

 

let quibble = function

[|"ABC"; "DEF"|];

[|"ABC"; "DEF"; "G"; "H"|]]

 

{{out}}

=={{header|Oforth}}==

 

| i s |

StringBuffer new "{" <<

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

]

 

{{out}}

 

=={{header|Ol}}==

(define (quibble . args)

(display "{")

(quibble "ABC" "DEF")

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

 

{{out}}

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

 

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

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

comma(["ABC"])

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

Output:

<pre>%1 = "{}"

=={{header|Pascal}}==

 

program CommaQuibbling;

 

writeln(Quibble.CommaQuibble);

end;

Output:

<Pre>

=={{header|Perl}}==

{{trans|Raku}}

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

<span style="color: #008080;">function</span> <span style="color: #000000;">quibble</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">words</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;">words</span><span style="color: #0000FF;">)>=</span><span style="color: #000000;">2</span> <span style="color: #008080;">then</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">quibble</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>

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

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

 

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

quib: Proc Options(main);

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

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

End;

{{out}}

<pre>

 

=={{header|PL/M}}==

 

/* COPY A STRING (MINUS TERMINATOR), RETURNS LENGTH (MINUS TERMINATOR) */

CALL BDOS(BDOS$EXIT, 0);

{{out}}

 

 

=={{header|Plain English}}==

Add "ABC" to some string things.

Add "DEF" to the string things.

Quibble four words.

Wait for the escape key.

{{out}}

<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|Quackery}}==

 

[ [ dup size

$ 'ABC' nest$ quibble echo$ cr

$ 'ABC DEF' nest$ quibble echo$ cr

{{out}}

<pre>

 

=={{header|R}}==

{

#The task does not consider empty strings to be words, so we remove them immediately.

#We could also remove non-upper-case characters, but the tasks gives off the impression that the user will do that.

len <- length(vect)

}

quib(character(0)) #R has several types of empty string, e.g. character(0), "", and c("", "", "").

quib(c("ABC", "DEF"))

quib(c("ABC", "DEF", "G", "H"))

{{out}}

<pre>> quib(character(0))

 

=={{header|Racket}}==

(define (sub-quibbling words)

(match words

 

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

{{out}}

<pre>() -> {}

=={{header|Raku}}==

(formerly Perl 6)

<{ }>.join: @A < 2 ?? @A !! "@A[0..*-2].join(', ') and @A[*-1]";

}

 

say comma-quibbling($_) for

{{out}}

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

 

=={{header|Ring}}==

# Project : Comma Quibbling

 

see str + nl

next

Output:

<pre>

{ABC DEF}

{ABC, DEF, G and H}

</pre>

 

=={{header|Ruby}}==

{{trans|Raku}}

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

 

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

=={{header|Sed}}==

script-file:

y/[/{/

y/]/}/

s/"//g

s/ [A-Z][A-Z]*}/ and&/g

test.txt:

["ABC"]

["ABC", "DEF"]

sed -f script-file test.txt

{{out}}

 

=={{header|Seed7}}==

 

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

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

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

 

{{out}}

 

=={{header|SenseTalk}}==

Quibble ["ABC"]

Quibble ["ABC", "DEF"]

end if

end Quibble

 

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

 

=={{header|VBA}}==

 

Sub Main()

If n > 0 Then s = Left(s, n - 1) & " and " & Right(s, Len(s) - (n + 1))

Quibbling = s

{{out}}

<pre>{}

 

=={{header|VBScript}}==

arr = Split(s,",")

If s = "" Then

WScript.StdOut.WriteLine

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

{{out}}

<pre>{}

FormatEnumerable() accepts an IEnumerable(Of String), as per Lippert's original specification. FormatArray() contains an alternative implementation for String().

 

Option Infer On

Option Strict On

End Sub

End Module

 

{{out}}

{ABC, DEF, G and H}

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

 

=={{header|Wren}}==

var c = w.count

if (c == 0) return "{}"

 

var words = [ [], ["ABC"], ["ABC", "DEF"], ["ABC", "DEF", "G", "H"] ]

 

{{out}}

{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$;"}"