Trova i Semordnilaps

21

I semordnilap (noti anche come eteropalindromi, semi-palindromi, semi-palindromi, reversogrammi, mynoreteh, anagrammi reversibili, inversioni di parole o anadromi) sono parole che sono anche parole se pronunciate all'indietro. Alcuni esempi sono:

  • Ward <=> Disegna
  • Denim <=> estratto
  • Parti <=> Cinturino

Dato un intero positivo N (tramite argomento di funzione o STDIN), restituisce / genera un elenco di semordnilap da questo elenco di parole inglesi , che hanno esattamente N lettere. La lista delle parole può essere salvato in locale sul computer come richiesto un file di testo: w.txt. Puoi anche ottenere l'elenco dall'URL, ma verrà incluso nel conteggio dei byte.

Regole:

  1. I palindromi non sono semordnilap! Pertanto, le parole "mezzogiorno", "rotore" e "radar" non devono essere incluse nell'elenco.
  2. Solo una delle parole (in una coppia semordnilap) deve essere inclusa nell'elenco. Pertanto, se "cane" è nella lista, "dio" non dovrebbe essere (non importa quale sia incluso).
  3. Se non ci sono semordnilaps, l'output dovrebbe essere una stringa vuota, 0, FALSE o qualcos'altro che indica che non ci sono risultati. La funzione deve funzionare anche se non ci sono risultati.

Questo è il codice golf, quindi vince il codice più breve in byte!

Classifica

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

## Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostra snippet di codice

code-golf 
— Stewie Griffin
fonte
10
— Martin Ender,
5
Il singolare non dovrebbe essere Emordnilape il plurale essere Semordnilap? ;)
— FryAmTheEggman l'
1
"I palindromi non sono semordnilaps!" Caspita, quella frase / pallottola non potrebbe essere più poco chiara, ma ora capisco cosa intendi. Le parole che sono se stesse invertite non sono semordnilap.
— gatto

Risposte:

10

Pyth , 23 (codice 18, 5 STDIN necessari)

J'f&qlTQ&}_TJ>_TTJ

Questa è una soluzione abbastanza semplice.

Jmemorizza l'elenco di parole. Quindi filtriamo l'elenco delle parole ( f J) sulla lunghezza della parola come input ( qlTQ), la parola invertita nell'elenco ( }_TJ) e l'inversione della parola è maggiore della parola ( >_TT). L'ultima condizione garantisceT non sia palindromica e che venga stampata solo una coppia. L'elenco risultante viene stampato.

Il modo in cui funziona Pyth, l'unico modo per aprire un file è ricevere il suo nome su STDIN. Questo è il motivo per cui ho contato 5 byte STDIN,w.txt , nel mio punteggio.

Esempio di esecuzione:

$ pyth -c "J'f&qlTQ&}_TJ>_TTJ" <<< '6
w.txt'
['animal', 'denier', 'diaper', 'drawer', 'pupils', 'recaps', 'redraw', 'sleets', 'snoops', 'sports']
— isaacg
fonte
10

Rubino, 74 byte

f=->n{i=IO.read('w.txt').split
p *i&[f.reverse]if f.size==n while f=i.pop}

Scorre l'elenco rimuovendo gli elementi, evitando così i palindromi e producendo sia "stressati" che "dessert". Utilizzando lo stesso nome di variabile per la funzione e l'iteratore aggira una stranezza della sintassi di Ruby: anche se f=i.popviene valutata in precedenza f.reverse, la linea non analizzerà a meno che non fsignifichi già qualcosa. Potrei anche usare p.

— histocrat
fonte
4

bash 134 157 118 byte

f () { comm -12 <(sort w.txt) <(rev w.txt|sort)|while read w; do ((${#w}==$1))&&[[ $w<$(rev<<<$w) ]]&&echo $w; done; }

Questa non è una voce seria, ma piuttosto in risposta alla risposta Bash di Brian . È così che tendo a pensare a programmare questo tipo di cose in Bash - usando Bash stesso il meno possibile e lasciando che gli strumenti integrati facciano tutto il lavoro.

— Aaron Davies
fonte
Otterrai comunque sia la parola che il suo riflesso dalla comunicazione, potresti semplicemente echeggiare "$ w" e non disturbarti con l'ordinamento e la coda extra. Se lo fai, il risultato dovrebbe già essere ordinato, quindi anche l'ordinamento finale può essere rimosso.
— Orione,
Non seguo Come posso fare la dedupla nel tuo approccio?
— Aaron Davies,
Inoltre, ho completamente dimenticato di rimuovere i palindromi. Fisso.
— Aaron Davies,
Mi dispiace, privazione del sonno ... devi davvero confrontarti con il contrario per mantenerne solo uno, ma non devi preoccuparti dei palindromi e il resto dei miei commenti sono ancora validi. E ora che lo dici, bash ha un operatore di confronto delle stringhe, quindi &&[[ $w > $(rev<<<$w) ]]&& echo $wevita comunque sort|tail -1. Detto questo, penso che puoi anche eliminare l'ordinamento finale e unico, perché rimuove i palindromi e produce solo una delle parole.
— Orione,
Inoltre, un gatto inutile all'inizio: <(sort w.txt)va bene.
— Orione,
4

Python, 126 125 120 byte

N=input()
J=open("w.txt").read().split()
for c in set(J):
 if N==len(c)and c!=c[::-1]and c[::-1]in J:print c;J.remove(c)

Soluzione piuttosto semplice.

— Claudiu
fonte
Sembra essere più breve da definire k=c[::-1]. Inoltre, non potresti chiamare set()solo la seconda volta? Non penso che ci siano ripetizioni nel file?
— FryAmTheEggman,
@FryAmTheEggman: In realtà ci vorrebbero 11 caratteri da assegnare k(9 per definizione più 1 per newline più 1 per spazio), ma salverei solo 10 caratteri (eliminalo [::-1]per 6 ma aggiungo 1 perché allora ho bisogno di uno spazio). A proposito di set, ho bisogno Jdi essere un set perché rimuovo le parole usate da esso per soddisfare la regola del no-dupe
— Claudiu
il passaggio a N==len(c)andsalva uno spazio.
— isaacg,
@isaacg: Ah sì, ty
— Claudiu,
Sei basso e =- dovrebbe esserlo ==.
— isaacg,
3

CJam, 48 47 45 42 38 byte

Poiché l'URL deve essere conteggiato, sto utilizzando lo stesso accorciatore di URL di Optimizer.

"ri.ms/§"gDcN+/{,ea~i=},_Wf%&{_W%>},N*

Fa §parte di ASCII esteso, quindi ogni carattere nel codice può essere codificato in un singolo byte.

Come nel caso di Optimizer, dovrai usare l' interprete Java ed eseguirlo localmente da un file, diciamo semordnilap.cjam, e poi

java -jar cjam-0.6.2.jar semordnilap.cjam <N>

pertanto l'input viene fornito come argomento della riga di comando.

Come funziona (leggermente obsoleto):

"Prepare word list:";
"ri.ms/§"gDcN+/ 
"ri.ms/§"g      "Fetch list from shortened URL.";
          DcN+  "Create \r\n string.";
              / "Split input into lines.";

"Process input:";
{,ea~i=},
{      }, "Filter the list.";
 ,        "Get word length.";
  ea      "Push command-line arguments.";
    ~     "Unwrap array.";
     i    "Convert to integer.";
      =   "Check equality.";

"Find all palindromes and semordnilaps:";
_Wf%&
_     "Duplicate list.";
 Wf%  "Reverse each line.";
    & "Set intersection.";

"Remove duplicates and palindromes:";
{_W%>},N*
{    },   "Filter list.";
 _W%      "Duplicate word, reverse.";
    >     "Check lexicographic order.";
       N* "Join with newlines.";

La stringa risultante viene stampata automaticamente alla fine del programma.

— Martin Ender
fonte
3

Java, 280 218 byte

Rispetto al resto della competizione, non ho assolutamente idea se questo è un buon punteggio.

void a(int n)throws Exception{List<String>l=Files.readAllLines(Paths.get("w.txt"));for(String s:l){String c=new StringBuilder(s).reverse()+"";if(s.length()==n&&c.compareTo(s)>0&&l.contains(c)){System.out.println(s);}}}

Allargato:

void a(int n)throws Exception{
    List<String>l=Files.readAllLines(Paths.get("w.txt"));
    for(String s:l){
        String c=new StringBuilder(s).reverse()+"";
        if(s.length()==n&&c.compareTo(s)>0&&l.contains(c)){
            System.out.println(s);
        }
    }
}

Utilizza compareTo () per ignorare simultaneamente palindromi e duplicati.

— Maniaco Stretch
fonte
2
Java soffierà sempre in una gara di golf.
— Rodolfo Dias,
Non l'ho mai visto Files.readAllLines(Paths.get("w.txt"))prima È un trucco utile.
— Ypnypn,
2

CJam, 68 byte

"www.ri.ms/§"gDc-N/{_,ea~~=\_W%=!*},:Q{_W%aQ\/,({Q\a-:Q;1}{;0}?},N*

Dovrai scaricare la versione Java del compilatore da qui e salvare il codice sopra in un file chiamato words.cjam (può essere qualsiasi nome). Quindi eseguire il codice come

java -jar cjam-0.6.2.jar <file_name> <input_number> [> <output_file_name>]

Ad esempio, per N = 8,

java -jar cjam-0.6.2.jar words.cjam 8 > out.txt
— Optimizer
fonte
Java: non è un acronimo. Per favore, non scriverlo JAVA.
— FUZxxl,
@FUZxxl questo è auto-modificabile ..
— Ottimizzatore
Non sono un ufficiale di polizia. Le persone hanno opinioni diverse sull'ortografia e rispetto la tua opinione. Ti consiglio semplicemente di non scrivere Java come se fosse un acronimo, non voglio forzare un altro incantesimo su di te.
— FUZxxl,
@FUZxxl Davvero non metà: D
— Ottimizzatore
2

Node.js, 172 byte

Funzione:

function d(n){return(require('fs').readFileSync("w.txt")+"").match(RegExp(("b"+Array(n+1).join("(.)")+"b(?=(.|s)*b"+"87654321".substr(-n)+"b)").replace(/\w/g,"\\$&"),"g"))}

test:

console.log(d(+process.argv[2]));
// run from command line like this:
// node main 4
// where
//   main is js file name
//   4    is length
— Qwertiy
fonte
2

K, 59 byte

{*+?{x@<x}'+(w;r)@\:&(x=#:'w)&(~w~'r)&w in r:|:'w:0:`w.txt}

Abbastanza diretto. Leggi l'elenco, costruisci l'elenco inverso, prendi la loro intersezione, filtra i palindromi, filtra nel conteggio richiesto, ordina e deduplica le coppie.

— Aaron Davies
fonte
2

Rubino, 95 byte

f=->n{l=[]
(a=IO.read"w.txt").split.map{|w|a[w]=?.
w.size==n&&a[/^#{r=w.reverse}\s$/]&&l<<w}
l}

Spiegazione

  • L'input viene preso come argomento per un lambda. Si aspetta unInteger .
  • Leggi il file in memoria come String( a).
  • Passa attraverso una Arraydi tutte le parole (senza nuove righe).
    • Rimuovi la parola da a.
    • Aggiungi parole qualificanti al Array l.
  • Ritorno l.

Viene Arrayrestituito un vuoto quando non sono state trovate parole qualificanti.

— britishtea
fonte
1

Node.js, CoffeeScript, 132 byte

f=(n)->(require('fs').readFileSync('w.txt')+'').split('\n').filter((s,i,f)->s.length==n&&f.indexOf(s.split('').reverse().join(''))>i)

Node.js, 162 byte

function a(n){return(require('fs').readFileSync('w.txt')+'').split('\n').filter(function(s,i,f){return s.length==n&&f.indexOf(s.split('').reverse().join(''))>i})}

Chrome Dev Tools Console, 111 byte (nella pagina di download)

f=(n=>$('pre').innerText.split('\n').filter((x,i,a)=>x.length==n&&a.indexOf(x.split('').reverse().join(''))>i))

Tutte le versioni restituiscono un array di tutti i Semordnilaps di lunghezza n.

Node.js, 162 byte

Stampa tutti i semordnilaps:

function a(n){(require('fs').readFileSync('w.txt')+'').split('\n').map(function(s,i,f){s.length==n&&f.indexOf(s.split('').reverse().join(''))>i&&console.log(s)})}
— CPU1
fonte
1

Julia, 101 byte

k=split(readall("w.txt"))
for(i=k)
([]!=(l=find(x->x==reverse(i)&&x!=i,k)))&&(println(i);k[l]="")
end

Questo dovrebbe effettivamente funzionare ...

— eaglgenes101
fonte
1

Mathematica, 105 byte

F[f_,n_]:=(W=StringSplit@Import@f;Select[W,StringLength@#==n&&MemberQ[W,r@#]&&Order[r@#,#]==1&&r@#!=# &])

A volte, l'importazione suddivide automaticamente il testo in un elenco di linee o lo tratta come CSV o TSV. Altre volte, Import leggerà il contenuto del file in una stringa. L'importazione ha fatto quest'ultimo per i dati di test.

test

— Ming-Tang
fonte
0

BASH

f() {
  w=($(cat "${1}"))
  for ((i=0;i<=${#w[@]};i++)); do
    if ((${#w[$i]} == $2)); then
      r=
      for((x=${#w[$i]}-1;x>=0;x--)); do
        r="$r${w[$i]:$x:1}";
      done
      if [[ ${w[$i]} != ${r} ]] && grep -qw $r "${1}"; then
        echo "${w[$i]}, ${r}"
      fi
      unset w[$i]
    fi
  done
}

test ...

f /usr/share/dict/words 5

debut, tubed
decaf, faced
decal, laced
deeps, speed
denim, mined
devil, lived
draws, sward
faced, decaf
keels, sleek
knits, stink
laced, decal
lager, regal
leper, repel
lever, revel
lived, devil
loops, spool
loots, stool
mined, denim
parts, strap
peels, sleep
pools, sloop
ports, strop
rebut, tuber
regal, lager
remit, timer
repel, leper
revel, lever
sleek, keels
sleep, peels
sloop, pools
smart, trams
snaps, spans
snips, spins
spans, snaps
speed, deeps
spins, snips
spool, loops
spots, stops
sprat, tarps
stink, knits
stool, loots
stops, spots
strap, parts
straw, warts
strop, ports
sward, draws
tarps, sprat
timer, remit
trams, smart
— Brian
fonte
2
Immagino che questo non sia molto giocoso ..? Questa sarebbe una bella risposta su Stack Overflow (se avesse qualche commento e spiegazione).
— Stewie Griffin,
1
D'accordo, questa è stata la mia prima iterazione nel risolvere questo problema in bash. Mi sono stancato di renderlo il più leggibile possibile. ma per quanto riguarda il golf. è più come se avessi sparato un 9 alla pari di 3: -)
— Brian
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.