(Premier défi, faites-le moi savoir s'il y a des problèmes.)

Un hétérogramme est un mot où aucune lettre de l'alphabet n'apparaît plus d'une fois, et un palindrome est une phrase qui est la même en arrière et en avant.

Le défi ici est d'écrire un morceau de code qui prend un mot (juste des lettres) en entrée et qui émet, qu'il s'agisse ou non d'un hétérogramme (véridique / faux). Le hic, c'est que le programme doit être un palindrome - lit le même en arrière et en avant. La capitalisation n'a pas d' importance ici, donc pour que l'hétérogramme soit valide, il ne peut pas avoir à la fois q et Q, par exemple. Aucun commentaire n'est autorisé et vous ne pouvez pas placer de chaînes contenant votre code (ou une partie importante de votre code) pour essayer de rendre la partie palindrome facile: P

C'est le code-golf, donc le code le plus court l'emporte. Bonne chance!

EDIT: Les parens, crochets ou autres symboles qui ont des formes gauche et droite doivent être inversés de manière appropriée pour la partie palindrome. Donc (helloolleh) est un palindrome, mais (helloolleh (ne l'est pas. Apparemment, cela s'appelle un palindrome commode.

EDIT 2: Vous n'obtiendrez aucune entrée vide, entrée avec plusieurs mots ou entrée avec des caractères autres que des lettres. Alors ne vous en faites pas :)

Pyth - 11 octets

(Espaces de fuite et de tête nécessaires et comptés).

 z.{ z }.z 

Suite de tests .

<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 octets

 Z.{rzZ.q.Zzr}.Z 

Essayez-le en ligne ici.

L'espace de tête est nécessaire. Je l'ai compté et l'espace de fin dans le nombre d'octets.

Voici la ventilation:

     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

Le principal problème est de rendre l'inverse du code analysable. Ensuite, nous pouvons laisser sortir l'erreur des identificateurs non définis.

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 octets

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

Exemple d'utilisation:

echo "abcde" | perl -n entry.pl

> <> , 137 131 octets

Quand j'ai vu ce défi, j'ai pensé que <<> pourrait enfin être un bon choix de langue car en l'utilisant, vous pouvez surtout ignorer les palindromes; il est simple de s'assurer que le pointeur ne reste que là où il devrait. Bien que cela soit vrai,> <> rend malheureusement les conditions de golf atroces (ou tout simplement le golf en général). J'espère utiliser des astuces étranges auxquelles j'ai pensé pour compenser cela, mais voici une réponse "rapide" (pas en fait, à la fois au niveau du programme et de la création). Vous pouvez l'essayer en ligne ici .

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

Renvoie 1 pour vrai et -1 pour faux (je pourrais le changer à 0 mais la longueur resterait la même, malheureusement)

Comme toujours, faites-moi savoir si cela ne fonctionne pas et si vous avez des idées sur la façon de jouer au golf. Je l'ai testé par rapport à quelques cas de test, mais il pourrait toujours y avoir une exception.

Voici une autre version, une qui je pense est un peu plus intelligente, mais hélas est de dix octets de plus. Les valeurs Truthy / falsey cette fois sont 1 et une erreur ( 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<

Explication:

Voici le code sans la partie ajoutée pour en faire un palindrome. Celui-ci n'utilise pas les astuces "plus intelligentes" que j'ai essayé d'utiliser pour la version alternative, il est donc un peu plus facile à expliquer (si quelqu'un est intéressé par une explication des "astuces", je serais heureux d'en donner une , bien que).

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

Ligne 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

Voici comment fonctionne le swapping ( :{:@=?v$) alambiqué - je vais utiliser un cas de test de cette pile: [5,1,8,1]où le dernier caractère est le haut.

:{Le haut de la pile est dupliqué:, [5,1,8,1,1]et la pile déplacée vers la gauche:[1,8,1,1,5]

:@Le haut est dupliqué:, [1,8,1,1,5,5]puis les trois premières valeurs sont décalées vers la droite:[1,8,1,5,1,5]

=?v Inutile pour cette partie de l'explication

$La valeur supérieure est inversée une fois de plus [1,8,1,5], ce qui, si vous le remarquez, est la pile d'origine décalée une fois (comme si {c'était la seule commande).

Donc, ce que cela fait en anglais ^{("Dieu merci, il explique en fait les choses")} est de vérifier la pile entière par rapport à la valeur supérieure et de passer à un point dans la deuxième ligne si une valeur est égale au sommet. Cette vérification est effectuée proportionnellement au nombre de valeurs dans la pile ( l - 1, où lest la longueur de la pile) afin que toutes les valeurs soient vérifiées les unes par rapport aux autres.

Ligne 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 octets

Vous devez l'exécuter avec la short_tagsdirective ini désactivée en 5.4 ou supérieur.

Premier golf de tous les temps. Deux exemplaires, le premier imprime tout un tas d'ordures avec le résultat falsifié / véridique:

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

Cette version n'imprimera aucun jargon (162 octets):

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

Exécuter à partir de la ligne de commande avec

php -f golf.php heterogram

Peut probablement être joué un peu plus loin

05AB1E, 9 octets

lDÙQqQÙDl

Essayez-le en ligne.

* insérer quelque chose sur le chemin du retour à mon tout premier défi *

La non-compétition depuis 05AB1E a été faite après ce challenge.

Explication

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 octets, défi de postdates de langue

DdD

Essayez-le en ligne!

C'est l'un des très rares programmes qui fonctionne à la fois dans Brachylog 1 et Brachylog 2. Le lien TIO est vers Brachylog 1 pour le bon vieux temps. Également inhabituel pour Brachylog, c'est un programme complet, pas une fonction. (Les programmes complets dans Brachylog produisent implicitement des booléens, ce qui est exactement ce que nous voulons pour cette question.)

Le principe général ici est que placer un prédicat entre une paire de lettres majuscules identiques est une affirmation que la valeur actuelle est invariante sous ce prédicat. Ainsi, vous voyez souvent des choses comme AoApour "est trié" ("invariant sous tri"); A↔Asignifierait (dans Brachylog 2) "est un palindrome" ("invariant sous inversion"), et ainsi de suite. Ce programme est "invariant lors de la suppression des doublons", c'est-à-dire "ne contient pas de doublons". Il est très pratique que cette méthode de spécification de l'invariance se trouve être un palindrome.

Brachylog , 3 octets

≠ụ≠

Essayez-le en ligne!

Le prédicat réussit si l'entrée est un hétérogramme et échoue s'il ne l'est pas.

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

MATL , 7 octets

tuX=Xut

Essayez-le en ligne!

Renvoie la liste [1, 1] si l'entrée est un hétérogramme et [0, 0] sinon.

Explication:

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