Racket / Scheme'de golf yapmak için hangi genel ipuçlarınız var ? Ben genel olarak en azından biraz Raket / Düzeni (örneğin "yorumları kaldırmak" bir cevap değildir) belirli olan golf sorunları kod uygulanabilir uygulanabilir fikirler arıyorum.

Biliyorum Scheme ve Racket (eski adıyla PLT Scheme) teknik olarak farklı dillerdir ancak birçok yönden oldukça benzerdir ve çok sayıda kod (şüphelendiğim) çoğunlukla amaçlandığı gibi çalışacaktır. Bahşişiniz yalnızca yukarıda belirtilen dillerden biri için geçerliyse, bunu not edin.

İfadeleri 'x, `x, ,x, bir ,@xotomatik genişletmek (quote x), (quasiquote x), (unquote x), ve (unquote-splicing x)sırasıyla. Bu tamamen sözdizimsel bir dönüşümdür ve her yere uygulanabilir. Bu, tek değişkenli işlevler için uygun bir gösterim sağlar:

; Defining a function:
(define ,x (+ x x))
; Calling a function:
(display ,2)

hangi genişler

; Defining a function:
(define (unquote x) (+ x x))
; Calling a function:
(display (unquote 2))

Yukarıdaki gibi kod test ettiğim yorumlayıcılarda çalıştı ve iki karakterli bir kısaltması olduğundan ideal olandan daha az olmasına rağmen, bağlı değişken gibi quoteveya sözdizimsel bir anahtar kelimeyi gölgelemek için semantiklerin ne olduğundan emin değilim , ancak bir karakter kısaltması olan yardımcı bir sözdizimidir ve bu nedenle bu saldırı için idealdir.quasiquoteunquote-splicingunquote

In Racket , λve lambdaanonim fonksiyonları oluşturmak için eşanlamlı anahtar kelimeler, ancak λ2 bayt lambda6'dır.

In Planı , orada böyle bir kelime var λve birlikte sıkışmış lambda.

~aSayıları ve sembolleri dizelere dönüştürmek için kullanın .

Raket kullanırken , değişkenleri λbirkaç bayt tıraş etmek için kullanarak bağlayın . In Planı , lambdabir ila dört veya daha fazla değişkeni bağlayıcı sürece, bu hüner uygulanamaz hale getirir.

Örnek: Bir değişken 2 bayt let/define

(define n 55)(* n n) ; 20 bytes

(let([n 55])(* n n)) ; 20 bytes

((λ(n)(* n n))55) ; 18 bytes

In Racket , requireformlar birden fazla argüman olabilir.

(require net/url net/uri-codec)

Şundan çok daha kısa mı?

(require net/url)(require net/uri-codec)

Şema hakkında fazla bir şey bilmiyorum , ama bir requireyerleşik varmış gibi görünmüyor .

Daha kısa eş anlamlılar kullanın

Racket'te çoğunlukla eşdeğer kısa versiyonları olan bir dizi prosedür vardır. (Genellikle eşdeğer değildir: örneğin, başarısız (car (cons 1 2))olduğu yerlerde çalışır (first (cons 1 2)). Ancak, sizin durumunuzda eşanlamlı olduklarını biliyorsanız ikame yapabilirsiniz.)

Bu liste muhtemelen eksik: Muhtemelen bu listeye girebilecek şeylerin çoğunu bilmiyorum.

• (= a b)(equal? a b)sayıları karşılaştırmak yerine .
• '(1 2)yerine (list 1 2).
• car, cadr, cdrİçin first, secondve rest.
• null? onun yerine empty?
• moduloremaindermodülün pozitif olduğu zamanlar yerine .
• floortruncateargümanının olumlu olduğu zamanlar yerine .

Gereksiz alanları atlayın

Bu "önemsiz" bir ipucu olarak düşünülebilir, ancak bir yere işaret edilmesi gerekir.

Normal kişiler tarafından yazılan Raket kodunu her okuduğunuzda (örneğin Raket belgelerinde ) tüm boşluklar konur: örneğin,

(append (list 1 2) (list 3 4) (list 5 6) (list 7 8))

Aslında, değişken adlarının bir parçası olduğu (ve )olamayacağı için, etraflarındaki tüm boşlukları silebilir ve herhangi bir belirsizlik kaybedemeyiz (ve daha da önemlisi, hala geçerli kod alabiliriz). Yukarıdaki ifade bunun yerine şöyle olabilir:

(append(list 1 2)(list 3 4)(list 5 6)(list 7 8))

Aşağıdaki ipuçları Raket içindir :

Varsayılan bağımsız değişkenler

Özellikle sık kullanılan uzun işlev adları için takma adlar oluşturmak için kullanışlıdır.

Golfün, argümanı tüketen bir işlev yazmanıza izin verdiğini ve reverseçok kullanmanız gerektiğini varsayalım . Şunun gibi bir şeyle başlayacaksınız:

(λ(x) ... reverse ... reverse ... reverse ...

Bunun yerine, daha kısa bir adla ek bir bağımsız değişken alabilir reverseve varsayılan değerini şu şekilde ayarlayabilirsiniz reverse:

(λ(x[r reverse]) ... r ... r ... r ...

Ayrıca, aynı argümanlardan bazılarıyla birçok yerde kullandığınız bir yardımcı fonksiyonunuz varsa kullanışlıdır. Mümkün olduğu kadar çok sayıda varsayılan bağımsız değişken kullanabilmeniz ve bağımsız değişkenleri birden fazla çağrı sitesinden kaldırabilmeniz için bağımsız değişkenleri işleve yeniden sıralamayı unutmayın.

match

Bu küçük bir yazı özetlemek biraz daha zordur, bu yüzden bunun için Racket Docs okuyun . Özetle, matchbir listeden belirli bir sırayla öğeleri ve eleman dizilerini çıkarmanıza izin verir ve quasquote sözdizimi, sakatlanmış listeyi tekrar birleştirmenizi sağlar:

(match (range 10)
 [`(,xs ... 3 ,ys ... 6 ,zs ...)
  `(,@(map f xs) 3 ,@(map f ys) 6 ,@(map f sz))]
 ...

Ayrıca, düzenli ifadelerle çalışmanın ve daha sonra ortaya çıkan gruplar hakkında ek hesaplama yapmanın kolay bir yolunu sunar,

adlı let

Buradaki söz dizimine bakın .let proc-id ...

Bu define, işlevi tanımladıktan sonra hemen çağırmadan veya çağırmadan çağrılan özyinelemeli işlevleri yazmanıza olanak tanır .

Gibi bir şey:

(define (fib i)
  (if (< i 2) i
      (+ (fib (- i 1)) (fib (- i 2)))))
(fib 10)

kısaltılabilir:

(let fib {[i 10]}
  (if (< i 2) i
      (+ (fib (- i 1)) (fib (- i 2)))))

Bu sonuncusu saçma, ama ben şimdiye kadar hiçbir yerde bu küçük hile kullanmak mümkün olmamıştır:
(apply map list matrix)bir devrik alır matrix, matrixlistelerin bazıları dikdörtgen liste gibi olduğunu '((1 2 3) (a b c)).
Bunun yararlı olduğunu kanıtladığında bana bildirin.

As Winny işaret , #!genellikle yerine kullanılabilecek #langdört bayt tasarruf.

#lang racket ;12 bytes
#!racket ;8 bytes