Görevin basittir: Girdi olarak bir tamsayı alan ve tuhafsa çıktısını çıkaran bir program yazın ve başka bir şey yapmaz (durmasına izin verilmez). Buradaki zorluk, sadece tek baytları kullanabilmenizdir.

İsteğe bağlı olarak çıktıya izleyen bir yeni satır ekleyebilirsiniz.

Bu kod-golf, (tek) bayt cinsinden en kısa cevabı kazanır.

Standart boşluklar yasaktır. Ayrıca, bu görevin gönderilmesinden daha yeni olan dil sürümlerini kullanamazsınız.

Örnek giriş> çıkış:

13 > 13

42 >

Japt -f , 1 bayt

u

uchar-code değerine sahip 117.

Dene

Yüksek oranlarda konuşma , 645529908926937253684695788965635909332404360034079 9394157991500940492270727190763049448735 1174269748937617561533841898064735499551 2293382937520069758100171520285996319 bayt

Bu kabaca 2 duodecillion byte'a eşittir.

Dosya aşağıdaki brainfuck programına çevrilir:

,[<<+>+>-]<[>>+<<-]+>>[-[->]<]<[<[<]>.<]

Girdiyi, maksimum 256 değeri olan bir ASCII kodu olarak alır.

x86-64 Makine Kodu, 8 bayt

Esinlenerek Bruce Forte çözümü , ama biraz par altında. :-)

8D 07          lea      eax, [rdi]    ; put copy of input parameter in EAX
D1 EF          shr      edi, 1        ; shift LSB into CF
             InfiniteLoop:
F3 73 FD       rep jnc  InfiniteLoop  ; test CF; infinite loop back here if input was even
C3             ret                    ; return with original input in EAX if it was odd

EDISystem V AMD64 çağrı kuralını izleyerek kayıt defterinde tek bir tamsayı parametresi alınır .

Bu değerin bir kopyası başlangıçta yapılır ve EAXuygunsa geri döndürülebilmesi için koyar . ( LEAnormal yerine kullanılır, MOVçünkü tek baytlık bir talimat gerekir.)

Daha sonra, içinde EDIkayma bitini taşıma bayrağına (CF) yerleştiren 1 değeri sağa kaydırılır. Sayı bitse bu bit 0, çift ise 1 olur.

Daha sonra CF'yi JNCsadece CF 0 ise dallanacak olan komutu kullanarak test ediyoruz (yani sayı çiftdi). Bu, eşit değerler için sonsuz bir döngüye gireceğimiz anlamına gelir. Tek değerler için düşüp orijinal değer (in EAX) döndürülür.

Yine de JNCtalimat ile ilgili bir püf noktası var - bir REPön eki var! Normal olarak, REPönekler yalnızca dize yönergeleriyle kullanılır, ancak Intel ve AMD kılavuzlarının her ikisi de alakasız / gereksiz / gereksiz REPöneklerin göz ardı edilmesine karar verdiklerinden, 3 bayt uzunluğunu almak için buradaki dal komutunu atıyoruz. Bu şekilde, atlama komutunda kodlanan göreceli sapma da gariptir. (Ve tabii ki, REPgarip bir bayt önekidir.)

Çok şükür RETgarip bir bayt kullanarak kodlanmış!

Çevrimiçi deneyin!

Tuhafsa değeri döndürmeyi ya da eşit olmasa bile sonsuz bir döngüye girmeyi düşünmüyorsanız, (asla geri dönmemek için) zorluğun "çıktısı" gereksinimlerini karşılar veya daha ilginç bir şey istiyorsanız, işte size bir işlev bu değeri bir seri porta verir (ancak eğer tek ise elbette).

x86-64 Makine Kodu (seri bağlantı noktasına çıkış), 17 bayt

8D 07         lea   eax, [rdi]   ; put copy of input parameter (EDI) in EAX

B1 F7         mov   cl, 0xf7     ; put 0xF7 into low-order bits of CX
B5 03         mov   ch, 0x03     ; put 0x03 into high-order bits of CX
FE C1         inc   cl           ; increment low-order bits of CX to 0xF8 (so all together it's now 0x3F8)
0F B7 D1      movzx edx, cx      ; move CX to DX ("MOV DX, CX" would have a 16-bit prefix of 0x66)

D1 EF         shr   edi, 1       ; shift LSB of input parameter into CF
73 01         jnc   IsEven       ; test CF: branch if 0 (even), fall through if 1 (odd)
EF            out   dx, eax      ; output EAX (original input) to I/O port 0x3F8 (in DX)
            IsEven:
C3            ret                ; return

Bunu biraz daha ilginç hale getiren şey, kodun daha fazlasını yapmasıdır, yani sadece tek baytlar kullanılarak kodlanmış komutları kullanarak hepsini yapmak daha zordur. Tabii ki, bu aynı zamanda kod golfünde başarısız olduğu anlamına gelir, bu yüzden bir tür tradeoff - ilginç ve zorlu mu istiyorsun yoksa kısa mı istiyorsun?

Neyse, bu bir PC'deki standart COM1 seri portu olan G / Ç portu 0x3F8'e yazmak için x86 OUTkomutunu kullanır . Tabii ki eğlence kısmı, tüm standart I / O portlarının (seri ve paralel) eşit adreslere sahip olmalarıdır, bu nedenle komut için doğrudan giriş yaptıkları gibi kodlanamazlar veya doğrudan bir kayıt cihazına taşınamazlar. Gerçek değerden küçük bir değerle başlatmanız ve ardından kayıttaki değeri arttırmanız gerekir. Ayrıca, manipülasyon için belirli kayıtları kullanmakla da sınırlısınız çünkü işlenenler olarak kullanıldığında komuttaki tek baytları kullanarak kodlanmış kayıtlara ihtiyacınız var.OUT

Ayrıca, komutun bir tuhaf kaymaya sahip olmasını sağlamak için gerekli olsa bile, gerekli olsa bile, döngünün tepesinde yazmacıyı ( DXyazmacı aracılığıyla CX) başlatmam gerekiyordu JNC. Bununla birlikte, atladığımız şey OUTtalimat olduğu için , bu kodun yaptığı tek şey atık döngüleri ve clobber çizik kayıtları; öyle değil aslında does çıktı o kaideyi bozmaz bu yüzden, herhangi bir şey.

Son olarak, bu işlev (girişini seri porta yaptıktan sonra veya yaptıktan sonra) giriş değeri bırakıldığında geri dönecektir EAX. Fakat bu aslında herhangi bir kuralı ihlal etmiyor; Assembly dilinde tüm fonksiyonlar bir değerle döner EAX- soru sadece önemli bir değer veya bir çöp değerdir. Bu, işlevin belgelerine göre belirlenir (temelde bir değer döndürür mü veya geri döndürür void) ve bu durumda onu bir değer döndürmediğini belgeliyorum. :-)

Seri portlara çıkış uygulamadığı için bunun için TIO bağlantısı yok. Gerçek demire veya hayal gücüne ihtiyacınız olacak.

Jöle , 2 bayt

ẋḂ

Bu karakterler bayt karşılık 0xF7 ve 0xBF içinde Jelly kod sayfası .

Çevrimiçi deneyin!

05AB1E , 3 bayt

Éi=

Kod, bayt değerlerine karşılık gelir C9,69,3Dveya 201,105,61hepsi gariptir.

Çevrimiçi deneyin!

açıklama

É     # input % 2 == 1
 i    # if true
  =   # print without popping

MATL , 3 bayt

o?G

Matl ASCII karakterler, bu nedenle kullanır o?G(ondalık) bayt karşılık gelir 111, 63, 71.

Çevrimiçi deneyin!

açıklama

o     % Push (implicit) input modulo 2
?     % If nonzero
  G   %   Push input
      % End (implicit)
      % Display stack contents (implicit)

Haskell , 36 33 bayt

c[1]=1;c[m]=1+1+c[m-1-1];o	m=c[m]

Çevrimiçi deneyin!

Kullanımı: o 7yiedls 7, o 8sonsuz bir döngüye girer.

Gerçek algoritma

o 1 = 1
o m = 2 + o(m-2)

Karşılaştığım ilk sorun, boşluk eksikliği ve argüman alan (bir işlev genellikle veya olarak tanımlandı çünkü . Ancak, bir satır içi yorumun da belirteç sınırlayıcı olarak çalıştığını öğrendim , bu nedenle verilen kurallar altında bir tanımlamanın mümkün olduğunu gördüm . Düzenleme: Ørjan Johansen, birinin boşluk yerine sekme karakteri kullanabileceğini, üç bayttan tasarruf ettiğini belirtti:omo m=...o(m)=...{- some comment -}o{--}m=... o m=...

İkinci sorun özyinelemeli çağrı oldu o(m-2). -2sadece -1-1, ama burada parantez gerekli çünkü yorum püf noktası çalışmıyor. Ben bir sayı içeren bir tekil listede fonksiyon çalışmalarını sağlayarak bu sabit: o[m-2]Bu girdi sağlayan standart bir yolu olmadığı için, ancak, ben bir yardımcı işlevine hesaplama dış kaynaklı clisteleri ve çağrı üzerine çalışan cden ohangi doğru biçimi vardır .

Python REPL, 38 bayt

Kullanarak girişini önceki ifadenin değeri olarak alır _. Çıktı bir dize (tekli tamsayıdaki dize gösterimi veya çift için boş dize) olacaktır.

'%s'%[['']+[_]][-1][[_%[1+1][-1]][-1]]

Çevrimiçi deneyin

Gerçek bir kabukta çalıştırmak için burada deneyebilirsiniz . Girişi yazın, enter tuşuna basın. Kodu yapıştırın, enter tuşuna basın.

Açıklama:

Bu anlamaya biraz zaman aldı. Çarpma yok, dallanma yok, dilimleme yok, virgül yok, nokta yok, ithalat yok exec, parantez yok , hayır eval, hayır print, hayır ve işlev yok. Stderr kullanarak bu çıktıyı çalıştıran bir çözüm buldum, ama sonra gerçek bir tamsayıyı çıktıracağımızı fark ettim, sadece bir truthy / falsey değeri değil.

Parantez yerine parantez kullanın [expression][-1]. Basitleştirmek yukarıdaki kodu içine çevirir '%s'%(['']+[_])[_%(1+1)].

Virgül olamayacağından, oluşturmak için liste ekleme kullandım ['',_]. String formatlama kullanılarak istenen sonuç elde edilir.

CJam, 6 bayt

q_iY%%

113 95 105 89 37 37

Bu program (çağıracağı giriş mod 2 sürer r ) ve her yazdırır r ^ giriş dizesinde inci karakter. Girilen sayı tuhafsa dizenin tamamını yazdırır, ancak her 0ncı karakteri yazdırması istenirse program bir hata verir.

Burada dene

Cubix , 23 19 17 bayt

;;u!I1)%/;O=!;;/;

Dene!

@Bir Cubix programını sonlandıran ascii 64'tür, bu yüzden ne yazık ki bu sadece tuhaflık testinden sonra sonsuz bir döngüye girer. Zaman aşımına uğradığından beri TIO bağlantısı yok.

= (ascii 61), Cubix'de bir opop değil.

Bu aslında negatif tamsayılar için çalışan önceki algoritmanın (aynı byte sayısı) küçük bir modifikasyonudur.

Küp sürümü:

    ; ;
    u !
I 1 ) % / ; O =
! ; ; / ; . . .
    . .
    . .

Algoritma:

• I (73) : girilen sayı olarak okunur
• 1 (49) : 1 itin
• ) (41) : artış
• % (37) : mod almak
• / (47) : Sola çevirin
• ! (33) : eğer tek ise bir sonraki komutu atla
  • 1;;/; ;is (59): Yığını çıktı için hazırlar.
  • O (79) : Sayı olarak çıktı.
  • Ardından algoritmaya tekrar girer, ancak girdi sonu için Ibir okur 0, bu yüzden çift dalına gireceğimiz garanti edilir.
• u (117) : sağa dönüş
• ;;;!I : döngü, etkili bir şey yapmadan.

Kömür , 9 bayt

¿﹪Ｉθ÷χ⁵→θ

Çevrimiçi deneyin!

Temel olarak 10/5 katı değilse giriş sağa doğru yazdırılır ( ²karakter Kömür kodu sayfasında bile bulunur ). Kullanılan karakterler:

• ¿: kod BF.
• ﹪: kod A5.
• Ｉ: kod C9.
• θ: kod F1.
• ÷: kod AF.
• χ: kod E3.
• ⁵: kod B5.
• →: kod 13.

Aslında, →sonun sonu gereksiz ama sonra cevabın tek bir uzunluğu olması gerektiğini gördüm.

Açıklama:

¿      if (
 ﹪      Modulo (
  Ｉθ      the input as number,
  ÷χ⁵      χ (predefined value: 10) divided by 5 = 2 ) [is 1])
 →θ      then print rightwards the input as string

x86_64 makine kodu (Linux), 12 11 bayt

Ne yazık ki 0x80bile, ama yine de işe yaradı ("hiçbir şey yapmadığını varsayarsak" geri dönmemek anlamına gelir):

0000000000000000 <odd>:
   0:   8d 07                   lea  (%rdi), %eax
   2:   83 e7 01                and    $0x1, %edi
   5:   83 ff 01                cmp    $0x1, %edi
   8:   75 fb                   jne       5  <odd+0x5>
   a:   c3                      retq

-1 bayt, teşekkürler @CodyGray!

Çevrimiçi deneyin!

Mathematica, 20 bayt

Golf dışı dilde ilk çözüm olarak görünün.

a=1+1;g[i_/;!a\[Divides]i]=i

Olarak MacintoshChineseTraditionalkarakter kodlayan. \[Divides]bir {161, 253}(2 byte)

Alternatif sürüm (23 bayt)

\[CapitalAlpha]=1+1;\[CapitalGamma][\[CapitalChi]_/;\[CapitalAlpha]\[LeftFloor]\[CapitalChi]/\[CapitalAlpha]\[RightFloor]\[NotEqual]\[CapitalChi]]=\[CapitalChi]

veya (Unicode'da gösterilir)

Α=1+1;Γ[Χ_/;Α⌊Χ/Α⌋≠Χ]=Χ

içinde Symbolkarakter kodlayan. (yalnızca 1 bayt karakter kullanın)

Solüsyon bir işlevi tanımlar g(veya Γgiriş "hiçbir şey" anlamıyla garip ve ne zaman girdi bile olduğunda (değerlendirmek değil), girişe değerlendirmeniz).

Perl, 54 bayt

Gerektirir -E.

Gerçekten bu zorluğun tadını çıkardım, sanırım bu cevabı denemek ve iyileştirmek isterdim, ancak bunun şu ana kadar yapabileceğim en kısa şey olabileceğini düşünüyorum. Birkaç gündür bu cevaplar ile açık ve kapalı oynuyorum, ancak 54 baytlık çözümden memnun olduğumu hissediyorum!

s//A_=Y[;A_=A_%O?A_W''/;y/#A-_/#-A/;s/[#-}]+/uc/ee;say

Çevrimiçi deneyin!

açıklama

Varsayılan olarak, Perl'in dizge işlevlerinin çoğu, $_başlamak için boş olan üzerinde çalışır .

İlk s//A_=Y[;A_=A_%O?A_W''/önce boş dizgeyi $_ile değiştirir A_=Y[;A_=A_%O?A_W'', ardından y/#A-_/#-A/aşağıdaki listeye göre karakterleri değiştirir (yukarıdaki karakter aşağıda karakter haline gelir):

#ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
#$%&'()*+,-./0123456789:;<=>?@A

hangi güncellemeleri $_içermesi gerektiği $_=<>;$_=$_%2?$_:''. Daha sonra s/[#-}]+/uc/eetüm karakterleri [#-}]+ile değiştirir uc. Olmadan /eebu sadece dize olurdu uc, ama /eeiki kez dize içeriğini değerlendirir. İlk değerlendirme sonucunu döndürür ucbir büyük harfli sürümüdür, $_ancak o zamandan beri $_hiçbir alfabetik karakterler içeriyor, bu sadece tüm dizeyi, sonra ikinci döner /e, dize tekrar değerlendirir hangi setleri $_birine $_(giriş numarası) ya ''olsun veya bağlı sayı tek veya çift değil.

Son olarak, $_şimdi ne istediğimizi içerdiğinden, onu yeni bir satır izleyen baskıları (bunun yerine sayneyin gerekli -Eolduğunu -e) çağırıyoruz $_.

Alternatif Perl, 93 bayt

Bunun için -prekabet etmeyeceğini düşündüğüm 92 bayt + 1 kod .

s//_/g;s//uc/e;y/\x09-\x0b/_/;s/____/}[/;s/___/%C]/;s/_/{''H/;y/'{}1CDGH/'-)1-3+--/;s/[#-}]+/uc/ee

Bir sekmeyi ve dikey sekme içerir y///olarak belirtilen, \x09ve \x0b.

Çevrimiçi deneyin!

LOGO , 390 46 52 50 bayt

[ask    1   se[make]iseq    1-3 cos ?/ask   1[1/sum 1   179]?]

Bu, giriş tek ise girişi döndüren ve giriş eşitse bir hataya neden olan bir şablon listesidir.

Kullanımı:

show invoke [ask ... (paste code here) ... ] 5

çıktı

5

5'ten beri garip

invoke [ask ... (paste code here) ... ] 6

6 bile olduğu için hataya neden olur.

TI-BASIC, 14 bayt

Input Q
sinֿ¹(gcd(Q²,int(e
Q

Bu, eşit sayıda bir etki alanı hatası (ana ekrana hiçbir şey yazdırma) atar.

Input Q             Q is a variable with an odd code. We cannot use "Ans" as it's even.

            int(e   floor(e) = 2; "2" is even.
         Q²         Q may be negative, so we square it which preserves parity.
     gcd(Q²,int(e   1 if Q is odd; 2 if Q is even.
sinֿ¹(gcd(Q²,int(e   Error iff Q is even.

Q                   If there was no error, print Q.

Pyth , 14 11 10 9 bayt

I + Q_ + K / Q + 3_1KQ 
I! SIcQ + 3_1Q 
I! U + 1_GQ1Q
? U + 1_GQ1k

Test paketi .

Japt , 4 bayt

u)çU

Japt, ISO / IEC 8859-1 kullanıyor , bu yüzden (ondalık) değerine karşılık geliyor 117 41 231 85.

Çevrimiçi test edin!

açıklama

Uu)çU   Implicit: U = input integer
Uu)     Return Python-style U % (missing argument = 2). This gives 1 if U is odd, 0 if even.
   çU   Implicitly convert U to a string and repeat it that many times.
        Implicit: output result of last expression

İlk önce p, çtersine çevrilen argümanların olduğu çözümleri kullanarak denedim . Ancak, psol argümanı bir sayı ise , üsteleme gerçekleştirir, bu yüzden açıkça bir dizeye dönüştürmemiz gerekir. Bu çözüm, garip bayt içermemesine ek olarak, aslında bir bayt daha kısa olduğu ortaya çıkıyor.

dc , 21 bayt

[c]sa?kKKCI-1;1k%1!=a

Ondalık: 91 99 93 115 97 63 107 75 75 67 73 45 49 59 49 107 37 49 33 61 97

Gereğince bu garip ve aksi boşaltır yığını halinde IO varsayılan bu program ana yığın girişi bırakır. Bu f, TIO sayfasındaki gibi programın sonuna debug komutu eklenerek onaylanabilir .

Çevrimiçi deneyin!

açıklama

[    # Begin macro definition.
 c   # Clear the main stack.
]sa  # End macro definition and push the macro into register "a".
?k   # Prompt for input and store it into precision parameter "k".
KK   # Push two copies of the input to the main stack.
CI-  # Push C-I = 12-10 = 2 to the main stack  
1;1  # Push the value stored in the first index of array "1" (0 by default) 
     # to the main stack. 
k    # Push 0 into parameter "k" to reset the precision (otherwise the modulus 
     # function will not work correctly).
%    # Push the input (mod 2) to the main stack.
1!=a # If the input (mod 2) does not equal 1, execute the macro in register "a".
f    # OPTIONAL: Output the contents of the main stack.

TI-Basic, 18 bayt

Lirtosiast sayesinde 2 bayt kaydedildi

:Prompt Q
:While 5Q/ᴇ1-int(5Q/ᴇ1
:Q

bayt cinsinden (+2 newlines = 3F)

:Prompt Q
 DD     51
:While 5Q/ᴇ1-int(5Q/ᴇ1
 D1    35 3B B1  35 3B  
        51 31     51 31
         83 71     83
:Q
 51

Bkz http://tibasicdev.wikidot.com/one-byte-tokens

MathGolf , 3 bayt

¥{k

Çevrimiçi deneyin!

Kullanılan baytlar 157, 123, 107.

açıklama

¥     Input modulo 2
 {    Loop that many times
  k   Push input

Bash , 31 bayt

read a
[ $[a%2] = 0 ] ||echo $a

Çevrimiçi deneyin!

Açıklama:

read a                   reading the input and define it on the variable a
[ $[a%2] = 0 ]      outputs exit status 0 when a/2 is 0 and exit status 1 if not.
||                           evaluates only when the exit status left of it is 1
echo $a                displays the variable a