(Prima sfida, per favore fatemi sapere se ci sono problemi con esso.)

Un eterogramma è una parola in cui nessuna lettera dell'alfabeto compare più di una volta e un palindromo è una frase che è la stessa avanti e indietro.

La sfida qui è scrivere un pezzo di codice che contenga una parola (solo lettere) come input e che generi o meno un eterogramma (verità / falsità). Il trucco è che il programma deve essere un palindromo - legge lo stesso avanti e indietro. Le maiuscole non contano qui, quindi, per essere valido, l'eterogramma non può avere sia q che Q, per esempio. Non sono consentiti commenti e non è possibile inserire stringhe che contengono il codice (o una parte significativa del codice) per provare a semplificare la parte palindromo: P

Questo è code-golf, quindi vince il codice più corto. In bocca al lupo!

EDIT: parentesi, parentesi o altri simboli che hanno le forme sinistra e destra devono essere invertiti in modo appropriato per la parte del palindromo. Quindi (ciaoolleh) è un palindromo, ma (ciaoolleh (non lo è. Apparentemente questo è chiamato un comodo palindromo.

EDIT 2: Non otterrai alcun input vuoto, input con più parole o input con caratteri diversi dalle lettere. Quindi non preoccuparti :)

Pyth - 11 byte

(Trailing e spazi iniziali necessari e contati).

 z.{ z }.z 

Test Suite .

<space>        Suppress print
 z             Input (for palindromness)
.{             Unique - actually does testing
  z            Input
<space>        Suppress print
  }            In operator
   .z          Cached input list
   <space>     At end of program makes empty tuple

Pyth, 17 byte

 Z.{rzZ.q.Zzr}.Z 

Provalo online qui.

Lo spazio iniziale è necessario. L'ho contato e lo spazio finale nel conteggio byte.

Ecco la ripartizione:

     z            z is initialized to the input
    r Z           Z is initialized to 0, and r(string)0 converts the string to lowercase
  .{              .{ is pyth's builtin uniqueness test
       .q         .q terminates the program
         .Zzr}    This is just the program mirrored
              .Z  . requires a number to immediately follow it
                  If left blank the parser would throw an error
 Z                This is just mirrored from the end
                  The leading space suppresses the automatic printing of this 0
                  The trailing space mirrors the leading space

Python 3, 125

Il problema principale è rendere analizzabile il contrario del codice. Quindi possiamo far uscire l'errore da identificatori indefiniti.

w=[str.lower][0]((input)())
(print)((max)((map)(w.count,w))<2)
(2>((w,tnuoc.w)(pam))(xam))(tnirp)
(()(tupni))[0][rewol.rts]=w

Perl, 43 byte

print+m:^(?!.*(.).*\1|1/*.(.)*.!?)^:m+tnirp

Esempio di utilizzo:

echo "abcde" | perl -n entry.pl

> <> , 137 131 byte

Quando ho visto questa sfida, ho pensato che> <> potesse finalmente essere una buona scelta della lingua poiché usandola puoi principalmente ignorare i palindromi; è semplice assicurarsi che il puntatore rimanga solo dove dovrebbe. Sebbene ciò sia vero,> <> sfortunatamente rende le condizioni del golf lancinanti (o semplicemente il golf in generale). Spero di usare alcuni strani trucchi che ho pensato di compensare per questo, ma ecco una risposta "rapida" (non in realtà, sia dal punto di vista del programma che della creazione). Puoi provarlo online qui .

i:0(?v>:"Z")?vl1-:1(?v&:{:@=?v$&e0.>
  ;n1<^  -*48<   .00~<  ;n-10<01-n;  >~00.   >84*-  ^>1n;
<.0e&$v?=@:}:&v?)1:-1lv?("Z":<v?)0:i

Restituisce 1 per vero e -1 per falso (potrei cambiarlo in 0 ma la lunghezza rimarrebbe la stessa, sfortunatamente)

Come sempre, fatemi sapere se non funziona e se avete idee su come giocarci. L'ho testato su alcuni casi di test, ma potrebbe esserci sempre un'eccezione.

Ecco un'altra versione, una che penso sia un po 'più intelligente, ma purtroppo è di dieci byte in più. I valori di verità / falsità questa volta sono 1 e un errore ( something smells fishy...):

>i:0(?v>:"Z")?vl: 2(?v&{:@$:@=01-*2.
 < ;n1<^  -*48<f6+0.0<
 &1-:1)e*1.1*e(1:-1& 
>0.0+6f>84*-  ^>1n; > 
.2*-10=@:$@:}&v?)2 :lv?("Z":<v?)0:i<

Spiegazione:

Ecco il codice senza la parte aggiunta per renderlo un palindromo. Questo non usa i trucchi "più intelligenti" che ho tentato di utilizzare per la versione alternativa, quindi è un po 'più facile da spiegare (se qualcuno è interessato a una spiegazione per i "trucchi", sarei felice di dartene uno , anche se).

i:0(?v>:"Z")?vl1-:1(?v&:{:@=?v$&e0.>
  ;n1<^  -*48<   .00~<  ;n-10<

Linea 1:

i:0(?v>:"Z")?vl1-:1(?v&:{:@=?v$&e0.>
i:0(?v                                 #Pushes input and directs down if negative
      >:"Z")?v                         #Directs down if input is greater than "Z"
                                       #(reduces lowercase input to uppercase)
              l                        #Pushes length

                                       #Main loop begins
               1-:1(?v                 #Decrements top, and then directs down if less than 1
                      &                #Pushes top of stack onto register (length minus 1)
                       :{              #Duplicates top, shifts stack to the left
                         :@            #Duplicates top, shifts top three values of the stack to the right

                           =?v         #If top two values are equal, directs down
                              $        #Swaps top two values of the stack
                               &       #Pushes register onto stack
                                e0.    #Jumps back to the "1" after "?vl"
                                       #Main loop ends

                                   >   #Makes sure when the pointer jumps back to i it goes the right way

Ecco come funziona il contorto swapping ( :{:@=?v$) - Userò un caso di prova di questo stack: [5,1,8,1]dove l'ultimo carattere è il primo.

:{La parte superiore della pila viene duplicata: [5,1,8,1,1]e la pila spostata a sinistra:[1,8,1,1,5]

:@La parte superiore viene duplicata:, [1,8,1,1,5,5]quindi i primi tre valori vengono spostati a destra:[1,8,1,5,1,5]

=?v Non necessario per questa parte della spiegazione

$Il valore più alto viene scambiato ancora una volta cedendo [1,8,1,5], il che, se noterai, è lo stack originale spostato una volta (come se {fosse stato l'unico comando).

Quindi, ciò che fa in inglese ^{("Grazie a Dio, in realtà sta spiegando le cose")} è controllare l'intero stack con il valore più alto e passare a un punto nella seconda riga se un valore è uguale al valore più alto. Questo controllo viene effettuato in modo proporzionale al numero di valori presenti nello stack ( l - 1, dove si ltrova la lunghezza dello stack) in modo che tutti i valori vengano confrontati.

Linea 2:

  ;n1<^  -*48<   .00~<  ;n-10<
   n1<                          #If input is less than 0 (i.e. there is none), print 1
  ;                             #and terminate

             <                  #If redirected because input is greater than "Z"
         -*48                   #Push 32, subtract (reducing lowercase to uppercase, numerically)
      ^                         #And move back to the portion that tests if input 
                                #is uppercase (which it will pass now)

                     <          #If counter is less than 1 (for main loop)
                 .00~           #Pop the counter and jump to the beginning (i)

                             <  #If any two values in the stack are equal
                          -10   #Push -1 (subtract 1 from 0)
                        ;n      #Print and terminate

PHP, 126 byte

È necessario eseguirlo con la short_tagsdirettiva ini disattivata in 5.4 o versioni successive.

Il primo golf di sempre. Due copie, la prima stampa un sacco di immondizia con il risultato di falsità / verità:

<?=var_dump(max(array_count_values(str_split(end($argv))))<2)?><?(2>((((vgra$)dne)tilps_rts)seulav_tnuoc_yarra)xam)pmud_rav=?>

Questa versione non stampa alcun gergo (162 byte):

<?=var_dump(max(array_count_values(str_split(end($argv))))<2);__halt_compiler()?><?()relipmoc_tlah__;(2>((((vgra$)dne)tilps_rts)seulav_tnuoc_yarra)xam)pmud_rav=?>

Esegui dalla riga di comando con

php -f golf.php heterogram

Probabilmente si può giocare a golf un po 'più avanti

05AB1E, 9 byte

lDÙQqQÙDl

Provalo online.

* inserisci qualcosa su come tornare alla mia prima sfida *

Non competitiva dal 05AB1E dopo questa sfida.

Spiegazione

lDÙQqQÙDl
l           Take input and lowercase it.
 DÙ         Duplicate and uniquify.
   Q        Compare the two strings.
    q       Immediately exit.
     QÙDl   The rest of the program is ignored.

Brachylog , 3 byte, sfida postdatati in lingua

DdD

Provalo online!

Questo è uno dei pochissimi programmi che funziona sia in Brachylog 1 che in Brachylog 2. Il collegamento TIO è a Brachylog 1 per amare ai vecchi tempi. Anche insolitamente per Brachylog, questo è un programma completo, non una funzione. (I programmi completi in Brachylog generano implicitamente booleani, che è proprio quello che vogliamo per questa domanda.)

Il principio generale qui è che posizionare un predicato tra una coppia di lettere maiuscole identiche è un'affermazione che il valore corrente è invariante sotto quel predicato. Quindi spesso vedi cose come AoA"è ordinato" ("invariante sotto l'ordinamento"); A↔Asignificherebbe (in Brachylog 2) "è un palindromo" ("invariante sotto inversione"), e così via. Questo programma è "invariante nella rimozione di duplicati", ovvero "non contiene duplicati". È davvero conveniente che questo metodo per specificare l'invarianza sia un palindromo.

Brachylog , 3 byte

≠ụ≠

Provalo online!

Il predicato ha esito positivo se l'input è un eterogramma e in caso contrario non riesce.

≠      The characters of the input are all distinct,
 ụ     and when converted to upper case,
  ≠    are still all distinct.

MATL , 7 byte

tuX=Xut

Provalo online!

Restituisce l'elenco [1, 1] se l'ingresso è un eterogramma e [0, 0] in caso contrario.

Spiegazione:

t       % duplicate the input
u       % remove duplicates from the original
X=      % check the two lists are equal
Xu      % unique rows (does nothing as we now have a boolean)
t       % duplicate the result
        % (implicit) convert to string and display