Quais são algumas abordagens inteligentes (breves e idiomáticas) para obter uma lista de cadeias e retornar uma única cadeia adequadamente pontuada criada a partir da lista, com cada elemento citado.

Isso surgiu para mim ao experimentar o Groovy , para o qual minha solução muito literal, mas ilustrativa, é

def temp = things.collect({"\'${it}\'"})
switch (things.size()) {
    case 1:
        result = temp[0]
        break
    case 2:
        result = temp.join(" and ")
        break
    default:
        result = temp.take(temp.size()-1).join(", ") + ", and " + temp[-1]
        break
}

Ou seja, ['1']deve ceder '1', ['1','2']deve ceder '1 and 2'[veja o que eu fiz lá?] E ['1','2','3']deve ceder '1, 2, and 3'.

Tenho boas respostas para o Groovy, mas gostaria de ver o que outros idiomas podem fazer.

Quais são algumas abordagens inteligentes e compactas em vários idiomas que tiram proveito dos recursos e idiomas desses idiomas?

CSS, 132 116 115 bytes

a:not(:last-child):nth-child(n+2):after,a:nth-last-child(n+3):after{content:","}a+:last-child:before{content:"and "

<p>
  <a>one</a>
</p>
<p>
  <a>one</a>
  <a>two</a>
</p>
<p>
  <a>one</a>
  <a>two</a>
  <a>three</a>
</p>
<p>
  <a>one</a>
  <a>two</a>
  <a>three</a>
  <a>four</a>
</p>

a:not(:last-child):nth-child(n+2):after,a:nth-last-child(n+3):after{content:","}a+:last-child:before{content:"and "

O CSS não é visto com muita frequência no código golf porque ele pode apenas formatar texto, mas na verdade funciona para esse desafio e achei que seria divertido fazer isso. Veja-o em ação usando o snippet acima (clique em "Mostrar snippet de código").

A lista deve estar em um arquivo HTML vinculado com cada elemento cercado por <a>tags e separado por quebras de linha. Os itens da lista devem ser os únicos elementos em seu elemento pai, por exemplo

<a>one</a>
<a>two</a>
<a>three</a>

Explicação

a:not(:last-child):nth-child(n+2)::after,
a:nth-last-child(n+3)::after {
    content: ",";
}

a + :last-child::before {
    content: "and ";
}

Vamos considerar a versão não destruída acima. Se você não estiver familiarizado com o funcionamento do CSS, tudo fora dos chavetas é um seletor que determina o conjunto de elementos HTML aos quais as declarações dentro dos chavetas se aplicam. Cada par de seletor-declaração é chamado de regra . (É mais complicado que isso, mas será suficiente para esta explicação.) Antes de aplicar qualquer estilo, a lista aparece separada apenas por espaços.

Queremos adicionar vírgulas após cada palavra, exceto a última, exceto as listas de duas palavras, que não possuem vírgulas. O primeiro seletor,, a:not(:last-child):nth-child(n+2):afterseleciona todos os elementos, exceto o primeiro e o último. :nth-child(n+2)é uma maneira mais curta de dizer :not(:first-child), e basicamente funciona selecionando elementos cujo índice (começando em 1) é maior ou igual a 2. (Sim, ainda me confunde um pouco. Os documentos do MDN podem ajudar.)

Agora só precisamos selecionar o primeiro elemento para obter uma vírgula se houver três ou mais elementos no total. a:nth-last-child(n+3):afterfunciona como :nth-child, mas contando pela parte de trás, por isso seleciona todos os elementos, exceto os dois últimos. A vírgula aceita a união dos dois conjuntos e usamos o :after pseudoelemento para adicionar contentimediatamente após cada elemento selecionado.

A segunda regra é mais fácil. Precisamos adicionar "e" antes do último elemento da lista, a menos que seja um único elemento. Em outras palavras, precisamos selecionar o último elemento que é precedido por outro elemento. +é o seletor de irmão adjacente em CSS.

Haskell: 81, 77 74 caracteres

f[x]=x
f[x,y]=x++" and "++y
f[x,y,z]=x++", "++f[y++",",z]
f(x:y)=x++", "++f y

Recursos de Haskell: Correspondência de padrões

Ruby, 47 bytes

q=" and ";p$*[2]?(a=$*.pop;$**", "+?,+q+a):$**q

Explicação

• A entrada são os argumentos da linha de comando ( $*).
• Quando $*tiver um terceiro elemento ( $*[2]não retorna nulo), pegue todos os elementos menos o último e transforme-os em uma String separada por vírgula usando Array#*. Por fim, adicione uma vírgula extra, a string " and "e o último argumento da linha de comando.
• Quando $*não tem terceiro elemento, dois, um ou zero argumentos foram dados. Os argumentos podem ser unidos com segurança à string " and "e produzir o resultado correto.

Python 2 (61)

s=input()
d=s.pop()
print", ".join(s)+", and "[8-7*len(s):]+d

O principal truque é cortar parte do marceneiro final ", and "para um e dois elementos. Por um lado, tudo é cortado e, por dois, a vírgula é removida. Isso é feito cortando [8-7*len(s):](observando que sé um menor após o pop).

Infelizmente, dnão pode ser substituído apenas por sua expressão ou popisso aconteceria tarde demais.

CSS, 62 caracteres 112 caracteres

Inspirado pelas outras entradas, ainda mais curtas. Observe que isso requer que os elementos A não sejam separados por espaços em branco:

a+a:before{content:", "}a+a:last-child:before{content:", and "

http://jsfiddle.net/olvlvl/1Ls79ocb/

Correção para o "um e dois", como apontado por Dennis:

a+a:before{content:", "}a+a:last-child:before{content:", and "}a:first-child+a:last-child:before{content:" and "

http://jsfiddle.net/olvlvl/1Ls79ocb/3/

Perl (v 5.10+) - 37 35 34 28

@F>2&&s/ /, /g;s/.* \K/and /

para ser executado perl -ape, com a lista fornecida com o espaço separado STDIN.

Saída para várias entradas:

$ perl -ape '@F>2&&s/ /, /g;s/.* \K/and /'
oxford
oxford
oxford cambridge
oxford and cambridge
oxford cambridge comma
oxford, cambridge, and comma
oxford cambridge comma space
oxford, cambridge, comma, and space

Javascript (63)

l=a.length;l>2&&(a[l-1]='and '+a[l-1]);a.join(l>2?', ':' and ')

Casos:

• a = [1] => 1
• a = [1, 2] => 1 and 2
• a = [1, 2, 3] => 1, 2, and 3

Advertência: isso modificará o último elemento em uma matriz com comprimento> 2.

GNU sed - 69 caracteres, incluindo 1 para a -rbandeira

s/ /, /g
s/( [^ ]+)( [^ ]+)$/\1 and\2/
s/^([^,]+),([^,]+)$/\1 and\2/

Leva uma lista separada por espaço (bastante idiomática para scripts de shell).

Exemplo

$ sed -r -f oxfordcomma.sed <<< "1"
1
$ sed -r -f oxfordcomma.sed <<< "1 2"
1 and 2
$ sed -r -f oxfordcomma.sed <<< "1 2 3"
1, 2, and 3
$

Python 2-71, 70 68

s=input()
l=len(s)-1
print', '.join(s[:l])+', and '[l<2:]*(l>0)+s[l]

Contagem de caracteres, incluindo ambos, inpute print.

Ruby, 57 bytes

f=->l{s=l*', ';s.sub(/,(?!.*,)/,(l.size<3?'':?,)+' and')}

Estou ingressando na string ,e, em seguida, substituindo a última vírgula na string por uma and(e opcional, dependendo do tamanho da lista).

Cobra - 60

do(l as String[])=l.join(', ',if(l.length<3,'',',')+' and ')

A List<of T>.joinfunção Cobra permite especificar um separador diferente para os dois elementos finais da lista, que é o que torna isso tão curto.

Perl - 59

sub f{$a=join', ',@_;$#_&&substr$a,(@_>2)-3,@_<3,' and';$a}

Une a lista com vírgulas e, se a lista tiver mais de um elemento, adiciona ' and'após a última vírgula (se comprimento> = 3) ou substitui a última vírgula por ela (se comprimento == 2).

PHP, 192 167 146 136 136 caracteres:

$n=' and ';$s=count($a);echo ($s<3)?join($n,$a):join(', ',array_merge(array_slice($a,0,$s-2),Array(join(",$n",array_slice($a,-2,2)))));

Com base em uma função que escrevi anos atrás em http://www.christopherbloom.com/2011/05/21/join-implode-an-array-of-string-values-with-formatting/

Lote - 151 bytes

@echo off&set f=for %%a in (%~1)do
%f% set/aa+=1
%f% set/ac+=1&if !c!==1 (set o=%%a)else if !c!==!a! (set o=!o!, and %%a)else set o=!o!, %%a
echo !o!

Nota; você precisa chamar o script cmdcom a /vopção definida como on, para não precisar incluir o longo setLocal enableDelayedExpansionno script. Caso contrário, adicione 30 à contagem de bytes e chame o script normalmente.

h:\uprof>cmd /von /c test.bat "1 2 3"
1, 2, and 3

h:\uprof>cmd /von /c test.bat "1 2 3 4 5"
1, 2, 3, 4, and 5

Groovy, 47 43 57 caracteres, JavaScript ES6 56 caracteres

Groovy:

(a[1]?a[0..-2].join(", ")+(a[2]?",":"")+" and ":"")+a[-1]

Como a matriz é preenchida com caracteres, podemos substituir a.size>1pora[1]

JavaScript, ES6:

a.join(', ').replace(/,([^,]+)$/,`${a[2]?',':''} and$1`)

Ambos os casos assumem que a variável a tem a matriz em questão.

PHP, 86 84 caracteres

$a = ['one', 'two', 'three', 'four', 'five'];

Com a matriz inicializada, começamos a contar:

$L=count($a)-1;$S=', ';$L<2?($S=' and '):($a[$L]='and '.$a[$L]);echo implode($S,$a);

Pré-especificado:

$last_index = count($a) - 1;
$separator = ', ';
if ($last_index < 2) {
    $separator = ' and ';
} else {
    $a[$last_index] = 'and '.$a[$last_index];
}
echo implode($separator, $a);

O último item da lista é modificado. Isso deve ser bom, porque no PHP, a atribuição de matriz e as chamadas de função executam cópias.

CJam, 35 30 28 27 bytes

q~)\_"and "L?@+a+_,2=", ">*

Este é um programa que lê de STDIN e imprime em STDOUT. Experimente online.

Como funciona

q~                                     " Q := eval(input())                               ";
  )                                    " P := Q.pop()                                     ";
   \_"and "L?@+                        " P := (Q ? 'and ' : '') + P                       ";
                a+                     " Q += [P]                                         ";
                  _,2=", ">            " J := ', '[(len(Q) == 2):]                        ";
                           *           " R := J.join(Q)                                   ";
                                       " print R (implicit)                               ";

Exemplo de execução

$ cjam <(echo 'q~)\_"and "L?@+a+_,2=", ">*') <<< '["1"]'; echo
1
$ cjam <(echo 'q~)\_"and "L?@+a+_,2=", ">*') <<< '["1""2"]'; echo
1 and 2
$ cjam <(echo 'q~)\_"and "L?@+a+_,2=", ">*') <<< '["1""2""3"]'; echo
1, 2, and 3
$ cjam <(echo 'q~)\_"and "L?@+a+_,2=", ">*') <<< '["1""2""3""4"]'; echo
1, 2, 3, and 4

Planilhas Google, 67 68 67 92 bytes

=SUBSTITUTE(JOIN(", ",FILTER(A:A,A:A<>"")),",",IF(COUNTA(A:A)>2,",","")&" and",COUNTA(A:A)-1

A entrada começa na célula A1e continua inativa por várias entradas.
JOINmescla todos eles em uma cadeia de caracteres com um espaço de vírgula entre cada um.
FILTERremove todos os espaços em branco para que você não termine com vírgulas infinitas no final.
SUBSTITUTEsubstitui a última vírgula (encontrada COUNTAcontando as entradas que não estão em branco).

Não é muito emocionante, mas é factível em uma única célula.

JavaScript (ES6) 60

Supondo que não haja cadeias vazias na matriz de entrada

f=(a,b=a.pop())=>a[0]?a.join(', ')+(a[1]?',':'')+' and '+b:b

Teste no console do FireFox / Firebug

console.log(f(['We invited the stripper','JFK','Stalin']))

Saída

 We invited the stripper, JFK, and Stalin

JavaScript - 60 56 71 67 63

Não é exatamente uma abordagem idiomática, mas me diverti escrevendo e gosto de regex.

Supondo que a matriz esteja armazenada em var a:

a.join((a.length>2?',':'')+' ').replace(/([^,\s])$/,"and $1")

Encurtado simplesmente verificando o índice [2]: (yay coerção booleana)

a.join((!!a[2]?',':'')+' ').replace(/([^,\s])$/,'and $1')

Aparentemente, sou péssimo nos testes e pulei um teste de entrada única. Aqui está a versão fixa:

a.join((!!a[2]?',':'')+' ').replace(/([^,\s])$/,(!!a[1]?'and ':'')+'$1')

Raspei 2 caracteres invertendo meus booleanos e mais 3 movendo o espaço da concatenação para o então / outro do primeiro ternário:

a.join((!a[2]?' ':', ')).replace(/([^,\s])$/,(!a[1]?'':'and ')+'$1')

Obrigado a @tomsmeding por me lembrar que não tenho que coagir meus booleanos porque JS faz isso por mim. Também percebi que esqueci de remover os parênteses que separam o primeiro ternário da concatenação dentro do join():

a.join(a[2]?', ':' ').replace(/([^,\s])$/,(a[1]?'and ':'')+'$1')

Eu fiz isso certo? Novo pedido de desculpas obrigatório.

Golfscript - 31 39 34 30

Olá Mundo! Sou muito espreita, pôster da primeira vez. Aqui está minha solução de 30 bytes no Golfscript (dado o array como [1 2 3] já está na pilha).

.,3<" and ":A{~A(;\+]", "}if*

Os resultados são adequados para todos os casos de teste.

EDIT: Pegue isso, CJam!

Xojo, 52 71 83 caracteres

dim i as int8=ubound(L)
L(i)=if(i=0,"","and ")+L(i)
Return L.Join(if(i=1," ",", ")

Observe que UBound é um a menos que o comprimento da matriz.

Excel VBA, 108 bytes

Função de janela imediata VBE anônima que recebe entrada como matriz delimitada por espaço do intervalo A1e sai para a janela imediata VBE.

x=Split([A1]):y=UBound(x):For i=0To y-2:?x(i)", ";:Next:If y>0Then?x(i)IIf(y>1,",","")" and "x(i+1)Else?[A1]

Raquete 87

(define(f x)(string-join(map ~a x)", "#:before-last(if(= 2(length x))" and "", and ")))

Python 62 chars

Supondo que i seja a lista de strings:

(" and", ", and")[len(i) < 2].join(", ".join(i).rsplit(",",1))

C # 102 Chars

var i=m.Count(),l=i;if(l>2)l--;var r=string.Join(", ",m.Take(l));if(l!=i)r+=" and "+m.Last();return r;

Julia (53)

print(join(ARGS,", ",(endof(ARGS)>2?",":"")" and "))

Leva args de STDIN e sai para STDOUT

Solução usando Base.join (itens, delim [, último])

Editar:

Casos de teste

julia oxfordComma.jl 1

1 1

julia oxfordComma.jl 1 2

1 e 2

julia oxfordComma.jl 1 2 3

1, 2 e 3

Rant (108)

[$[l:@b]:[r:each][s:[cmp:[rc];2;[is:different;,]]\s][before:[last:[notfirst:and\s]]][sync:;ordered][arg:b]]

Ungolfed:

[$[l:@b]:
    [r:each]                            # Repeat for each item
    [s:[cmp:[rc];2;[is:different;,]]\s] # Separate by comma if n > 2
    [before:[last:[notfirst:and\s]]]    # Insert "and" before last item
    [sync:;ordered]                     # Force forward order
    [arg:b]                             # Read list
]

Uso:

[$l:{A|B|C|D|E}]

Experimente online

Pyth, 28

j>", "qlQ2+_t_Q+?"and "tQkeQ

Exemplos:

$ pyth programs/oxford.pyth <<< "['1']"
1

$ pyth programs/oxford.pyth <<< "['1','2']"
1 and 2

$ pyth programs/oxford.pyth <<< "['1','2','3']"
1, 2, and 3

PHP - 72

Configure a entrada:

$i=[1,2,3,4,5];

E então o processo:

$x=count($i)-1;if($x) {$i[$x]=" and ".$i[$x];}echo join($x>1?",":"",$i);