Оскільки цифри і послідовності Фібоначчі здаються популярною темою для кодового гольфу, я подумав, що кодувати гольф з числами Кіта може бути цікавим завданням .

Тому я пропоную завдання, щоб створити функцію, яка приймає ціле число і повертає істинне або хибне залежно від числа, це число Кіта чи ні.

Більше про номери Кіта

У рекреаційній математиці число Кіта або число рефігіту (коротке для повторюваної цифри, подібної Фібоначчі) - це число у такій цілій послідовності: 14, 19, 28, 47, 61, 75, 197, 742, 1104, 1537, 2208, 2580,…

У Numberphile є відео, в якому пояснюється, як обчислити число Кіта. Але в основному ви берете цифри числа. Додайте їх разом, а потім візьміть останні цифри початкового числа та додайте їх до суми обчислення, промийте та повторіть. І приклад, щоб це було зрозуміло.

14
1 + 4 = 5
4 + 5 = 9
5 + 9 = 14

Вхідні дані

Ціле число.

Вихідні дані

Щоправда, якщо число - це число Кіта. Неправдиво, якщо його немає ..

GolfScript ( 31 25 символів)

..[10base{.{+}*+(\}@*]?0>

Введіть як ціле число на вершині стека. Вихід 0 (помилково) або 1 (вірно). Демонстрація в Інтернеті, в якій перераховані номери Кіта до 100.

Пітон ( 78 75)

a=input()
n=map(int,`a`)
while a>n[0]:n=n[1:]+[sum(n)]
print(a==n[0])&(a>9)

n=n[1:]+[sum(n)]робить усі чари. Він бере кожен елемент, але перший елемент n, наклеюється на суму n(з першим пунктом), після чого встановлює це значення n.

Я б хотів, щоб ви могли зателефонувати listна ціле число та розділити цифри.

Повертається Falseна всіх введеннях нижче 10. Може бути на 8 символів коротшим, якщо він повернувся True.

GolfScript, 32 29 символів

...[10base\{.{+}*+(\}*]&,\9>&

Реалізація GolfScript, яку можна протестувати в Інтернеті . Вхід подається як верхній елемент на стеку, і він повертає 0 (тобто хибний) або 1 відповідно.

APL, 36 34 39 36 33 29 27

*+/x={(∇⍣(⊃x>¯1↑⍵))⍵,+/⍵↑⍨-⍴⍕x}⍎¨⍕x←⎕

Виведіть, 1якщо Кіт, 0інакше

GolfScript знову вражає !!

Редагувати

+/x={(∇⍣(x>⊢/⍵))⍵,+/⍵↑⍨-⍴⍕x}⍎¨⍕x←⎕

Використовуючи Right-Reduction ( ⊢/) замість Take minus 1 ( ¯1↑), безпосередньо зберігаючи 1 char та побічно економте 1 від Disclose (⊃ )

Пояснення

⍎¨⍕x←⎕приймає оцінений вхід (трактується як число) і присвоює йому x. Перетворює його в масив символів (він же "рядок" в інших мовах) і проходить цикл через кожен символ (цифру), перетворюючи його в число. Таким чином, це призводить до числового масиву цифр.

{(∇⍣(x>⊢/⍵))⍵,+/⍵↑⍨-⍴⍕x}є основною функцією "циклу":
+/⍵↑⍨-⍴⍕xбере останні ⍴⍕x(без цифр x) числа з масиву та підсумовує їх.
⍵,з'єднує його в кінець масиву.
(x>⊢/⍵)перевірте, чи останнє число в масиві (який ще не +/⍵↑⍨-⍴⍕xз'єднався) менше xта повертає 1чи 0
∇⍣виконує цю функцію на новому масиві стільки разів. Отже, якщо останнє число менше, ніж xця функція повторюється. В іншому випадку просто поверніть новий масив

Після виконання функції масив містить суми до того моменту, коли 2 числа чи більше або дорівнюють x(наприклад, 14буде генерувати 1 4 5 9 14 23, 13буде генерувати 1 3 4 7 11 18 29)
Нарешті перевірити, чи кожне число дорівнює, xі вивести суму отриманого двійкового масив.

Редагувати

1=+/x={(∇⍣(x>⊢/⍵))⍵,+/⍵↑⍨-⍴⍕x}⍎¨⍕x←⎕

Додано 2 символи :-( для виведення даних, 0якщо вхід одноцифровий

Ще одна редакція

+/x=¯1↓{(∇⍣(x>⊢/⍵))1↓⍵,+/⍵}⍎¨⍕x←⎕

Пояснення

Тепер функція скидає перше число ( 1↓) з масиву замість того, щоб брати останнє ⍴⍕x( ↑⍨-⍴⍕x).
Однак такий підхід робить 1=не адекватним обробляти одноцифрові числа. Тож тепер випадає останнє число з масиву, перш ніж перевірити рівність x, додати 1 знак

Ви здогадалися: EDIT

+/x=1↓{1↓⍵,+/⍵}⍣{x≤+/⍵}⍎¨⍕x←⎕

Порівняно xз нещодавно доданим елементом замість останнього останнього, тому випадання першого (замість останнього) елемента перед перевіркою рівності xє достатньою, збереження знаку мінус. Зберігає ще 3, використовуючи іншу форму оператора живлення (⍣ )

І з’являється відповідь на 25 знаків (Orz)

Остання редакція

x∊1↓{1↓⍵,+/⍵}⍣{x≤+/⍵}⍎¨⍕x←⎕

Не можу повірити, що я пропустив це.
Не можна більше гольфу.

Загальний Лісп, 134

CL часом може бути досить нечитабельним.

(defun k(n)(do((a(map'list #'digit-char-p(prin1-to-string n))(cdr(nconc a(list(apply'+ a))))))((>=(car a)n)(and(> n 9)(=(car a)n)))))

Деякі форматування, щоб уникнути горизонтальної прокрутки:

(defun k(n)
  (do
    ((a(map'list #'digit-char-p(prin1-to-string n))(cdr(nconc a(list(apply'+ a))))))
    ((>=(car a)n)(and(> n 9)(=(car a)n)))))

Тест:

(loop for i from 10 to 1000
      if (k i)
      collect i)

=> (14 19 28 47 61 75 197 742)

F # - 184 символів

Я сподіваюся, що це нормально, що я буду брати участь у власному виклику.

let K n=
let rec l x=if n<10 then false else match Seq.sum x with|v when v=n->true|v when v<n->l(Seq.append(Seq.skip 1 x)[Seq.sum x])|_->false
string n|>Seq.map(fun c->int c-48)|>l

Редагувати Виправлена ​​помилка щодо невеликої кількості.

К, 55

{(x>9)&x=*|a:{(1_x),+/x}/[{~(x~*|y)|(+/y)>x}x;"I"$'$x]}

.

k)&{(x>9)&x=*|a:{(1_x),+/x}/[{~(x~*|y)|(+/y)>x}x;"I"$'$x]}'!100000
14 19 28 47 61 75 197 742 1104 1537 2208 2580 3684 4788 7385 7647 7909 31331 34285 34348 55604 62662 86935 93993

PowerShell: 120 128 123 111 110 97

$j=($i=read-host)-split''|?{$_};While($x-lt$i){$x=0;$j|%{$x+=$_};$null,$j=$j+$x}$x-eq$i-and$x-gt9

$i=read-host приймає дані від користувача, зберігає його в $ i.

$j=(... )-split''|?{$_}розбиває цифри з $ i на масив і зберігає їх у $ j.

Дякую Райнанту, що вказав, що -ne''це непотрібно.

While($x-lt$i) встановлює наступний цикл, схожий на Fibonnaci, для запуску, поки змінна сума, $ x, не досягне або перевищить $ i.

$x=0 нулі out $ x, тому він готовий до використання для підбиття підсумків (необхідний, коли цикл повертається навколо).

$j|%{$x+=$_} використовує цикл ForEach-Object для додавання значень з $ j в $ x.

$null,$j=$j+$x зміщує значення в $ j вліво, відкидаючи перше, додаючи $ x.

Так! Нарешті я придумав коротший спосіб змінити і додавати, і отримав цей сценарій під 100!

$x-eq$i після завершення циклу while перевіряється, якщо значення суми, $ x, дорівнює початковому значенню, $ i - загалом вказує на число Кіта.

-and$x-gt9 визнає недійсними одноцифрові числа, нульові та від’ємні числа, які не можуть бути Кіт-Числами.

Цей сценарій трохи "безладний". Він може витончено обробити $ i та $ j, залишившись, але вам потрібно буде очистити $ x між прогонами.

Завдяки Кіту Хілу та mjolinor за деякі методи розбиття чисел на цифри, які використовувались у попередніх версіях цього сценарію. Поки вони не в остаточній версії, вони все ж забезпечили чудовий досвід навчання.

Рубі, 82

def keith?(x)
  l="#{x}".chars.map &:to_i
  0while(l<<(s=l.inject :+)).shift&&s<x
  (s==x)&l[1]
end

Підозрюваний Python - кращий інструмент для цього.

С, 123

k(v){
    int g[9],i,n,s,t=v;
    for(n=s=0;t;t/=10)s+=g[n++]=t%10;
    for(i=n;s<v;){
        i=(i+n-1)%n;
        t=g[i];g[i]=s;s=s*2-t;
    }
    return n>1&&s==v;
}

тест за допомогою джгута:

main(i){
    for(i=0;i<20000;i++)
        if(k(i)) printf("%d ",i);
}

дає:

14 19 28 47 61 75 197 742 1104 1537 2208 2580 3684 4788 7385 7647 7909

R, 116

Зрив Python:

a=scan();n=as.numeric(strsplit(as.character(a),"")[[1]]);while(a>n[1])n=c(n[-1],sum(n));if((n[1]==a)&&(a>9))T else F

Перл, 90

sub k{$-=shift;$==@$=split//,$-;push@$,eval join'+',@$[-$=..-1]while@$[-1]<$-;grep/$-/,@$}

Весела вправа! Я знаю, що це старий пост, але я помітив, що Perl відсутня!

Я впевнений, що я можу вдосконалити те, як будувати це, щоб перетравити інші відповіді більш ретельно, тому я, ймовірно, перегляну це!

Малий розмова - 136 знаків

 [:n|s:=n asString collect:[:c|c digitValue]as:OrderedCollection.w:=s size.[n>s last]whileTrue:[s add:(s last:w)sum].^(s last=n and:n>9)]

Надіслати цей блок value:

Ява - 1437 рік

import java.io.*;
class keith
{
    public int reverse(int n)
    {
        int i,c=0;
        while(n>0)
        {
            c=(c*10)+(n%10);
            n/=10;
        }
        return(c);
    }
    public int countdigit(int n)
    {
        int i,c=0;
        while(n>0)
        {
            c++;
            n/=10;
        }
        return(c);
    }
    public void keith_chk()throws IOException
    {
        BufferedReader br=new BufferedReader(
        new InputStreamReader(System.in));
        int n,digi,r,p=0,a,tot=0,i;
        System.out.print("Enter number :-");
        n=Integer.parseInt(br.readLine());
        digi=countdigit(n);

        int ar[]=new int[digi+1];
        r=reverse(n);
        while(r>0)
        {
            a=r%10;
            ar[p++]=a;
            tot=tot+a;
            r/=10;
        }
        ar[p]=tot;
        while(true)
        {
            for(i=0;i<=p;i++)
            System.out.print(ar[i]+"\t");
            System.out.println(); 
            if(tot == n)
            {
                System.out.print("Keith Number....");
                break;
            }
            else if(tot > n)
            {
                System.out.print("Not Keith Number.....");
                break;
            }
            tot=0;
            for(i=1;i<=p;i++)
            {
                ar[i-1]=ar[i];
                tot=tot+ar[i];
            }
            ar[p]=tot;
        }
    }
}

Python3 104

#BEGIN_CODE
def k(z):
 c=str(z);a=list(map(int,c));b=sum(a)
 while b<z:a=a[1:]+[b];b=sum(a)
 return(b==z)&(len(c)>1)
#END_CODE score: 104

print([i for i in filter(k, range(1,101))])  #[14, 19, 28, 47, 61, 75]

І це функція;)

Пітон - 116 символів

Насправді не експерт у кодегольфі, тож у вас це - моя перша спроба.

x=input();n=`x`;d=[int(i)for i in n];f=d[-1]
while f<x:d+=[sum(d[-len(n):])];f=d[-1]
if f==x>13:print 1
else:print 0

Внесіть 2 зміни для функції:

• Зміна print наreturn
• Призначте xпараметр

PS I друге @ beary605 - додайте вбудований для розділення цифр / символів / що завгодно.

Рубі (з ООП)

class Recreationalmathematics
def Check_KeithSequence(digit) 
    sequence,sum=digit.to_s.split(//).to_a,0
    while(sum<digit) do
        sum=0
        sequence.last(digit.to_s.size).each{|v|  sum=sum+v.to_i}
        sequence<<sum
    end 
    return (sum==digit)?"true":"false" 
end
end
test = Recreationalmathematics.new
puts test.Check_KeithSequence(197)
puts test.Check_KeithSequence(198)