Numaralı Küpte Yüz Çıktılama


19

0 ile 7 arasındaki sayıları bir küpün 8 köşesine istediğiniz şekilde atayın. Her tepe noktasına tam olarak bir sayı atanmalıdır.

Örneğin, köşeleriniz şu şekilde atanabilir:

  3-----1
 /|    /|
4-----2 |
| |   | |
| 5---|-0
|/    |/
6-----7

0'dan 5'e kadar bir tamsayı alan bir program yazın. Bu 6 sayının her biri, küpünüzün tam olarak bir yüzü ile istediğiniz şekilde ilişkilendirilir. Bu sayılardan biri girildiğinde, ilişkili yüzün 4 tepe noktası numarası, 2 × 2 basamaklı basamakta stdout'a yazdırılmalıdır. Yüz, küpün dışından düz olarak görülmelidir. 4 yüz rotasyonunun tümü geçerlidir.

Örneğin, 0, yukarıdaki örnek küpün ön yüzü ile ilişkiliyse, bu giriş için geçerli bir çıktı olur 0:

42
67

Yüz herhangi bir 90 ° döndürmede görüntülenebilir, bu nedenle bunlar da geçerlidir:

27
46
76
24
64
72

Bu çıktı (ve dönüşleri) , yüzün yanlış tarafından görüntülendiğinden geçerli değildir :

24
76

Aynı fikir diğer tüm yüzler için de geçerlidir. Örneğin, 1 arka yüzle ilişkiliyse, girdi 1çıktı üretebilir 13[newline]05(ve 31[newline]50geçersiz olur).

Yani asıl zorluk, tepe noktası sayılarını ve rotasyonlarını seçerek girdiyi 4 tepe noktasına çevirmek kolay ve kısa olacaktır.

Bayt cinsinden en kısa kod kazanır. Tiebreaker daha önceki gönderi. ( Kullanışlı bayt sayacı. )

notlar

  • Program yerine bir işlev yazabilirsiniz. 0 ile 5 arasında bir tamsayı almalı ve 2 × 2 basamaklı ızgara dizesini yazdırmalı veya döndürmelidir.
  • Stdin, komut satırı veya işlev arg'dan girdi alın. Girişin geçerli olduğunu varsayabilirsiniz.
  • Çıktı isteğe bağlı olarak bir satırsonu satırına sahip olabilir.
  • Seçtiğiniz tepe ve yüz numaralarını bize bildirdiğinizden emin olun.

Yanıtlar:


17

CJam, 23 16 bayt

Muhtemelen bu probleme zarif bir matematiksel çözüm var. Ama nasıl bulacağına dair hiçbir fikrim yok, bu yüzden süper sıkıştırılmış sert kodlama!

Bir tane buldum! Bitsel işlemleri kullandığı için klasik olarak zarif bir matematiksel çözüm değil, ancak tamamen formülü.

li_o1^_p_6|o3+6%

Çevrimiçi deneyin.

Küp düzeni

  4-----7          4-----7          3-----2
 /|    /|         /  0  /|         /  3  /|
1-----0 |        1-----0 |        6-----5 |
| |   | |        |     |2|        |     |4|
| 5---|-2        |  1  | 2        |  5  | 7
|/    |/         |     |/         |     |/ 
6-----3          6-----3          1-----4  

açıklama

Eski cevabım küpü zaten her yüzün yüz numarasına eşit olan ilk (sol üst) köşe numarasıyla tanımlanabilecek şekilde ortaya koydu. Ama yüz numarasını kullanarak daha fazla köşe noktası sayısı hesaplamak istedim. Bir noktada, ikinci (üst sol) köşe numarasını XOR 1 yüz numarası olarak hesaplamak için ayağımı kapıya getiren bir fikir buldum. Ve bir süre deneme yanılma sonrasında ortaya çıkmayı başardım yukarıda gösterilen düzen ve bir yüzün her köşe numarasını noldukça kısa bir şekilde hesaplamamı sağlayan aşağıdaki formüller ile :

  • Sol üst: n
  • Sağ üst: n^1
  • Sol alt: (n^1)|6
  • Sağ alt: ((n^1)+3)%6

Referans olarak, burada istenen düzende her yüz için çıktıyı yeniden oluşturacağım:

Face:      0     1     2     3     4     5

Vertices:  01    10    23    32    45    54
           74    63    70    65    72    61

Bu nedenle, tüm program, giriş köşesi numarasını okumak ve bu değerleri sırayla üretmek, farklı köşeler için biraz farklı baskı mantığına rağmen geliyor. İlkinden sonraki her tepe noktası bir tabanla başladığından n^1, mantığı daha da sıkıştıran sadece bir kez hesaplamam gerektiğini unutmayın.


Gelecek kuşak için ve hala çok iyi bir yaklaşım olduğunu düşündüğüm için, işte eski cevabım.

CJam, 23 bayt

Muhtemelen bu probleme zarif bir matematiksel çözüm var. Ama nasıl bulacağına dair hiçbir fikrim yok, bu yüzden süper sıkıştırılmış sert kodlama!

"pÜ×ñè¨"487b8b3/ri_o=~p

Çevrimiçi deneyin.

Küp düzeni

  0-----7          0-----7          3-----6
 /|    /|         /  0  /|         /  3  /|
1-----2 |        1-----2 |        4-----5 |
| |   | |        |     |2|        |     |5|
| 5---|-6        |  1  | 6        |  4  | 7
|/    |/         |     |/         |     |/ 
4-----3          4-----3          1-----0  

açıklama

Kullanılan temel yaklaşım, her bir yüz için köşeleri mümkün olduğunca az alanda kodlamaktır. Optimizer'ın temel dönüştürme çözümüne benzer şekilde, tepe noktası listesine ASCII karakter verisi olarak paketlenmiş bir sekizli sayı gibi davranılır. Ancak bu, benzerliklerin daha fazla optimizasyon için yol açtığı yerdir!

"Saf" çözüm için yaptığım üç temel optimizasyon:

  • Küpü, her bir yüzün yüz numarası ile ilk köşe numarası olarak tanımlanabilecek şekilde yerleştirin. Yukarıda gösterildiği gibi küp düzenime bakıldığında, her yüzün sol üst köşe numarasının yüz numarasına eşit olduğu görülebilir. Bu, girdiyi geri yazdırmak zorunda kalmadan, daha az altı köşeyi kodlamama izin veriyor, bu da bir bayt kaydetmek için çıkıyor.
  • Köşe verisini, her bir "karakterin" maksimum 256'dan büyük olduğu bir dizeye paketleyin. Bu maksimum 256'yı geçtikçe, dizenin uzunluğu yavaş yavaş azalır, ancak herhangi bir "karakterin" 256'yı aşması ve böylece artık 1 baytlık ASCII karakter kümesinin bir parçası değildir. Bu nedenle, 256 ile 1000 arasındaki her bazdaki köşe verilerini kodlamaya çalışan bir program yazdım, bununla birlikte 256 karakterlik bir veri verisini taban 256'ya kıyasla kaydeden yaklaşık 10 baz buldum. 487'yi seçtim, elde edilen dize tamamen yazdırılabilir ASCII'den oluşur.
  • İlk optimizasyonla karıştırıldığında, çıktıyı asimetrik olarak üretin. CJam'daki genel yaklaşım, köşe verilerini 2 elemanlı listelerin 2 elemanlı bir listesi olarak biçimlendirmek, ortasına bir satırsonu eklemek ve çıktının dolaylı olarak yazdırılmasını sağlamak olacaktır. Ama bunun yerine ilk köşeyi (giriş yüzü numarasına eşit) yeni satır eklemeyen bir operatörle yazdırıyorum, diğer köşelerin 3 elemanlı listesini alıyorum, bir sonraki köşeyi yakalayıp ekleyen bir operatörle yazdırıyorum ve diğer iki köşenin örtülü olarak yazdırılmasına izin verin. Bu bir bayt tasarrufu sağlar.

2
Permütasyonları zarif bir matematiksel yaklaşım olarak denedim ve optimizasyonlarınız olmadan zor kodlamadan daha ayrıntılı.
Peter Taylor

Son cevabınız harika. Tamamen farklı bir yaklaşım olduğu ve başka bir oylamaya layık olduğu için ayrı bir cevap olarak yayınlamanız gerektiğini düşünüyorum. Temelde C cevabımla aynı küpü var ama ilk üç köşesi bile bir yer değiştirdi. Özlediğime inanamıyorum 6+n%2 --> 6|n(bunu Ruby cevabıma zaten ekledim.) Unutmayın ki, dönüşümleri n --> n^1yüzlerde uygulayarak formüllerinizi basitleştirebilirsiniz, ancak bunu attığınız nve devam n^1ederken kazandığınızı tahmin ediyorum puanınıza yardım etmeyin.
Level River St

@steveverrill Övgü için teşekkürler! Sohbette bunu tamamen yeni bir cevap olarak göndermem gerekip gerekmediğini sordum, ama bir fikir birliği yoktu, bu yüzden yapmadım. Küpün nve n^1çiftlerin dikkatlice sipariş edilmesinin , başka bir tepe noktasını sadece hesaplamamı sağlayacağını fark ettiğimde kendimden kesinlikle memnun kaldım |6. Ve n --> n^1kesinlikle mantıklı olan bu dönüşümü görmedim . Ama puanımı gerçekten etkilemeyeceğini doğru bir şekilde tahmin ettiniz, bu yüzden muhtemelen olduğu gibi bırakacağım.
Runer112

Devam ettim ve XOR fikrinizi Ruby cevabımla birleştirdim. 10 tasarruf sağlar (2 için ek olarak 6+n%2 --> 6|n) umarım umarım. Ben kullandı n --> n^1benim son revizyon ancak farklı girişler ile, sizinkiyle aynı çıkışları verir, böylece yüzlerine dönüşümü. BTW, bit işlemlerinin yetersiz olduğunu düşünmüyorum, hepsi bunları nasıl kullandığınıza bağlı!
Level River St

1
GolfScript oyununda 1 karakter daha kısa:~.1^..n@6|@3+6%
Peter Taylor

14

C 69

f(c){int d=c++%2*2-1;printf("%d%d\n%d%d",(c-d)%6,c%6,c%2+6,(c+d)%6);}

Test programında yönlendirilmemiş

f(c){
 int d=c++%2*2-1;
 printf("%d%d\n%d%d",(c-d)%6,c%6,c%2+6,(c+d)%6);
}

int n;
main(){
  scanf("%d",&n);
  f(n);
}

açıklama

Küp numaralandırmam, açıldığında şöyle görünür:

0---7
|   |
| 0 |
|   |
1---2---7 
|   |   |
| 1 | 2 |
|   |   |
6---3---4---7
    |   |   |
    | 3 | 4 |
    |   |   |
    6---5---0
        |   |
        | 5 |
        |   |
        6---1

Sol üst köşede yüzle aynı sayı vardır.

Sağ alt köşede sayı var (n+2)%6

Tek niçin sağ üst köşe (n+1)%6ve sol alt6

Hatta nsağ üst köşede 7ve sol alt köşede(n+1)%6

Program gösterildiği gibi tek sayıları gösterir ve çift sayılar 180 derece döndürülür. Bu, sağ üst köşenin her zaman (n+1)%6ve sol alt kısmın her zaman olduğu anlamına gelir (n+1)%2+6. Tersine çevrilebilir nve n+2daha kolaydır ( toplama veya çıkarma veya gerektiği gibi ayarlanarak c=n+1ve kullanılır .)d1-1

Çıktı

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

5
+1 Bu hayal ettiğim zarif matematiksel çözüm. Ne yazık ki, C uygulanan ...
Runer112

1
@ Runer112 Teşekkürler. Ne yazık ki, C en iyi bildiğim dildir. Ruby öğreniyorum ama hala yeni başlayan biriyim. Ruby bu puanı parçalayabilmeli, ancak muhtemelen Cjam ile rekabet etmemelidir. Belki sonra Ruby yayınlayacağız, ya da sadece benim C cevaba bazı küçük iyileştirmeler bulmak (değiştirme gibi c%6etmek c%=6ve onu önce gelir böylece, bazı modül hesaplamaları ortadan kaldırmak mümkün olmalıdır yüzünü dönen.) 'Dir deneme yapmak başka şey Yüz etiketlemesini tek bir yere kaydırıyorum, n-1,n,n+1bunun yerine alıyorum n,n+1,n+2.
Level River St

@steveverrill zaten nglobal olarak beyan edersiniz, böylece daha yüksek bir beyanda bulunarak birkaç bayt kaydedebilir, imzayı değiştirebilir misiniz f()? Yoksa sadece buradaki fişleve mi bakıyoruz ?
dwcanillas

@dwcanillas "You may write a function instead of a program"bu yüzden sadece işlevi sayıyorum. Her durumda, bu sadece en aşina olduğum dilde bir kavram kanıtıydı. Başlangıçtan bundan çok daha kısa olan Ruby cevabımı kısaltmakla daha çok ilgileniyorum.
Level River St

8

Öğe, 18

_4:2%6+``2+6%`-5+`

Birçok daha gelişmiş golf dilinin aksine, Element'in bir sıkıştırma operatörü yoktur, bu nedenle çözümün kısalığı, kullanılan kesin numaralandırma şemasına oldukça yakındır. Bazı deneylerden sonra, yalnızca basit aritmetik işlemler kullanılarak köşelerin hesaplanmasını sağlayan yeni bir numaralandırma şeması oluşturdum.

  1-----0          1-----0          2-----5
 /|    /|         /  4  /|         /  3  /|
4-----6 |        4-----6 |        3-----7 |
| |   | |        |     |0|        |     |5|
| 7---|-5        |  2  | 5        |  1  | 0
|/    |/         |     |/         |     |/ 
3-----2          3-----2          4-----1  

Sol üst köşe çift ise 6, tek ise 7'dir. Sağ üst köşe yüz numarasının kendisidir. Sol alt yüz numarası artı 2, mod 6'dır. Sağ alt 5 eksi yüz numarasıdır.

İşte kodun bir açıklaması.

_4:2%6+``2+6%`-5+`
_4:                    take input and make several copies of it
   2%6+`               take face #, mod 2, add 6, and output
        `              output input, which already has the newline attached
         2+6%`         take face #, add 2, mod 6, and output
              -5+`     negate face #, add 5, and output

Yüzlerin her biri için çıktılar:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

+1: Kodunuzu çözülemez bulsam da, bunun golf dilinde nasıl puan aldığını görmek güzel. Görünüşe göre şu anda ortak 3'üncü sıradasınız, 2 CJam cevabının arkasında: Peter Taylor ve Runer 112.
Level River St

Şimdi sağlam bir ikinci sırada, ama CJam'ı dövmesini öngörmüyorum.
PhiNotPi

6

Octave, 108 , 100 68 50 bayt

Tabii ki önceki yaklaşımlarımdan daha zarif yapmanın bir yolu, düz kodlama. Oktav'ın Codelabolf için Matlab = 'den daha uygun olması nasıl şaşırdım?)

f=@(n)['040201375767';'261345154623'](:,2*n+(1:2))

Yerleşim:

(Üzgünüm, eklemeyi unuttum.)

Küp düzeni

  1-----5          1-----5          6-----7
 /|    /|         /  2  /|         /  5  /|
0-----4 |        0-----4 |        2-----3 |
| |   | |        |     |4|        |     |3|
| 3---|-7        |  0  | 7        |  1  | 5
|/    |/         |     |/         |     |/ 
2-----6          2-----6          0-----1  

Eski versiyonlar:

f=@(n)[0 4 0 2 0 1 3 7 5 7 6 7;2 6 1 3 4 5 1 5 4 6 2 3](:,2*n+(1:2))

Daha eski Sürümler:

Bu gerçekten 2x2x2'lik bir dizi oluşturacak ve daha sonra bir 'dilim' seçecek. Bir 3d matris permütasyonu yapıyoruz ve her seferinde üst veya alt dilimi seçiyoruz. (Bu, bir matris yerine bir ifadenin indekslenmesi nedeniyle matlab'da çalışmaz) Eminim, daha kısa olacak daha doğrudan yapmanın yolları olacaktır.

f=@(n)squeeze(permute(reshape(0:7,2,2,2),circshift((1:3)',n))(n=fix(n/3)+1,circshift((1:2)',n-1),:))

f=@(n)squeeze(permute(reshape(0:7,2,2,2),circshift((1:3)',n))(floor(n/3)+1,circshift((1:2)',floor(n/3)),:))

5

CJam, 31 28 (veya 26) bayt

8,2/W%_1m<]z[D75K46]2/+ri=N*

26 baytlık bir sürüme temel dönüştürme kullanılarak da sıkıştırılabilir .

Küpün aşağıdaki gibi olduğunu varsayar:

  7-----1
 /|    /|
5-----3 |
| |   | |
| 6---|-0
|/    |/
4-----2

yüzleri gibi

  7-----1      .-----.      .-----.      .-----.
 /  4  /|     /  4  /|     /  4  /|     /  0  /|
5-----3 |    .-----. |    .-----. |    .-----. |
|     |2|    |     |1|    |     |0|    |     |5|
|  1  | 0    |  0  | .    |  3  | .    |  3  | .
|     |/     |     |/     |     |/     |     |/ 
4-----2      .-----.      .-----.      .-----.    

Buradan çevrimiçi deneyin


4

CJam (25 bayt)

"ñRXµ  roM~"(ib65b2/q~=N*

Bu, yazdırılamayan bir karakter ve (StackExchange yazılımı tarafından yönetilecek) bir sekme içerir, bu nedenle xxd biçiminde:

0000000: 22f1 5258 1fb5 0972 6f4d 7e22 2869 6236  ".RX...roM~"(ib6
0000010: 3562 322f 717e 3d4e 2a                   5b2/q~=N*

Çevrimiçi demo

Küp:

  1-----0        Faces:
 /|    /|        10 46
4-----6 |        14 37
| |   | |        20 31
| 3---|-2        23 57
|/    |/         56 20
7-----5          57 64

Bu, taban sıkıştırılabilirliğini en üst düzeye çıkarmak için küp köşeleri seçilen saf sert kodlamadır. 2 basamaklı sayıları çözerim, böylece hiçbiri 0 ile başlayamaz. Ben de 7 ile başlamak istemiyorum, çünkü bu ikinci üssü çok yukarı itiyor. Bu nedenle 0 ve 7 uzun bir diyagonal üzerinde olmalıdır. Ben kodlama değeri azaltmak için ilk 10 kenar gitmek istiyorum. Bunun dışında bayt sayısını değiştirmeden makul miktarda esneklik var.

Sihirli dizeden ilk karakteri çıkardıktan sonra, temel dönüşüm için bir temel olarak kullanmadan önce bir int'e atmak gerektiğinden biraz hayal kırıklığına uğradım. Umarım gelecekteki CJam sürümleri bu baytı kurtaracaktır, ancak burada kullanmak için çok geç olacaktır.


4

JavaScript (ES6), 53 62

Düzenle Şablon dizeleri, 8x @NinjaBearMonkey kullanarak 8 bayt kaydedin. Dikkat edin, tırnak içindeki yeni satırlar önemlidir ve daraltılamaz.

Javascript'te zekice olamaz, çok ayrıntılı.

f=n=>`01
23
45
67
01
31
5702
64`.substr(n-4?n*3:20,5)

Çıktı for(i=0;i<6;i++)console.log(f(i),i)

01
23
0

23
45
1

45
67
2

67
01
3

02
64
4

31
57
5

Numara ilişkilendirmeleri (veify için ön bilgi bu eğlenceliydi)


1
ES6 şablon dizeleri kullanıyorsanız \n, 8 bayt kaydetmesi gereken aktif yeni satır karakterleri kullanabilirsiniz .
NinjaBearMonkey

Şablon dizeleri için tırnak işaretleri yerine onay işaretleri `kullanmanız gerekir.
NinjaBearMonkey

Evet, aslında bunu böyle test ettim.
edc65

4

Ruby Rev 1, 40 36

->(c){print(c^1,c,"\n",6|c,(c+3)%6)}

4 byte tasarruf etmek için lambda kullanmayı önerdiği için @rcrmn'a teşekkürler. Anonim bırakarak emin değildi ama meta burada tartışıldı ve bu Tamam olduğuna karar vermiş gibi görünüyor .

Burada 40 baytlık bir işlev olarak, Rev 0 Ruby cevabımla karşılaştırmak için, aşağıda da var (Orijinal C cevabı ayrı bir gönderide.)

def f(c)print(c^1,c,"\n",6|c,(c+3)%6)end

Runer112'den daha fazla ilham: Bu, en son (16 bayt!) Cevabında kullanılan numaralandırma şemasında bir modifikasyona dayanıyor. PhiNotPi'nin planının doğrudan limanı aynı puanı verecektir.

Numaralandırmayı Rev 0 turundan bir adım kaydırarak ve her şeyi XOR 1 alarak, aşağıdaki küpü elde ederiz:

4---7
|   |
| 1 |
|   |
1---0---7
|   |   |
| 0 | 3 |
|   |   |
6---3---2---7
    |   |   |
    | 2 | 5 |
    |   |   |
    6---5---4
        |   |
        | 4 |
        |   |
        6---1

Çıktı

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rev 0, 56 52 50

Gereksiz kaldırarak 4 bayt Kaydedilen ()%6gelen c-dve başka bir 2 ile (runer112 esinlenerek)6+c%2 --> 6|c .

Skor sadece ilk satır olan fonksiyon içindir. Ruby'de yeniyim ve n'ye bir kullanıcı giriş numarası almak için 12 karakterden (11 artı yeni satır) daha kısa bir yol bulamadığım için şaşırdım. Sonuç olarak, program yerine bir işlev yapmak 1 bayt tasarruf sağlar.

def f(c)d=c%2*2-1;print((c+d)%6,c,"\n",c|6,c-d)end

n=gets.to_i
f(n)

Bu C cevabımın bir limanı. C'de, %operatör negatif bir sayı ile negatif bir değer döndürür. Ruby'de her zaman pozitif bir değer döndürür, bu yüzden 1 eklemeye gerek yoktur c. Sonuç olarak, yüzlerin numaralandırmasını aşağıdaki gibi 1 kaydırmak avantajlıdır:

0---7
|   |
| 1 |
|   |
1---2---7 
|   |   |
| 2 | 3 |
|   |   |
6---3---4---7
    |   |   |
    | 4 | 5 |
    |   |   |
    6---5---0
        |   |
        | 0 |
        |   |
        6---1

Yeni yüz numaralandırmasıyla, program yukarıda gösterilen şekilde kanıtları yazdırır ve olasılıklar 180 derece döndürülür:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Lambdas kullanarak işlevi kısaltabileceğinize inanıyorum: ->(x){...code...}işlev tanımınızı 4 karakter daha kısa bırakır. Daha sonra onu kullanmak için bir değişkene atamanız ve #call
rorlork

@rcrmn teşekkürler, haklısın, f=->(c){print(c^1,c,"\n",6|c,(c+3)%6)}koşuyor ve 2 karakter daha kısa ( atlarsam 4 karakter daha kısa f=). Emin değilim atlamak adil f=ama soru fonksiyon anonim olamaz demiyor. Garip bulduğum şey, bu sözdiziminin yeni başlayanlara gösterilen sözdiziminden tamamen farklı olması, parantez içinde geçirilen parametresi var:f=lambda{|c|print(c^1,c,"\n",6|c,(c+3)%6)}
Level River St

Buna lambda değişmez adı verilir. Ve sözdizimini hatırlamamız gerektiğinde her zaman bir referans bulmak zor buluyorum ...
rorlork

3

Pyth, 30

@ Jakube 2 bayt için teşekkürler.

Jc2jkfx>Q2!.&T^2%Q3U8jb?_J%Q2J

Burada deneyin.

Pyth uzmanlarının golf tavsiyeleri nezaketle kabul edilecektir. Özellikle çıktı bölümünün bazı iyileştirmeler olabileceğini düşünüyorum.

Aşağıdaki pitonun limanı: ...

Python, 109

Q=input()
s=''.join(map(str,filter(lambda v:(Q<3)^(v&(1<<Q%3)>0),range(8))))
print s[1-Q%2::2],'\n',s[Q%2::2]

... limanı olan

Saf Bash, 130

Açıklama amacıyla:

for v in {0..7};{
if(($1/3));then((v&(1<<$1%3)))&&a+=$v
else((v&(1<<$1%3)))||a+=$v
fi
}
i=$[$1%2*2]
echo "${a:i:2+i}
${a:2-i:4-i}"

Küp köşeleri şu şekilde numaralandırılmıştır:

  4-----5
 /|    /|
0-----1 |
| |   | |
| 6---|-7
|/    |/
2-----3

Ve yüzler bu şekilde numaralandırılmıştır:

Face  Vertices  Swap
   0  0,2,4,6
   1  0,1,4,5   x
   2  0,1,2,3
   3  1,3,5,7   x
   4  2,3,6,7
   5  4,5,6,7   x

SwapKolon köşelerin sırası çıkış anahtarlamalı gösterir.

Algoritma tüm köşe noktaları {0..7} ile başlar. Köşeler, köşe numaralarında ayarlanan bitlere göre elimine edilir:

  • 0,1 ve 2 yüzleri için, sırasıyla 1,2 veya 3 bitli köşeler korunur
  • 3,4 ve 5 yüzleri için, sırasıyla 1,2 veya 3 bitli köşeler korunur

"Tutulan" köşeler bir dizeye eklenir. Dize, takas bayrağının (yüz numarası mod 2) ayarlanıp ayarlanmadığına bağlı olarak 0,1 ve sonra 2,3 çıkış karakterlerinden oluşur.


1

J - 26 bayt

Yüz numarasını bağımsız değişken olarak alma ve basamak ızgarasını döndürme işlevi.

0{.@":"0@{0&(|:|.)&(i.3#2)

Aşağıdaki küpü kullanıyoruz:

  4-----5    Face numbers:
 /|    /|     0 - front
0-----1 |     1 - top
| |   | |     2 - left
| 6---|-7     3 - back
|/    |/      4 - bottom
2-----3       5 - right

Örnek ( tryj.tk adresinde kendiniz deneyin ):

   0{.@":"0@{0&(|:|.)&(i.3#2) 3         NB. inline
76
54
   f =: 0{.@":"0@{0&(|:|.)&(i.3#2)      NB. named
   f each 0 1 2 3 4 5                   NB. all results
+--+--+--+--+--+--+
|01|40|64|76|37|13|
|23|51|20|54|26|57|
+--+--+--+--+--+--+

Ekmek ve tereyağı 0&(|:|.). Bu, küpü yinelemeli olarak uygulandığında her yüzü ziyaret edecek şekilde tersine çeviren ve döndüren bir fiildir, giriş argümanını kullanarak bunu yaparız. Küpün köşeleri tarafından oluşturulur i.3#2, bu yüzden bunu başlangıç ​​noktası olarak kullanırız ve ön yüzü alırız0...{ işimiz bittiğinde alırız.

Basamakları dize olarak yazdırmak 8 karakterdir: {.@":"0@Bir diziyi döndürmemize izin verilirse, bu 8 tam karakter tasarrufu sağlar. [yumruk titremeye ve ayırt edilemez tutuşa başlar]


1, 4 ve 5 için sonuçlar tersine çevrilmiş gibi görünüyor
Digital Trauma

0

> <> (Balık) , 38 bayt

'/ =/2= 28"H5'a@i-!
noan~\;
~>:?!^1-@~

Her çıkış iki adet 2 basamaklı satır olarak kaydedilir. Satırlar dizede charcodes olarak saklanır '/ =/2= 28"H'( dizeden 10sonra eklenmiş satır hariç a). İlk karakter (/ = 47 ), ikinci etkileşime program akışını yönlendirmek için kullanılır.

Üstteki 2*(53-n)elemanlar atılır (burada n, giriş numarasının kodudur) ve sonraki iki kod arasında yeni satır ile yazdırılır.

Yerleşim:

  3-----2
 /|    /|
4-----7 |
| |   | |
| 5---|-0
|/    |/
6-----1      0 1 2 3 4 5 sides are top front bottom back left right respectively.
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.