Ben çocukken ve hayatımdaki tasarruflarımı hesaplamak istediğimde, yüksek sesle sayılırdım:

bir iki üç dört beş altı Yedi sekiz dokuz on;
onbir, on iki, on üç, on dört, on beş, on altı, on yedi, on sekiz, on dokuz, yirmi;
yirmi bir, yirmi iki, yirmi üç, yirmi dört, yirmi beş ...

Sonunda bu çok heceli sayıların her birini telaffuz etmekten yoruldum. Matematiksel düşünceyle, çok daha verimli bir sayım yöntemi yarattım:

bir iki üç dört beş altı Yedi sekiz dokuz on;
bir, iki, üç, dört, beş, altı, yedi, sekiz, dokuz, yirmi;
bir, iki, üç, dört, beş, altı, yedi, sekiz, dokuz, otuz ...

Gördüğünüz gibi, sadece önceki numaradan değiştirilen rakamları telaffuz ediyorum. Bu, sayıların İngilizce isimlerinden çok daha fazla tekrarlanabileceği ve bu nedenle hesaplamak için daha az beyin gücü gerektirdiğine ek bir avantaja sahiptir.

Meydan okuma

Olumlu bir tamsayı alan ve nasıl sayarım çıktısını veren / döndüren bir program / işlev yazın: yani, en sağ sıfır olmayan basamak ve tüm sondaki sıfırlar.

Örnekler

   1    1
   2    2
  10   10
  11    1
  29    9
  30   30
  99    9
 100  100
 119    9
 120   20
 200  200
 409    9
1020   20

Testlerin tam listesi gerekli olmamalıdır. Bu, OEIS’te A274206 .

kurallar

• Girişiniz, hassasiyet ve bellek konularını göz ardı ederek tüm pozitif tamsayılar için teorik olarak çalışmalıdır.
• Giriş ve çıkış ondalık basamakta olmalıdır.
• Girdi ve / veya çıktıyı sayı, dize veya rakam dizisi olarak almayı seçebilirsiniz.
• Giriş, pozitif bir tamsayı olarak garanti edilir. Girişiniz geçersiz giriş için her şeyi yapabilir.

Bu kod golf , yani bayt cinsinden en kısa kod kazanır.

Python 2,28 bayt

f=lambda n:n%10or 10*f(n/10)

Çevrimiçi deneyin!

Özyinelemeli bir formül çok temiz bir şekilde çalışır. Son hane sıfır değilse, çıktısını alın. Aksi takdirde, son sıfırı kaldırın, çıktısını hesaplayın ve 10 ile çarpın.

Jöle , 6 3 bayt

G / Ç ile ondalık basamak listesi olarak -3 bayt .

ṫTṪ

Test paketi Çevrimiçi deneyin!

Nasıl?

ṫTṪ - Main link: listOfDigits  e.g.  [1,    0,    2,    0]  or [1,      1,    9  ]
 T  - truthy indexes                 [1,          3      ]     [1,      2,    3  ]
ṫ   - tail (vectorises)              [[1,0,2,0],  [2,0]  ]     [[1,1,9],[1,9],[9]]
  Ṫ - tail pop                                    [2,0]                       [9]

Ondalık listeler alamazsak 6 bayt:

DµṫTṪḌ

Hangisini burada görebilirsiniz .

Bu aynı şeyi yapar, ancak bir tamsayıyı daha önce ondalık bir listeye dönüştürür ve daha sonra bir tamsayıya dönüştürür.

C, 30 29 27 bayt

Bunu yapmak için iki C istismarını kötüye kullandığım için gurur duyuyorum (yazının sonunda açıklanmıştır); Bu özellikle C (GCC) içindir.

3) b=10;f(a){a=a%b?:b*f(a/b);}// 27 bayt

2) b;f(a){b=a=a%10?:10*f(a/10);}// 29 bayt

1) f(i){return i%10?:10*f(i/10);}// 30 bayt

Çevrimiçi deneyin (27 byte version)

İlk deneme (30 bayt): GCC'de üçlü olarak bir değer bildirilmezse koşullu değerin geri döndürüleceği gerçeğini kötüye kullanır. Bu nedenle üçlü operatörüm gerçeğin geri dönüş değeri için boş.

İkinci deneme (29 bayt): GCC'de, bir fonksiyonun dönüş değeri olmadığında, fonksiyonda anlamlı olarak ikiden fazla değişken kullanıldığında, ilk argüman değişkeninin son set değeri kullanıldığında, anladığım kadarıyla, bellek hatasını suistimal eder. iade edilecek.
   (Düzenleme: ancak bu "ayar değeri" belirli şekillerde ayarlamalıdır, örneğin bir değişkeni ayarlamak =veya +=çalışmak ancak %=bununla çalışmak işe yaramaz; garip)

Üçüncü deneme (27 byte): Yukarıda belirtilen bellek hatasını kötüye kullanmak için ikinci değişkeni (b) zaten anlamlı bir şekilde kullanmam gerektiğinden, ikame için "10" için gerçek bir değişken olarak kullanabilirim.
   (Not: Ben takas gerekir a=a%bile a%=b, başka bir byte kaydetmek ama ne yazık ki bu bellek böcek "çalışma" durağına yukarıda istismar neden yapamıyorum bu yüzden)

Retina , 7 6 bayt

!`.0*$

Çevrimiçi deneyin (tüm test durumları)

Girilen dizgenin sonundaki sıfırları izleyen bir rakamın çıktı eşleşmeleri. Zorunlu olmamakla birlikte, bunun için de işe yarar 0.

Cubix , 18 32 bayt

Sanırım daha sonra bir süre bunu harcamak zorunda kalacağım ve biraz sıkıştırabilir miyim bakacağım. Ama şu an için burada.
Bu tamamen yanlış bir şekilde düşündüğümü çıkıyor. Şimdi işlem artımlı olarak giriş tamsayı için bir mod (1,10,100,1000, ...) uygular ve sıfır olmayan ilkini yazdırır. Biraz daha sıkıcı ama daha kısa.

!N%*I1^\.u;u@O\;;r

Burada dene

    ! N
    % *
I 1 ^ \ . u ; u
@ O \ ; ; r . .
    . .
    . .

JavaScript, 21 bayt

f=n=>n%10||10*f(n/10)

Test durumları

f=n=>n%10||10*f(n/10)

console.log(f(1   )); //  1
console.log(f(2   )); //  2
console.log(f(10  )); //  10
console.log(f(29  )); //  9
console.log(f(99  )); //  9
console.log(f(1020)); //  20

Javascript 19 18 bayt

Bir baytta golf oynamak için ETHproductions ve iki baytta golf oynamak için Patrick Roberts sayesinde

x=>x.match`.0*$`

Girilen dizgenin sonundaki regex ile herhangi bir karakterin ardından gelen en büyük sıfır sayısının ardından gelen dizeleri dizisini döndürür.

Çevrimiçi Deneyin

Bash + coreutils, 12

grep -o .0*$

Çevrimiçi deneyin .

Kir , 5 bayt

d\0*e

Çevrimiçi deneyin!

açıklama

       Find the longest substring of the input matching this pattern:
d      a digit, then
 \0*   zero or more 0s, then
    e  edge of input (which is handled as an Nx1 rectangle of characters).

Brachylog , 2 bayt

a₁

Çevrimiçi deneyin!

Yerleşik sonek a₁Tamsayılar için şu şekilde uygulanır:

brachylog_adfix('integer':1, 'integer':0, 'integer':0).
brachylog_adfix('integer':1, 'integer':I, 'integer':P) :-
    H #\= 0,
    H2 #\= 0,
    abs(P) #=< abs(I),
    integer_value('integer':Sign:[H|T], I),
    integer_value('integer':Sign:[H2|T2], P),
    brachylog_adfix('integer':1, [H|T], [H2|T2]).

Brachylog, tamsayıları basamak listesi olarak ele almayı sever ve bunun için özel yardımcı program belirtimini kullanır integer_value/2. integer_value/2Burada ilginç olan şey , bir sıfır listesini baştaki sıfırlarla doğru bir şekilde çevirebilmesi gerektiğinden, aynı zamanda bir tamsayıyı baştaki sıfırlarla bir basamak listesine çevirebilmesidir, bu nedenle bunu yapmak istemez. gerçekleşir (çoğu, özellikle nondet olanlar a), sayı listelerinin başlarının 0 olmasını yasaklar. Bu nedenle, a₁listeler ve dizeler için en kısa süre önce son ekleri oluştururken, içinde 0 olan bir tam sayı ekinin üstüne atlar. yinelenenleri silmeye ilaveten, aynı zamanda, üretilen ilk sonekin tüm son sıfırlarla en sıfır sıfır olmayan basamak olduğu anlamına gelir.

Brain-Flak , 74 bayt

{({}<>)<>}(()){{}<>(({}<>)[((((()()()){}){}){}){}]<(())>){((<{}{}>))}{}}{}

Çevrimiçi deneyin!

Yalnızca son 0 olmayan ve tüm son 0'ları yazdırır.

Açıklama:

{({}<>)<>}                    # Move everything to the other stack (reverse the input)
(())                          # Push a 1 to get started
{                             # do...
  {}<>                        #   pop the result of the equals check (or initial 1)
  (                           #   push...
    ({}<>)                    #     the top value from the other stack (also put this on the stack)
    [((((()()()){}){}){}){}]  #     minus the ASCII value of 0
    <(())>                    #     on top of a 1
  )                           #   close the push   
  {                           #   if not zero (ie. if not equal)
    ((<{}{}>))                #     replace the 1 from 3 lines back with a 0
  }{}                         #   end if and pop the extra 0
}                             # while the copied value != "0"
{}                            # pop the result of the equals check

Vim, 19 bayt

Her ikisi de 19 bayt olan iki sürüm:

:s/\v.*([^0]0*)/\1
:s/.*\([^0]0*\)/\1

Üstelik takip eden bir vagon her birine geri dönüyor.

Tüm test durumlarını çevrimiçi olarak doğrulayın! (Birden çok satırda test etmek için bir bayt eklendi)

TI-Basic, 18 bayt

If fPart(.1Ans
Return
Ans.1
prgmA
10Ans

R, 33 bayt

Adsız bir işlev olarak uygulandı

function(x)rle(x%%10^(0:99))$v[2]

Bu, 10 ^ 0 ila 10 ^ 99 arasında bir mod uygular. rlesonuçları azaltmak için kullanılır, böylece ikinci öğe her zaman istediğimiz sonuç olur.
Çevrimiçi deneyin!

Zsh , 18 16 bayt

<<<${(M)1%[^0]*}

Çevrimiçi deneyin! Çevrimiçi deneyin!

Bash , 25 bayt

r=${1%[^0]*}
echo ${1#$r}

Çevrimiçi deneyin!

Kabukların regex kullanması için harici programları çağırması gerekir, bu yüzden globbing ile başlamalıyız.

${1%[^0]*}Genişleme sıfırdan farklı bir karakterle başlayan kısa sonek ile eşleşir ve kaldırır.

• Zsh’de (M) bayrağın eşleşen son ekin kaldırılmak yerine tutulmasına neden olur.
• Bash'de, ${1% }genişleme kalan her şey bir önek olarak kaldırılır.

GNU sed , 17 14 + 1 (r bayrağı) = 15 bayt

Düzenleme: Riley sayesinde 2 bayt daha az

s:.*([^0]):\1:

Her şey silinerek en sağdaki sıfır basamağa kadar çalışır, ardından mevcut sondaki sıfırlarla birlikte yazdırılır. Komut dosyası, bir çalıştırmada, her biri ayrı bir satırda birden çok sınama yapabilir.

Çevrimiçi deneyin! (tüm test örnekleri)

Mathematica, 26 bayt

Rakamların listesini alan ve rakamların listesini çıkaran saf fonksiyon:

#/.{___,x_,y:0...}:>{x,y}&

açıklama

#                           First argument
 /.                           Replace
   {                              start of list followed by
    ___,                          zero or more elements followed by
        x_,                       an element (referred to later as x) followed by
           y:0...                 a sequence of zero or more 0s (referred to later as y) followed by
                 }                end of list
                  :>            with
                    {x,y}         {x,y}
                         &   End of function.

Bu x, en sıfır eşleşmeyi bulduğu için çalışır , bu listenin sıfır sırasını 0ve ardından listenin sonunu takip ettiği için listenin en sıfırdan sıfır elemanı olmalıdır .

Java 8, 47 bayt

bu, a ile atanabilen bir lambda ifadesidir IntUnaryOperator:

x->{int m=1;for(;x%m<1;m*=10);return x%m*m/10;}

açıklama: x%m0 olana kadar m ile 10'u çarpın return x%m*m/10. bölmeyi gerektirir, çünkü m istenen sonuçtan daha büyük bir mertebedir.

Perl 6 , 10 bayt

{+m/.0*$/}

Önemsiz regex çözümü. Sayı girer ve çıkar.

MATL , 10 7 bayt

@B sayesinde 3 bayt kaydedildi . Mehta!

tfX>Jh)

Giriş ve çıkış bir basamak dizisidir.

Çevrimiçi deneyin!

Veya tüm test durumlarını doğrulayın .

açıklama

t     % Input string implicitly. Duplicate
f     % Push indices of non-zero digits
X>    % Keep maximum, say k
Jh    % Attach 1j to give [k, 1j]. This is interpreted as an index "k:end"
)     % Index into original string. Display implcitly

C #, 30 28 bayt

Bu JavaScript cevabına dayanarak , bütün kredi tür ona git varsayalım böylece.

golfed

i=a=>a%10<1?10*i(a/10):a%10;

• -2 Emigna sayesinde ()etrafta dolaşarak bytea

J, 27 bayt

10&|`(10*(p%&10))@.(0=10&|)

Xnor'ın formülüne dayanıyor, bu yüzden ona borç veriyor.

Kotlin, 49 bayt

lamda, atanabilir (List<Int>) -> List<Int>

{a->a.slice(a.indexOfLast{it in 1..9}..a.size-1)}

• örtük parametre adı itiçindeindexOfLast
• .. Bina aralıkları için

Perl 5, 12 bayt

11 -nEyerine , artı 1-e

say/(.0*$)/

05AB1E , 9 bayt

RD0Ê1k>£R

Çevrimiçi deneyin! veya Test paketi olarak

açıklama

R          # reverse input
 D         # duplicate
  0Ê       # check each for inequality with 0
    1k     # get the index of the first 1
      >    # increment
       £   # take that many digits from the input
        R  # reverse

Japt , 6 bayt

f".0*$

Çevrimiçi deneyin!

Stax , 5 bayt

æΩ$3╚

Koş ve hata ayıkla

Prosedür:

1. "Çokluğu" 10 ile hesaplayın (Bu, girişin eşit olarak bölüştüğü 10 sayısının sayısıdır)
2. 1 ekleyin.
3. Sağındaki birçok karakteri (dize olarak giriş) saklayın.

05AB1E , 4 bayt

ĀÅ¡θ

Rakam listesi olarak G / Ç.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın (test paketi daha iyi okunabilirlik için bir birleştirme içeriyor).

Açıklama:

Ā     # Python-style truthify each digit in the (implicit) input-list (0 if 0; 1 if [1-9])
      #  i.e. [9,0,4,0,3,0,0] → [1,0,1,0,1,0,0]
 Å¡   # Split the (implicit) input-list on truthy values (1s)
      #  i.e. [9,0,4,0,3,0,0] and [1,0,1,0,1,0,0] → [[],[9,0],[4,0],[3,0,0]]
   θ  # And only leave the last inner list
      #  i.e. [[],[9,0],[4,0],[3,0,0]] → [3,0,0]
      # (after which it is output implicitly as result)

Pyke, 13 11 10 bayt

`1QY0mN%e>

Burada dene!

  QY       -     digits(input)
    0mN    -    map(^, i != 0)
 1     %   -   indecies(^, i == 1)
        e  -  ^[-1]
`        > - str(input)[^:]

11 bayt:

`D\0mN1R%e>

Burada dene!

13 bayt:

`D\0mN_1R@_t>

Burada dene!

Haskell 57 Bayt

f(x:s)a|x=='0'=f s$'0':a|1>0=x:a
t x=f(reverse.show$x)[]

Input    -> Output
t 120    -> "20"
t 30200  -> "200"