(Primeiro desafio, informe-me se houver algum problema.)

Um heterograma é uma palavra em que nenhuma letra do alfabeto ocorre mais de uma vez e um palíndromo é uma frase que é a mesma para trás e para a frente.

O desafio aqui é escrever um pedaço de código que considere uma palavra (apenas letras) como entrada e produza se é ou não um heterograma (verdade / falsidade). O problema é que o programa deve ser um palíndromo - lê o mesmo para trás e para a frente. A capitalização não importa aqui, portanto, para o heterograma ser válido, ele não pode ter q e Q, por exemplo. Nenhum comentário é permitido e você não pode colocar seqüências que contenham seu código (ou uma parte significativa do seu código) para tentar facilitar a parte do palíndromo: P

Isso é código-golfe, então o código mais curto vence. Boa sorte!

EDIT: Parens, colchetes ou outros símbolos que tenham formas esquerda e direita devem ser revertidos adequadamente para a parte do palíndromo. Então (helloolleh) é um palíndromo, mas (helloolleh (não é. Aparentemente, isso é chamado de palíndromo conveniente).

EDIT 2: Você não receberá nenhuma entrada vazia, entrada com várias palavras ou entrada com caracteres que não sejam letras. Então não se preocupe com isso :)

Pitão - 11 bytes

(Espaços à direita e à esquerda necessários e contados).

 z.{ z }.z 

Conjunto de Teste .

<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

Pitão, 17 bytes

 Z.{rzZ.q.Zzr}.Z 

Experimente online aqui.

O espaço principal é necessário. Eu contei isso e o espaço à direita na contagem de bytes.

Aqui está o detalhamento:

     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

O principal problema é tornar o inverso do código analisável. Em seguida, podemos deixar erros de 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

Exemplo de uso:

echo "abcde" | perl -n entry.pl

> <> , 137 131 Bytes

Quando vi esse desafio, pensei que> <> finalmente seria uma boa escolha de linguagem, pois, ao usá-lo, você pode ignorar palíndromos; é simples garantir que o ponteiro permaneça apenas onde deveria. Embora isso seja verdade,> <> infelizmente torna as condições do golfe excruciantes (ou apenas o golfe em geral). Espero usar alguns truques estranhos que pensei em compensar isso, mas aqui está uma resposta "rápida" (na verdade não, tanto em termos de programa quanto de criação). Você pode experimentá-lo online aqui .

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

Retorna 1 para true e -1 para false (eu poderia alterá-lo para 0, mas o comprimento permaneceria o mesmo, infelizmente)

Como sempre, deixe-me saber se isso não funciona e se você tem alguma idéia de como jogar golfe. Eu testei em alguns casos de teste, mas sempre poderia haver uma exceção.

Aqui está outra versão, que eu acho que é um pouco mais inteligente, mas, infelizmente, são dez bytes a mais. Os valores de Truthy / Falsey neste momento são 1 e um erro ( 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<

Explicação:

Aqui está o código sem a parte adicionada para torná-lo um palíndromo. Este não usa os truques "mais inteligentes" que tentei usar para a versão alternativa, por isso é um pouco mais fácil de explicar (se alguém estiver interessado em uma explicação para os "truques", ficaria feliz em dar um , Apesar).

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

Linha 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

Aqui está como a troca complicada ( :{:@=?v$) funciona - usarei um caso de teste dessa pilha: [5,1,8,1]onde o último caractere é o topo.

:{A parte superior da pilha é duplicada: [5,1,8,1,1]e a pilha deslocada para a esquerda:[1,8,1,1,5]

:@A parte superior é duplicada:; em [1,8,1,1,5,5]seguida, os três principais valores são deslocados para a direita:[1,8,1,5,1,5]

=?v Desnecessário para esta parte da explicação

$O valor superior é trocado mais uma vez [1,8,1,5], o que, se você notar, é a pilha original deslocada mais uma vez (como se {tivesse sido o único comando).

Então, o que isso faz em inglês ^{("Graças a Deus, ele está realmente explicando as coisas")} é verificar a pilha inteira em relação ao valor superior e passar para um ponto na segunda linha, se algum valor for igual ao topo. Essa verificação é feita proporcionalmente a quantos valores existem na pilha ( l - 1, onde lestá o comprimento da pilha), para que todos os valores sejam verificados um contra o outro.

Linha 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

Você precisa executar isso com a short_tagsdiretiva ini desativada na 5.4 ou superior.

Primeiro golfe de todos os tempos. Duas cópias, a primeira imprime um monte de lixo com o resultado falso / verdadeiro:

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

Esta versão não imprime nenhum jargão (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=?>

Execute a partir da linha de comandos com

php -f golf.php heterogram

Provavelmente pode ser jogado um pouco mais longe

05AB1E, 9 bytes

lDÙQqQÙDl

Experimente online.

* insira algo sobre voltar ao meu primeiro desafio *

Não competir desde 05AB1E foi feito após esse desafio.

Explicação

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, desafio de pós-datas de idiomas

DdD

Experimente online!

Este é um dos poucos programas que funciona no Brachylog 1 e no Brachylog 2. O link do TIO é para o Brachylog 1 pelos velhos tempos. Também não usual para o Brachylog, este é um programa completo, não uma função. (Os programas completos no Brachylog emitem implicitamente booleanos, que é exatamente o que queremos para esta pergunta.)

O princípio geral aqui é que colocar um predicado entre um par de letras maiúsculas idênticas é uma afirmação de que o valor atual é invariável nesse predicado. Então você costuma ver coisas como AoA"é classificado" ("invariante sob classificação"); A↔Asignificaria (em Brachylog 2) significaria "é um palíndromo" ("invariante sob reversão") e assim por diante. Este programa é "invariável ao remover duplicatas", ou seja, "não contém duplicatas". É realmente conveniente que esse método de especificar invariância seja um palíndromo.

Braquilog , 3 bytes

≠ụ≠

Experimente online!

O predicado será bem-sucedido se a entrada for um heterograma e falhará se não for.

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

MATL , 7 bytes

tuX=Xut

Experimente online!

Retorna a lista [1, 1] se a entrada for um heterograma e [0, 0] se não.

Explicação:

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