(ความท้าทายแรกโปรดแจ้งให้เราทราบหากมีปัญหาใด ๆ กับมัน)

heterogramเป็นคำที่ตัวอักษรไม่เกิดขึ้นมากกว่าหนึ่งครั้งและpalindromeเป็นวลีที่เป็นไปข้างหลังเหมือนกันและไปข้างหน้า

ความท้าทายที่นี่คือการเขียนโค้ดที่ใช้คำ (ตัวอักษร) เป็นอินพุตและแสดงผลว่าเป็น heterogram (ความจริง / เท็จ) หรือไม่ สิ่งที่จับได้คือโปรแกรมจะต้องเป็นแบบ palindrome - อ่านย้อนหลังและไปข้างหน้าเหมือนกัน การใช้อักษรตัวพิมพ์ใหญ่ไม่สำคัญที่นี่ดังนั้นเพื่อให้ heterogram มีความถูกต้องจะต้องไม่มีทั้ง q และ Q ไม่อนุญาตให้มีความคิดเห็นและคุณไม่สามารถวางสตริงที่มีรหัสของคุณ (หรือส่วนสำคัญของรหัสของคุณ) เพื่อพยายามทำให้ส่วน palindrome ง่าย: P

นี่คือรหัส - กอล์ฟดังนั้นรหัสที่สั้นที่สุดจึงชนะ โชคดี!

แก้ไข: Parens วงเล็บหรือสัญลักษณ์อื่น ๆ ที่มีรูปแบบซ้ายและขวาจะต้องกลับรายการที่น่ากลัวสำหรับส่วน palindrome ดังนั้น (helloolleh) คือ palindrome แต่ (helloolleh (ไม่ใช่) เห็นได้ชัดว่านี่เรียกว่า palindrome ที่สะดวก

แก้ไข 2: คุณจะไม่ได้รับการป้อนข้อมูลที่ว่างเปล่าการป้อนข้อมูลด้วยคำหลายคำหรือการป้อนข้อมูลด้วยอักขระอื่นที่ไม่ใช่ตัวอักษร ดังนั้นอย่ากังวลไป :)

Pyth - 11 ไบต์

(ช่องว่างต่อท้ายและนำหน้าจำเป็นและนับ)

 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 ไบต์

 Z.{rzZ.q.Zzr}.Z 

ลองออนไลน์ได้ที่นี่

พื้นที่ชั้นนำเป็นสิ่งที่จำเป็น ฉันได้นับมันและพื้นที่ต่อท้ายในการนับไบต์

นี่คือรายละเอียด:

     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

ปัญหาหลักคือการทำให้ย้อนกลับของรหัสแยกวิเคราะห์ได้ จากนั้นเราสามารถปล่อยให้มันเกิดข้อผิดพลาดจากตัวระบุที่ไม่ได้กำหนด

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 ไบต์

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

ตัวอย่างการใช้งาน:

echo "abcde" | perl -n entry.pl

> <> , 137 131 ไบต์

เมื่อฉันเห็นความท้าทายนี้ฉันคิดว่า> <> ในที่สุดอาจเป็นทางเลือกที่ดีของภาษาเนื่องจากการใช้มันคุณสามารถเพิกเฉยปาลิโมโดรมได้ มันง่ายที่จะตรวจสอบให้แน่ใจว่าตัวชี้อยู่ในตำแหน่งที่ควรเท่านั้น แม้ว่าสิ่งนี้จะเป็นจริง แต่โชคไม่ดีที่ทำให้สภาพการเล่นกอล์ฟทรุดโทรม (หรือเล่นกอล์ฟโดยทั่วไป) ฉันหวังว่าจะใช้กลเม็ดแปลก ๆ ที่ฉันคิดว่าจะชดเชยให้กับสิ่งนี้ แต่นี่เป็นคำตอบที่ "เร็ว" (ไม่ใช่ที่จริงทั้งคำตอบที่ชาญฉลาดของโปรแกรมและการสร้าง) คุณสามารถลองออนไลน์ได้ที่นี่

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

ส่งคืน 1 สำหรับจริงและ -1 สำหรับเท็จ (ฉันสามารถเปลี่ยนเป็น 0 ได้ แต่ความยาวคงอยู่เหมือนเดิมโชคไม่ดี)

และเช่นเคยแจ้งให้เราทราบหากนี่ไม่ได้ผลและหากคุณมีความคิดเกี่ยวกับวิธีการเล่นกอล์ฟ ฉันทดสอบกับกรณีทดสอบบางกรณี แต่อาจมีข้อยกเว้นเสมอ

นี่เป็นอีกเวอร์ชั่นหนึ่งที่ฉันคิดว่าฉลาดกว่านี้อีกเล็กน้อย แต่อนิจจามากกว่าสิบไบต์ ค่า Truthy / falsey ครั้งนี้คือ 1 และข้อผิดพลาด ( 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<

คำอธิบาย:

นี่คือรหัสที่ไม่มีส่วนที่เพิ่มเพื่อให้เป็นแบบ palindrome อันนี้ไม่ได้ใช้กลอุบายที่ "ฉลาดกว่า" ที่ฉันพยายามจะใช้กับรุ่นอื่นดังนั้นจึงเป็นการง่ายกว่าที่จะอธิบาย (ถ้าใครสนใจคำอธิบายสำหรับ "ลูกเล่น" ฉันยินดีที่จะให้ แม้ว่า)

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

บรรทัด 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

นี่คือวิธีการสลับซับซ้อน ( :{:@=?v$) ที่ใช้งานได้ - ฉันจะใช้กรณีทดสอบของสแต็กนี้: [5,1,8,1]โดยที่อักขระตัวสุดท้ายคือด้านบน

:{ด้านบนสุดของสแต็กมีการทำซ้ำ: [5,1,8,1,1]และสแต็กเลื่อนไปทางซ้าย:[1,8,1,1,5]

:@ด้านบนซ้ำกัน: [1,8,1,1,5,5]จากนั้นค่าสามอันดับแรกจะถูกเลื่อนไปทางขวา:[1,8,1,5,1,5]

=?v ไม่จำเป็นสำหรับคำอธิบายในส่วนนี้

$มูลค่าสูงสุดจะถูกสับเปลี่ยนอีกครั้ง[1,8,1,5]ซึ่งหากคุณสังเกตเห็นว่าสแต็กดั้งเดิมเปลี่ยนไปหนึ่งครั้ง (ราวกับว่า{เคยเป็นคำสั่งเดียว)

ดังนั้นสิ่งที่ทำในภาษาอังกฤษ^{("ขอบคุณพระเจ้าเขาอธิบายสิ่งต่าง ๆ จริง ๆ ")}คือตรวจสอบสแต็กทั้งหมดกับค่าสูงสุดและย้ายไปยังจุดในบรรทัดที่สองหากค่าใดมีค่าเท่ากับด้านบน การตรวจสอบนี้ทำตามสัดส่วนของจำนวนที่มีอยู่ในสแต็ก ( l - 1ซึ่งlความยาวของสแต็ก) เพื่อให้ค่าทั้งหมดถูกตรวจสอบซึ่งกันและกัน

บรรทัด 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 ไบต์

คุณต้องเปิดใช้งานโดยปิดshort_tagsคำสั่ง ini เป็น5.4 หรือสูงกว่า

กอล์ฟครั้งแรกเลยทีเดียว สำเนาสองชุดชุดแรกพิมพ์ขยะจำนวนมากด้วยผลลัพธ์ที่ผิด / เป็นจริง:

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

รุ่นนี้จะไม่พิมพ์ศัพท์แสงใด ๆ (162 ไบต์):

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

เรียกใช้จากบรรทัดคำสั่งด้วย

php -f golf.php heterogram

อาจจะสามารถเล่นกอล์ฟได้อีกเล็กน้อย

05AB1E, 9 ไบต์

lDÙQqQÙDl

ลองออนไลน์

* แทรกบางอย่างเกี่ยวกับการเดินทางกลับไปสู่ความท้าทายครั้งแรกของฉัน *

ไม่ใช่การแข่งขันตั้งแต่ 05AB1E เกิดขึ้นหลังจากการท้าทายนี้

คำอธิบาย

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 ไบต์ภาษาโพสต์ความท้าทาย

DdD

ลองออนไลน์!

นี่เป็นหนึ่งในโปรแกรมไม่กี่โปรแกรมที่ใช้ได้ทั้งใน Brachylog 1 และ Brachylog 2 ลิงก์ TIO คือ Brachylog 1 เพื่อเห็นแก่เวลาเก่า ยังไม่เหมาะสำหรับ Brachylog นี่เป็นโปรแกรมเต็มรูปแบบไม่ใช่ฟังก์ชั่น (โปรแกรมเต็มรูปแบบใน Brachylog แสดงผลเป็น booleans ซึ่งเป็นเพียงสิ่งที่เราต้องการสำหรับคำถามนี้)

หลักการทั่วไปในที่นี้คือการวางเพรดิเคตระหว่างคู่ของตัวอักษรตัวพิมพ์ใหญ่ที่เหมือนกันเป็นการยืนยันว่าค่าปัจจุบันนั้นไม่เปลี่ยนแปลงภายใต้เพรดิเคตนั้น ดังนั้นคุณมักจะเห็นสิ่งต่าง ๆ เช่นAoA"เรียงลำดับ" ("ไม่เปลี่ยนแปลงภายใต้การเรียงลำดับ"); A↔Aจะ (ใน Brachylog 2) หมายถึง "is palindrome" ("ค่าคงที่ภายใต้การกลับรายการ") และอื่น ๆ โปรแกรมนี้เป็น "คงที่ภายใต้การลบรายการที่ซ้ำกัน" คือ "ไม่ได้มีรายการที่ซ้ำกัน" มันสะดวกมากที่วิธีการระบุค่า invariance นี้เป็นแบบ palindrome

Brachylogขนาด 3 ไบต์

≠ụ≠

ลองออนไลน์!

เพรดิเคตจะสำเร็จถ้าอินพุตเป็น heterogram และล้มเหลวหากไม่ใช่

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

MATL , 7 ไบต์

tuX=Xut

ลองออนไลน์!

ส่งคืนรายการ [1, 1] ถ้าอินพุตเป็น heterogram และ [0, 0] ถ้าไม่ใช่

คำอธิบาย:

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