Giriş

Ben televizyon izlerken geçen gün bu (işe yaramaz) desen tökezledi. Ben ilk sayı kullanmak çünkü "9 desen" o (diyelim bu özü, bir sayı girin olan 9. oldu adında x ) ve sonra geri almak:

• x
• x + ( x / 3) [buna y diyelim ]
• y'nin üçte ikisi [buna z diyelim ]
• z + 1

Yani, bu örüntünün içine 9 sayısını x olarak koyarsam , ortaya çıkan şey budur:

• 9 ( 9 )
• 12 ( 9 + 9/3 ) [3 üzeri 9 3 ve 9 + 3 12]
• 8 ( üçte ikisinin 12 katı) [12'nin üçte biri 4 ve 4 * 2 8'dir]
• 9 ( 8 + 1 9'dur)

Meydan okuma

Bana bir sayı alan ve deseni kullanarak bir tamsayı dizisi çıkaran bir işlev (herhangi bir programlama dilinde) yazın.
Bu psuedo kodu gibi:

function ninePattern(int myInt) returns IntegerArray {  
    int iterationA = myInt + (myInt / 3);  
    int iterationB = iterationA * (2 / 3); 
    int iterationC = iterationB + 1;  
    IntegerArray x = [myInt, iterationA, iterationB, iterationC];  
    return x;  
}

Açıklamalar

Sorunun özellikleriyle ilgili yorumlarda tartışmalar gündeme geliyor. Bu bölüm bunlardan bazılarını açıklığa kavuşturmak içindir.

"bayt cinsinden saymak karakterden daha iyidir"

Karakter seçtim çünkü (en azından benim için) yargılamak daha kolay olurdu. Tabii ki, şimdi değiştiremem. (çok sayıda yanıt zaten gönderildi)

"Yuvarlama"

Yuvarlama bu kafiyeyi izler:

5 veya daha fazla ise, puanı yükseltin
4 veya daha azsa, dinlenmesine izin verin

Basitçe söylemek gerekirse, 4.7 veya 3.85 gibi bir şey varsa, bunları sırasıyla 5 ve 4'e yuvarlayın.

Örnekler

Input => Result
9 => [9, 12, 8, 9]
8 => [8, 11, 7, 8]
6 => [6, 8, 5, 6]
23 => [23, 31, 21, 22]
159 => [159, 212, 141, 142]

Bununla birlikte, sayılar 2.3 veya 10.435446 gibi bir şeyse, bunları sırasıyla 2 ve 10'a yuvarlayın.

"dil desteği"

Fonksiyonlar ve / veya dizileri, VEYA SADECE tercih ettiğiniz dil bunları desteklemiyorsa kullanamazsınız. Varsa (karakter sayınızı artıracak olsa bile) bunları kullanmalısınız .

MarioLANG, 659 621 591 582 556 543 516 458 418 401 352 308 369 bayt

yuvarlama oldukça pahalıdır: /

Çevrimiçi deneyin

;>>[![( [( [( [( [( [<(([!)))!+(((-<>( >((+
:"==#================"===#== #=====""[ "==
)(  -[!)>>[![)  [)[<(!>)[<)) >))) [!!-[!((
 (  )"#="==#======="=#==="=<="=====##==#==<
 +  +>) )-+<>+)[!)+! +))![-[)>[ [([-[![<<:
 +  )-+ )(=""===#==#  ==#===)"=======#=====
 +  >!>)!>  !(- < !:+:))<  ))!((++)))< 
 )  "#"=#===#===" ======" ===#======="
 !
=#========================

Bu beklenenden daha eğlenceliydi, bu muhtemelen optimal değil ama sanırım oraya geliyorum.

Açıklama zamanı:

( 352 baytlık sürüm için)

önce argümanı alıp yazdırıyoruz:

;
:

yeterince basit

daha sonra programın büyük bölümüne geçiyoruz : bölüm girişi / 3

;>>[![              [( [( [<result
:"==#======================"======
)   -[!)>>[![        [<((((!   
)   )"#="==#=========="====#
+(  +>) )  +>(+)[!)+))!
+(  )-+ )  -"====#====#
+   >!>)!  >! -  <
    "#"=#  "#===="
 !
=#

Brainfuck bölümünün biraz değiştirilmiş bir dönüşümüdür.

[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]

hangi girdi alır

n 0 d 0 0 

ve sana geri ver

0 n d-n%d n%d n/d 

bölümü aldığımızda n ve n / d toplamını almak ve yazdırmak için kullanırız

;>>[![              [( [( [<    !+(((-<
:"==#======================"===)#====="
)   -[!)>>[![        [<((((!    >))) [!(((
)   )"#="==#=========="====#   ="=====#==:
+(  +>) )  +>(+)[!)+))!
+(  )-+ )  -"====#====#
+   >!>)!  >! -  <
    "#"=#  "#===="
 !
=#

sonra başka bir bölüm daha yapmamız gerekir: (2 * (n + n / d)) / 3

böylece (2 * (n + n / d) elde ederiz

;>>[![              [( [( [<    !+(((-<
:"==#======================"===)#====="
)   -[!)>>[![        [<((((!    >))) [!(((
)   )"#="==#=========="====#   ="=====#==:
+(  +>) )  +>(+)[!)+))! 2*2n/d>[   -[![  <
+(  )-+ )  -"====#====# ======"======#====
+   >!>)!  >! -  <            !((++))<
    "#"=#  "#===="            #======"
 !
=#

ve 3 ile tekrar bölüme koyun

;>>[![              [( [( [<    !+(((-<
:"==#======================"===)#====="
)   -[!)>>[![        [<((((!    >))) [!(((
)   )"#="==#=========="====#   ="=====#==:
+(  +>) )  +>(+)[!)+))!      )>[   -[![  <
+(  )-+ )  -"====#====#      )"======#====
+   >!>)!  >! -  <       +++))!((++))<
    "#"=#  "#====" ===========#======"
 !
=#=================

o noktada her şey patlar, mario sonsuza dek daha büyük ve daha büyük sayıda bölünme yaparak sonsuz bir döngü içinde sıkışır.

ve birinci ve ikinci bölüm arasında bir ayrım yapmanın bir yoluna ihtiyacımız olduğunu düzeltmek için, sonuçta, oh sevinç, bir yolumuz var

;>>[![              [( [( [<([!)!+(((-<
:"==#======================"==#)#====="
)   -[!)>>[![        [<((((!))< >))) [!(((
)   )"#="==#=========="====#)="="=====#==:
+(  +>) )  +>(+)[!)+))!!:+:)))>[   -[![  <
+(  )-+ )  -"====#====#======)"======#====
+   >!>)!  >! -  <       +++))!((++))<
    "#"=#  "#====" ===========#======"
 !
=#=================

temelde bakıyoruz x in

x 0 n d-n%d n%d n/d 

0, eğer bu birinci bölümde olduğumuz anlamına geliyorsa

aksi takdirde ikinci bölümdeyiz ve sadece bölümün sonucunu yazdırıyoruz, 1 ekleyip tekrar yazdırıyoruz

ve voilà pasta kolay.

Emotinomicon 99 bayt, 33 karakter

😷😭,😲🆙🆙😼🆙😨😎⏬😎🆙😍➗➕🆙😨😎⏬😎😉✖😍➗🆙😨😎⏬😎😅➕😨

Açıklama:

😷                                 clear output
 😭                                begin quote string
  ,                               
   😲                              end quote string
    🆙                             duplicate top of stack
     🆙                            duplicate top of stack
      😼                           take numeric input
       🆙                          duplicate top of stack
        😨                         pop N and output as a number
         😎                        reverse stack
          ⏬                       pops and outputs top of stack as character
           😎                      reverse stack
            🆙                     duplicate top of stack
             😍                    push 3 to the stack
              ➗                   divide top two elements on stack
               ➕                  add top two elements on stack
                🆙                 duplicate top of stack
                 😨                pop N and output as a number
                  😎               reverse stack
                   ⏬              pops and outputs top of stack as character
                    😎             reverse stack
                     😉            push 2 to the stack
                      ✖           multiply top two elements on stack
                       😍          push 3 to the stack
                        ➗         divide top two elements on stack
                         🆙        duplicate top of stack
                          😨       pop N and output as a number
                           😎      reverse stack
                            ⏬     pops and outputs top of stack as character
                             😎    reverse stack
                              😅   push 1 to the stack
                               ➕  add top two elements on stack
                                😨 pop N and output as a number

MATL, 14 bayt

Xot4*3/tE3/tQv

Çevrimiçi Deneyin

Oldukça basit, vyığını bir diziye birleştirir. Xobir tamsayı veri türüne dönüştürülür ve sonraki tüm işlemler tamsayı işlemleridir.

Çedar , 27 bayt

b=8/9*$0
[$0,$0+$0/3,b,b+1]

$0girdi ile değişken. Cheddar sadece bir golf dili değil ¯ \ _ (ツ) _ / ¯, aynı zamanda rekabet etmiyor çünkü Cheddar'ın giriş işlevselliği bu zorluktan sonra yapıldı.

Ungolfed:

IterationB := 8 / 9 * $0  // 8/9ths of the Input
[ $0,                     // The input
  $0 + $0 / 3,            // Input + (Input/3)
  IterationB,             // (see above)
  IterationB + 1          // above + 1
]

Java, 86 82 84 85 karakterler

class c{int[]i(int I){int a=I+(I/3),b=(int)(a*(2d/3d));return new int[]{I,a,b,b+1};}}

dBir tamsayıdan hemen sonra yerleştirilen harf tamsayıyı a yapar double.

Ungolfed:

class c{
    int[] i(int I) {
        int a = I + (I / 3),
            b = (int)(a * (2d / 3d));
        return new int[]{I, a, b, b + 1};
    }
}

Sınıf olmadan ( class c{}8 karakter uzunluğunda), 76 karaktere küçülür:

int[]i(int I){int a=I+(I/3),b=(int)(a*(2d/3d));return new int[]{I,a,b,b+1};}

110 karakterde daha doğru sürüm (enum ile 118) - floats kullanıyor çünkü kimse döküm için yer yok Math#round(double):

int[]i(int I){float a=I+(I/3f),b=(a*(2f/3f));return new int[]{I,Math.round(a),Math.round(b),Math.round(b+1)};}

Java, 56 80 Bayt

Bazı kullanıcıların belirttiği gibi, bu çözüm (bazı diğerleri java gibi) verileri düzgün yuvarlamaz. Şimdi doğru sonucu döndürmesi gereken biraz daha uzun bir çözüm sunuyorum

int[]h(int a){int[]b={a,Math.round(a+a/3f),a=Math.round(a*8f/9),++a};return b;}

veya 60 bayt lamda sürümü

a->new int[]{a,Math.round(a+a/3f),a=Math.round(a*8f/9),++a}

Golf versiyonu

int[]g(int a){int[]b={a,a+a/3,a*8/9,a*8/9+1};return b;}

ve dinsiz

int[] g(int a) {
        int[] b = { a, a + a / 3, a * 8 / 9, a * 8 / 9 + 1 };
        return b;
    }

veya lambda olarak tanımlanan 36 bayt

a->new int[]{a,a+a/3,a*8/9,a*8/9+1}

Java, 64 bayt

int[]f(int i){return new int[]{i,i+=i/3+0.5,i-=i/3-0.5,i+=1.5};}

notlar

• Bu, gerekli yuvarlama yapısına sahiptir, @ user902383'ün çözeltisi ile karıştırıldığında daha kısa yapabilecek misiniz emin değilim.

Ungolfed

int[] f(int i) {
    return new int[]{
            i, 
            i += i / 3 + 0.5, 
            i -= i / 3 - 0.5, 
            i += 1.5};
}

İ = 9 ile çıktı

[9, 12, 8, 9]

Çizik, 33 bayt

Girdi istediğinde, setler agirişine yuvarlanmış, setler bve ckendi değişiklikler nedeniyle, daha sonra virgülle ayırarak dört sayı diyor.

Java 8 lambda, 109 81 79 75 karakter

Çünkü ... biliyorsun ... Java bile golf oynayabilir ...

a->{int b=(int)(.5+a*4./3),c=(int)(.5+b*2./3);return new int[]{a,b,c,++c};}

Lambda sınıfa sokuldu:

class C {  
   static int[] a(int a) {
        int b = (int) (.5 + a * 4. / 3),
            c = (int) (.5 + b * 2. / 3);
        return new int[]{a, b, c, ++c};
    }
}

Ben de tamsayı türü olduğu gibi uzun kullanmak için izin olduğunu varsayalım. Ne yazık ki bir tamsayı doğru yuvarlamak gerekir ve bu nedenle "kısa" bir döküm çalışmıyor. Uzun ürünler kullanarak, yuvarlama sonuçlarını tekrar ints.

Güncelleme

Güzel küçük + 0.5 kullanarak ve daha sonra hile yaparak doğru yuvarlamayı koruyoruz ve 2 karakter tasarruf ediyoruz!

Ayrıca bu hile artık uzun süre kullanılmasını gerektirmez, böylece 4 karakter daha ints tıraşına geri dönebiliriz.

Mathematica - 21 bayt

Mathematica'yı kardeşlerim RPi'den aldım, bu yüzden eğlenmek için denemek ve bir PPCG mücadelesinden daha iyi bir yol.

{#,4#/3,8#/9,8#/9+1}&

Anonim bir işlevi tanımlar. Şöyle deneyin:

In[26]:= x:={#,4#/3,8#/9,8#/9+1}&                                             

In[27]:= x[9]                                                                 

Out[27]= {9, 12, 8, 9}

Python 3, 45 bayt

f=lambda i:map(round,[i,i*4/3,i*8/9,i*8/9+1])

İdeone.com'da çalışan bu kodu görün

Lua, 52 Bayt

Bu program, komut satırı argümanına göre bir sayı alır ve karşılık gelen diziyi döndürür. Lua'daki programlar teknik olarak işlevlidir, çünkü tercüman her zaman bir işlevde sarar. Bu aynı zamanda diğer dosyalarda kodları "çağırdığınızda" kullanılan bu tamircidir (temelde loadfile/ kullanır dofile).

m=math.floor x=...z=m(x*8/9)return{x,m(x*4/3),z,z+1}

Aslında 21 bayt

`;;3@/+;32/*;uk1½+♂≈`

Bu program, üst yığın değerinde gerekli işlemleri gerçekleştiren bir işlevi bildirir.

Çevrimiçi deneyin! ( .sondaki ekstra işlevi değerlendirir ve sonucu yazdırır)

Açıklama:

`;;3@/+;32/*;uk1½+♂≈`
 ;;                    make two copies of x
   3@/+                divide by 3, add that to x to get y
       ;32/*           make a copy of y and multiply by 2/3 to get z
            ;u         make a copy of z and add one
              k        push stack as a list
               1½+     add 0.5 to each element
                  ♂≈   apply int() to each element (make integers from floats by flooring; this is equivalent to rounding half-up because of adding 0.5)

Mathcad, [tbd] bayt

Mathcad codegolf bayt denkliği henüz belirlenmemiştir. Bir klavye sayısını kaba bir eşdeğer olarak alarak, çözüm yaklaşık 40 bayttır.

05AB1E , 15 bayt

Kod:

Ð3/+D·3/D>)1;+ï

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin! .

Pyke, 11 bayt

D}[}3/bD)[h

Burada deneyin!

            - implicit input()
D           - a,b = ^
 }          - b*=2
  [}3/bD)   - macro:
   }        -   tos*=2
    3/      -   tos/=3
      b     -   tos = round(tos)
       D    -   old_tos = tos = tos
            - macro
         [  - macro
          h - d +=1

Javascript, 50 bayt

Java çözümümü JavaScript'e dönüştürdüm ve biraz daralttım.

var r=Math.round,g=a=>[a,r(a+a/3),a=r(a*8/9),++a]

C ++ 0x - 95 102 185 189 109 129 karakter

int * n(int p){static int a[3];a[0]=p;a[1]=round(p+(p/3));a[2]=round((a[1]/3)*2);a[3]=a[2]+1;return a;}

• Bunun için cmath başlığının çalışması gerekir.

Degolfed

#include <cmath>
int * ninePattern(int p) {
        static int a[3]; // pattern array
        a[0] = p; // sets first iteration
        a[1] = round(p + (p / 3)); // sets second iteration
        a[2] = round((a[1] / 3) * 2); // sets third iteration
        a[3] = a[2] + 1; // sets fourth iteration
        return a; // returns array
}

Erlang, 80 bayt

-module(f).
-export([f/1]).
f(X)->Y=X+(X/3),Z=trunc(Y*(2/3)),[X,trunc(Y),Z,Z+1].

Çalıştırmak için f.erl olarak kaydedin , derleyin ve işlevi çağırın. Bir ints listesi döndürecektir:

fxk8y@fxk8y:/home/fxk8y/Dokumente/erlang/pcg# erl
Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:4:4] [async-    threads:10] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> c(f).
{ok,f}
2> f:f(9).
"\t\f\b\t"
3>

ASCII değer aralığındaysanız Erlang'ın int s'yi otomatik olarak ASCII karakterlerine dönüştürdüğünü unutmayın, çünkü Erlang bir karakter türüne sahip değildir . İşlevi 100 ile çağırmak size daha iyi okunabilirlik sağlar [100,133,88,89] .

Ungolfed:

-module(f).
-export([f/1]).

f(X) ->
  Y = X+(X/3),
  Z = trunc(Y*(2/3)),
  [X, trunc(Y), Z, Z+1].

Erlang, 46 bayt

Cevap esinlenerek @ fxk8y (Cevabına yorum gönderemedim)

F=fun(X)->Z=round(X*4/9),[X,Z*3,Z*2,Z*2+1]end.

Ayrıca sonuçları şu şekilde görebilirsiniz:

2> io:fwrite("~w~n", [F(9)]).                         
[9,12,8,9]
ok

Pyth, 20 bayt

m.RdZ[Jc*4Q3Kc*2J3hK

Açıklama:

            (Implicit print)
m           For each d in array, d =
.RdZ        Round d to zero decimal places
[           The array of
  J         The result of setting J to
    c       The float division of
      *4Q   Input * 4
      3     and 3
            ,
  K         The result of setting K to
    c       The float division of
      *2J   J * 2
      3     and 3
            , and
  hK        K + 1.
            (Implicit end array)

Burada test edin

Jolf, 17 bayt

Ώ‘Hγ+H/H3Βώ/γ3hΒ’

Bir işlevi tanımlar Ώ. Girdiyi dolaylı olarak alır, bu yüzden tam bir program olarak iki katına çıkar. Burada deneyin!

Mathematica, 51 bayt

FoldList[#2@#&,{#,Round[4#/3]&,Round[2#/3]&,#+1&}]&

Her adımda yuvarlama anlamına gelen gönderinin geçerli (gönderme sırasında) sürümüne uyan anonim işlev.

FoldListBir olan tipik operasyon programlamada. Bu FoldList[f, list]iki argüman işlevini çağrılır ve flistenin sonraki öğesini ikinci argüman olarak alarak sonuca (veya ilk yinelemede listenin ilk öğesine) art arda uygular .

Ungolfed: #2 @ # &ikinci argümanını ilkine uygulayan anonim bir işlevdir. Bu nedenle, list argümanı FoldListgirdiye uygulanacak ardışık işlevlerden oluşur.

FoldList[#2 @ # &,
  {#, (* note the absence of '&' here, 
         this '#' stands for the argument
         of the complete function and is 
         covered by the & at the end      *)
   Round[4 # / 3] &, (* anonymous function that rounds 4/3 of its input *)
   Round[2 # / 3] &, (* ditto, 2/3 *)
   # + 1 &           (* add one function *)
  }] &               (* and the '&' makes the entire 
                        thing an anonymous function,
                        whose argument is the '#' up
                        at the top.                  *)

Girdi tamsayı olduğu ve bölümler 3 olduğu için, asla 4.5 gibi bir sonuç olmayacaktır, bu nedenle son basamak bir olduğunda yuvarlama kuralları hakkında endişelenmenize gerek yoktur 5: her zaman bir tamsayıya veya diğerine açıkça daha yakın olacaktır.

Dyalog APL , 33 bayt

(⌽,{1+⊃⍵})∘{⍵,⍨3÷⍨2×⊃⍵}(3÷⍨4∘×),⊢

Desmos, 37 bayt

a=9
b=a+\frac{a}{3}
c=\frac{2}{3}b
d=c+1

Alışılmadık diller için çevrimiçi Yay'ı deneyin !

CJam, 21 bayt

qi__3d/+mo_2d3/*i_)]`

Geribildirim

açıklama

• qi__ - Girişi bir tamsayı olarak okuyun ve iki kez çoğaltın
• 3D/+mo - Girişin bir örneğini 3'e bölün, sonra y'yi oluşturmak için ikinci örneğe ekleyin
• _2d3/*i - y'yi çoğaltın, sonra .6 ile çarpın
• _)] `- Dupe, arttırma, diziyi sarma, dizi olarak yazdırma (` operatör :( nedeniyle kodda değil)

Düzenleme: İlk üç bir çift yapmak unuttum, böylece program bozuldu. Sabit.

Aksiyom, 59 bayt

g(x)==round(x)::INT;f(x)==[x,a:=g(x+x/3.),b:=g(a*2./3),b+1]

Ölçek

(3) -> [[i,f(i)] for i in [9,8,6,23,159]]
   (3)
   [[9,[9,12,8,9]], [8,[8,11,7,8]], [6,[6,8,5,6]], [23,[23,31,21,22]],
    [159,[159,212,141,142]]]
                                                      Type: List List Any

PHP, 60 Bayt

print_r([$a=$argn,$b=round($a+$a/3),$c=round($b*2/3),$c+1]);

Çevrimiçi deneyin!

PHP, 67 bayt

function f($x){return [$x,$y=round($x*4/3),$z=round($y*2/3),$z+1];}