(Erste Herausforderung, lass es mich wissen, wenn es irgendwelche Probleme damit gibt.)

Ein Heterogramm ist ein Wort, bei dem kein Buchstabe des Alphabets mehr als einmal vorkommt, und ein Palindrom ist eine Phrase, die vorwärts und rückwärts gleich ist.

Hier besteht die Herausforderung darin, einen Code zu schreiben, der ein Wort (nur Buchstaben) als Eingabe aufnimmt und ausgibt, ob es ein Heterogramm ist oder nicht (wahr / falsch). Der Haken ist, dass das Programm ein Palindrom sein muss - liest das gleiche vor und zurück. Die Groß- und Kleinschreibung spielt hier keine Rolle. Damit das Heterogramm gültig ist, kann es zum Beispiel nicht sowohl q als auch Q haben. Es sind keine Kommentare zulässig, und Sie können keine Zeichenfolgen platzieren, die Ihren Code (oder einen wesentlichen Teil Ihres Codes) enthalten, um den Palindrom-Teil zu vereinfachen: P

Das ist Code-Golf, also gewinnt der kürzeste Code. Viel Glück!

BEARBEITEN: Parens, Klammern oder andere Symbole mit linker und rechter Form müssen für den Palindrom-Teil entsprechend umgekehrt werden. Also (helloolleh) ist ein Palindrom, aber (helloolleh) ist es nicht. Anscheinend wird dies ein bequemes Palindrom genannt.

BEARBEITEN 2: Sie erhalten keine leere Eingabe, Eingabe mit mehreren Wörtern oder Eingabe mit anderen Zeichen als Buchstaben. Also mach dir keine Sorgen :)

Pyth - 11 Bytes

(Nachgestellte und führende Leerzeichen notwendig und gezählt).

 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 

Probieren Sie es hier online aus.

Der führende Raum ist notwendig. Ich habe es gezählt und das nachfolgende Leerzeichen in der Byteanzahl.

Hier ist die Aufteilung:

     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

Das Hauptproblem besteht darin, die Umkehrung des Codes analysierbar zu machen. Dann können wir Fehler aus undefinierten Bezeichnern herauslassen.

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

Anwendungsbeispiel:

echo "abcde" | perl -n entry.pl

> <> , 137 131 Bytes

Als ich diese Herausforderung sah, dachte ich, dass> <> endlich eine gute Wahl für die Sprache sein könnte, da man mit ihr Palindrome meist ignorieren kann. Es ist einfach sicherzustellen, dass der Zeiger nur dort bleibt, wo er sollte. Obwohl dies zutrifft, macht> <> die Golfbedingungen leider unerträglich (oder nur allgemein). Ich hoffe, dass ich einige seltsame Tricks anwenden kann, um dies zu kompensieren, aber hier ist eine "schnelle" Antwort (nicht wirklich, sowohl in Bezug auf Programme als auch in Bezug auf die Erstellung). Sie können es hier online ausprobieren .

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

Gibt 1 für wahr und -1 für falsch zurück (ich könnte es in 0 ändern, aber die Länge würde leider gleich bleiben)

Lassen Sie mich wie immer wissen, wenn dies nicht funktioniert und Sie Ideen haben, wie Sie Golf spielen können. Ich habe es mit ein paar Testfällen getestet, aber es kann immer eine Ausnahme geben.

Hier ist eine andere Version, von der ich denke, dass sie etwas schlauer ist, aber leider sind es zehn Bytes mehr. Die Wahrheits- / Falschheitswerte sind diesmal 1 und ein Fehler ( 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<

Erläuterung:

Hier ist der Code ohne den Teil, der hinzugefügt wurde, um daraus ein Palindrom zu machen. In diesem Fall werden die "clevereren" Tricks, die ich für die alternative Version verwendet habe, nicht verwendet. Daher ist es etwas einfacher zu erklären (falls jemand Interesse an einer Erklärung für die "Tricks" hat, würde ich gerne einen geben obwohl).

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

Linie 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

So funktioniert das verschlungene Tauschen ( :{:@=?v$) - Ich verwende einen Testfall dieses Stapels: [5,1,8,1]Dabei ist das letzte Zeichen das oberste.

:{Die Oberseite des Stapels wird dupliziert [5,1,8,1,1]und der Stapel nach links verschoben:[1,8,1,1,5]

:@Der obere Bereich wird dupliziert: [1,8,1,1,5,5]Dann werden die oberen drei Werte nach rechts verschoben:[1,8,1,5,1,5]

=?v Unnötig für diesen Teil der Erklärung

$Der oberste Wert wird noch einmal getauscht [1,8,1,5], was, wie Sie sehen werden, bedeutet, dass der ursprüngliche Stapel einmal verschoben wurde (als ob {dies der einzige Befehl gewesen wäre).

Das heißt, auf Englisch ^{("Gott sei Dank, er erklärt die Dinge")} wird der gesamte Stapel mit dem Höchstwert verglichen und zu einem Punkt in der zweiten Zeile verschoben, wenn ein Wert dem Höchstwert entspricht. Diese Überprüfung erfolgt proportional zu der Anzahl der Werte im Stapel ( l - 1wobei ldie Länge des Stapels angegeben ist), sodass alle Werte gegeneinander überprüft werden.

Zeile 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

Sie müssen dies mit dem laufen short_tagsini - Richtlinie einge ab in 5.4 oder höher.

Das erste Golf überhaupt. Zwei Kopien, die erste druckt einen ganzen Haufen Müll mit dem falschen / wahren Ergebnis:

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

Diese Version gibt keinen Jargon (162 Bytes) aus:

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

Führen Sie von der Kommandozeile aus mit

php -f golf.php heterogram

Wahrscheinlich kann man ein bisschen weiter golfen

05AB1E, 9 Bytes

lDÙQqQÙDl

Probieren Sie es online aus.

* Fügen Sie etwas über den gesamten Weg zurück zu meiner ersten Herausforderung *

Nach dieser Herausforderung wurde seit 05AB1E kein Wettbewerb mehr durchgeführt.

Erläuterung

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, Sprachnachstellung

DdD

Probieren Sie es online!

Dies ist eines der wenigen Programme, die sowohl in Brachylog 1 als auch in Brachylog 2 funktionieren. Die TIO-Verknüpfung ist aus alten Gründen mit Brachylog 1 verknüpft. Ebenfalls ungewöhnlich für Brachylog ist dies ein vollständiges Programm, keine Funktion. (Vollständige Programme in Brachylog geben implizit Boolesche Werte aus. Genau das möchten wir für diese Frage.)

Das allgemeine Prinzip hier ist, dass das Platzieren eines Prädikats zwischen einem Paar identischer Großbuchstaben eine Behauptung ist, dass der aktuelle Wert unter diesem Prädikat unveränderlich ist. So sieht man oft Dinge wie AoA"ist sortiert" ("invariant unter Sortieren"); A↔Awürde (in Brachylog 2) bedeuten "ist ein Palindrom" ("invariant unter Umkehrung") und so weiter. Dieses Programm ist "unveränderlich beim Entfernen von Duplikaten", dh "enthält keine Duplikate". Es ist sehr praktisch, dass diese Methode zur Angabe der Invarianz ein Palindrom ist.

Brachylog , 3 Bytes

≠ụ≠

Probieren Sie es online!

Das Prädikat ist erfolgreich, wenn die Eingabe ein Heterogramm ist, und schlägt fehl, wenn dies nicht der Fall ist.

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

MATL , 7 Bytes

tuX=Xut

Probieren Sie es online!

Gibt Liste [1, 1] zurück, wenn die Eingabe ein Heterogramm ist, und [0, 0], wenn nicht.

Erläuterung:

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