code-golf - primaria - frases anagramas
Código golf: encontrar todos los anagramas. (8)
Perl, 59 caracteres
chop,$_{join'''',sort split//,lc}.="$_ "for<>;/ ./&&say for%_
Tenga en cuenta que esto requiere Perl 5.10 (para la función say ).
Una palabra es un anagram si las letras de esa palabra se pueden reorganizar para formar una palabra diferente.
Tarea:
- El código fuente más corto por número de caracteres para encontrar todos los conjuntos de anagramas a los que se ha asignado una lista de palabras.
- Los espacios y las nuevas líneas deben contarse como caracteres.
Usa la regla del código.
--------- 10 -------- 20 -------- 30 -------- 40 -------- 50 ---- ---- 60 -------- 70 -------- 80 -------- 90 -------- 100 ------- 110- ------ 120
Entrada:
una lista de palabras de stdin con cada palabra separada por una nueva línea.
p.ej
A
A''s
AOL
AOL''s
Aachen
Aachen''s
Aaliyah
Aaliyah''s
Aaron
Aaron''s
Abbas
Abbasid
Abbasid''s
Salida:
Todos los conjuntos de anagramas, con cada conjunto separado por una línea separada.
Ejecución de ejemplo:
./anagram < words
marcos caroms macros
lump''s plum''s
dewar''s wader''s
postman tampons
dent tend
macho mocha
stoker''s stroke''s
hops posh shop
chasity scythia
...
Tengo una solución de 149 char perl que publicaré tan pronto como algunas personas más publiquen :)
¡Que te diviertas!
EDITAR: aclaraciones
- Supongamos que los anagramas no distinguen entre mayúsculas y minúsculas (es decir, mayúsculas y minúsculas son equivalentes)
- Solo deben imprimirse juegos con más de 1 artículo
- Cada conjunto de anagramas solo se debe imprimir una vez.
- Cada palabra en un conjunto de anagramas solo debe aparecer una vez.
EDIT2: Más aclaraciones
- Si dos palabras difieren solo en el uso de mayúsculas, se deben colapsar en la misma palabra, y depende de usted decidir qué esquema de mayúsculas usar para la palabra contraída
- los conjuntos de palabras solo tienen que terminar en una nueva línea, siempre y cuando cada palabra esté separada de alguna manera, por ejemplo, separados por comas, o el espacio separado sea válido. Entiendo que algunos idiomas tienen métodos de impresión de matriz rápida incorporados, por lo que esto debería permitirle aprovechar eso si no genera matrices separadas por espacio.
Ruby, 94 caracteres
h={};(h[$_.upcase.bytes.sort]||=[])<<$_ while gets&&chomp;h.each{|k,v|puts v.join'' ''if v.at 1}
AWK - 119
{split(toupper($1),a,"");asort(a);s="";for(i=1;a[i];)s=a[i++]s;x[s]=x[s]$1" "}
END{for(i in x)if(x[i]~/ .* /)print x[i]}
AWK no tiene una función de join como Python, o podría haber sido más corta ...
Asume mayúsculas y minúsculas como diferentes.
C ++, 542 caracteres
#include <iostream>
#include <map>
#include <vector>
#include <boost/algorithm/string.hpp>
#define ci const_iterator
int main(){using namespace std;typedef string s;typedef vector<s> vs;vs l;
copy(istream_iterator<s>(cin),istream_iterator<s>(),back_inserter(l));map<s, vs> r;
for (vs::ci i=l.begin(),e=l.end();i!=e;++i){s a=boost::to_lower_copy(*i);
sort(a.begin(),a.end());r[a].push_back(*i);}for (map<s,vs>::ci i=r.begin(),e=r.end();
i!=e;++i)if(i->second.size()>1)*copy(i->second.begin(),i->second.end(),
ostream_iterator<s>(cout," "))="/n";}
Haskell, 147 caracteres
tallas anteriores: 150 159 caracteres
import Char
import List
x=sort.map toLower
g&a=g(x a).x
main=interact$unlines.map unwords.filter((>1).length).groupBy((==)&).sortBy(compare&).lines
Esta versión, a 165 caracteres, satisface las nuevas reglas clarificadas:
import Char
import List
y=map toLower
x=sort.y
g&f=(.f).g.f
w[_]="";w a=show a++"/n"
main=interact$concatMap(w.nubBy((==)&y)).groupBy((==)&x).sortBy(compare&x).lines
Esta versión maneja:
- Las palabras en la entrada que difieren solo por caso deben contar como una sola palabra
- La salida debe ser un conjunto de anagramas por línea, pero la puntuación adicional es aceptable
Potencia Shell, 104 97 91 86 83 caracteres
$k=@{};$input|%{$k["$([char[]]$_|%{$_+0}|sort)"]+=@($_)}
$k.Values|?{$_[1]}|%{"$_"}
Actualización para el nuevo requisito (+8 caracteres):
Para excluir las palabras que solo difieren en el uso de mayúsculas, podríamos simplemente eliminar los duplicados (insensibles a mayúsculas y minúsculas) de la lista de entrada, es decir, $input|sort -u donde -u significa -unique . sort es insensible a mayúsculas por defecto:
$k=@{};$input|sort -u|%{$k["$([char[]]$_|%{$_+0}|sort)"]+=@($_)}
$k.Values|?{$_[1]}|%{"$_"}
Explicación del [char[]]$_|%{$_+0}|sort -part
Es una clave para la entrada de tabla hash en la que se almacenan los anagramas de una palabra. Mi solución inicial fue: $_.ToLower().ToCharArray()|sort . Luego descubrí que no necesitaba ToLower() para la clave, ya que las búsquedas de ToLower() hash no distinguen entre mayúsculas y minúsculas.
[char[]]$_|sort sería ideal, pero la clasificación de los caracteres para la clave debe ser sensible a mayúsculas y minúsculas (de lo contrario, Cab y abc se almacenarán bajo diferentes claves). Desafortunadamente, el sort no es insensible a las mayúsculas y minúsculas para caracteres (solo para cadenas).
Lo que necesitamos es [string[]][char[]]$_|sort , pero encontré una forma más corta de convertir cada char en string, que es concatinar otra cosa, en este caso un entero 0 , por lo tanto [char[]]$_|%{$_+0}|sort . Esto no afecta el orden de clasificación, y la clave real termina siendo algo así como: d0 o0 r0 w0 . No es bonito, pero hace el trabajo :)
Python, 167 caracteres, incluye E / S
import sys
d={}
for l in sys.stdin.readlines():
l=l[:-1]
k=''''.join(sorted(l)).lower()
d[k]=d.pop(k,[])+[l]
for k in d:
if len(d[k])>1: print('' ''.join(d[k]))
Sin el código de entrada (es decir, si asumimos que la lista de palabras ya está en una lista w ), solo tiene 134 caracteres:
d={}
for l in w:
l=l[:-1]
k=''''.join(lower(sorted(l)))
d[k]=d.pop(k,[])+[l]
for k in d:
if len(d[k])>1: print('' ''.join(d[k]))
Python, O (n ^ 2)
import sys;
words=sys.stdin.readlines()
def s(x):return sorted(x.lower());
print ''/n''.join([''''.join([a.replace(''/n'','' '') for a in words if(s(a)==s(w))]) for w in words])