(Primer desafío, avíseme si tiene algún problema).

Un heterograma es una palabra donde ninguna letra del alfabeto aparece más de una vez, y un palíndromo es una frase que es igual hacia atrás y hacia adelante.

El desafío aquí es escribir un fragmento de código que tome una palabra (solo letras) como entrada y genere si es o no un heterograma (verdad / falsedad). El problema es que el programa debe ser un palíndromo: lee lo mismo hacia atrás y hacia adelante. La capitalización no importa aquí, por lo que, para que el heterograma sea válido, no puede tener tanto q como Q, por ejemplo. No se permiten comentarios y no puede colocar cadenas que contengan su código (o una parte importante de su código) para intentar facilitar la parte del palíndromo: P

Este es el código de golf, por lo que gana el código más corto. ¡Buena suerte!

EDITAR: Parens, corchetes u otros símbolos que tienen formas izquierda y derecha deben invertirse apropiadamente para la parte del palíndromo. Entonces (helloolleh) es un palíndromo, pero (helloolleh (no lo es. Aparentemente esto se llama un palíndromo conveniente).

EDIT 2: no obtendrá ninguna entrada vacía, entrada con varias palabras o entrada con caracteres que no sean letras. Así que no te preocupes por eso :)

Pyth - 11 bytes

(Espacios finales y principales necesarios y contados).

 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 bytes

 Z.{rzZ.q.Zzr}.Z 

Pruébelo en línea aquí.

El espacio principal es necesario. Lo he contado y el espacio final en el recuento de bytes.

Aquí está el desglose:

     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

Pitón 3, 125

El principal problema es hacer que el reverso del código sea analizable. Entonces podemos dejar que salga de los identificadores indefinidos.

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 bytes

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

Ejemplo de uso:

echo "abcde" | perl -n entry.pl

> <> , 137 131 Bytes

Cuando vi este desafío, pensé que> <> finalmente podría ser una buena opción de lenguaje, ya que al usarlo puedes ignorar los palíndromos; es sencillo asegurarse de que el puntero solo permanezca donde debería. Si bien esto es cierto,> <> desafortunadamente hace que los condicionales de golf sean insoportables (o simplemente el golf en general). Espero usar algunos trucos extraños que pensé para compensar esto, pero aquí hay una respuesta "rápida" (no en realidad, tanto en lo que respecta al programa como a la creación). Puedes probarlo en línea aquí .

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

Devuelve 1 para verdadero y -1 para falso (podría cambiarlo a 0 pero la longitud se mantendría igual, desafortunadamente)

Como siempre, avíseme si esto no funciona y si tiene alguna idea sobre cómo jugar golf. Lo probé en algunos casos de prueba, pero siempre podría haber una excepción.

Aquí hay otra versión, una que creo que es un poco más inteligente, pero lamentablemente es diez bytes más. Los valores de verdad / falsey esta vez son 1 y un error ( 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<

Explicación:

Aquí está el código sin la parte agregada para convertirlo en un palíndromo. Este no usa los trucos "más inteligentes" que intenté usar para la versión alternativa, por lo que es un poco más fácil de explicar (si alguien está interesado en una explicación de los "trucos", me encantaría dar uno , aunque).

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

Línea 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

Así es como funciona el intercambio enrevesado ( :{:@=?v$): utilizaré un caso de prueba de esta pila: [5,1,8,1]donde el último carácter es el superior.

:{La parte superior de la pila se duplica: [5,1,8,1,1]y la pila se desplaza hacia la izquierda:[1,8,1,1,5]

:@La parte superior se duplica: [1,8,1,1,5,5]luego, los tres valores superiores se desplazan a la derecha:[1,8,1,5,1,5]

=?v Innecesario para esta parte de explicación

$El valor superior se intercambia una vez más [1,8,1,5], lo que, si observará, es la pila original desplazada una vez (como si {hubiera sido el único comando).

Entonces, lo que esto hace en inglés ^{("Gracias a Dios, en realidad está explicando las cosas")} es verificar toda la pila con el valor superior y pasar a un punto en la segunda línea si algún valor es igual al superior. Esta comprobación se realiza de forma proporcional a la cantidad de valores que hay en la pila ( l - 1donde lestá la longitud de la pila) para que todos los valores se verifiquen entre sí.

Línea 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 bytes

Debe ejecutar esto con la short_tagsdirectiva ini desactivada en 5.4 o superior.

Primer campo de golf. Dos copias, la primera imprime un montón de basura con el resultado falso / verdadero:

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

Esta versión no imprimirá ninguna jerga (162 bytes):

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

Ejecutar desde la línea de comando con

php -f golf.php heterogram

Probablemente se pueda jugar un poco más.

05AB1E, 9 bytes

lDÙQqQÙDl

Pruébalo en línea.

* inserte algo acerca de regresar a mi primer desafío *

No compitiendo desde 05AB1E se hizo después de este desafío.

Explicación

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 bytes, desafío de fechas posteriores al idioma

DdD

Pruébalo en línea!

Este es uno de los pocos programas que funciona tanto en Brachylog 1 como en Brachylog 2. El enlace TIO es Brachylog 1 por los viejos tiempos. También inusualmente para Brachylog, este es un programa completo, no una función. (Los programas completos en Brachylog generan implícitamente booleanos, que es justo lo que queremos para esta pregunta).

El principio general aquí es que colocar un predicado entre un par de letras mayúsculas idénticas es una afirmación de que el valor actual es invariante bajo ese predicado. Entonces, a menudo se ven cosas como AoA"está ordenado" ("invariante bajo clasificación"); A↔A(en Brachylog 2) significa "es un palíndromo" ("invariante bajo inversión"), y así sucesivamente. Este programa es "invariable al eliminar duplicados", es decir, "no contiene duplicados". Es realmente conveniente que este método para especificar la invariancia sea un palíndromo.

Brachylog , 3 bytes

≠ụ≠

Pruébalo en línea!

El predicado tiene éxito si la entrada es un heterograma y falla si no lo es.

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

MATL , 7 bytes

tuX=Xut

Pruébalo en línea!

Devuelve la lista [1, 1] si la entrada es un heterograma y [0, 0] si no.

Explicación:

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