Посчитайте счастливые билеты в заданном диапазоне


18

В России у нас что-то вроде традиции: нам нравится искать счастливые билеты.

Вот как выглядит обычный билет:

автобусный билет

Как видите, билет имеет шестизначный номер.

Шестизначное число считается счастливым, если сумма первых трех цифр равна сумме трех последних.

Цифре на фото не повезло:

038937
038 937
0 + 3 + 8 = 11
9 + 3 + 7 = 19
11 != 19

Вызов

Учитывая пределы диапазона (включительно), верните количество счастливых номеров билетов, содержащихся в нем.

параметры

  • Ввод: 2 целых числа: первое и последнее целые числа в диапазоне
  • Входы будут между 0 и 999999 включительно
  • Вывод: 1 целое число: сколько счастливых чисел в диапазоне
  • Вы можете взять входные данные и вернуть выходные данные в любом приемлемом формате
  • Допустим, начальные нули для чисел меньше 100000.

Примеры

0, 1 => 1
100000, 200000 => 5280
123456, 654321 => 31607
0, 999999 => 55252

Это поэтому выигрывает самый короткий ответ в байтах на каждом языке.

Обновление: вот счастливчик счастливчик


Ответы:


10

05AB1E , 8 (или 10?) 11 (или 13?) Байтов

Ÿʒ₄n+¦S3ôOË

Попробуйте онлайн или проверьте еще несколько тестов .

ПРИМЕЧАНИЕ. В 05AB1E строки и целые числа взаимозаменяемы, поэтому выходные числа не содержат начальных нулей. Однако это можно исправить с помощью 1 дополнительного байта ( 12 байтов ):

Ÿ₄n+€¦ʒS3ôOË

Попробуйте онлайн или проверьте еще несколько тестов .

+3 байта для исправления ошибок длиной 3 или менее (диапазон [000000, 000999]).

Объяснение:

Ÿ          # Create an inclusive (on both sides) range from the two inputs
           #  i.e. 038920 and 038910 → 
           #   [38910,38911,38912,38913,38914,38915,38916,38917,38918,38919,38920]
 ʒ         # Filter this list by:
  n+      #  Add 1,000,000 to the number
     |     #  And remove the leading 1
           #   i.e. 38910 → 1038910 → '038910'
  S        #  Transform it to a list of digits
           #   i.e. '038910' → ['0','3','8','9','1','0']
   3ô      #  Split it into chunks of length 3
           #   i.e. ['0','3','8','9','1','0'] → [['0','3','8'],['9','1','0']]
     O     #  Sum the digits in both parts
           #   i.e. [['0','3','8'],['9','1','0']] → [11,10]
      Ë    #  Check if they are equal (if they are, they remain in the filtered list)
           #   i.e. [11,10] → 0

РЕДАКТИРОВАТЬ: Кажется, я (и большинство других ответов) немного неверно истолковал задачу и количество цифр спрашивается вместо самих чисел в пределах диапазона. В этом случае }gможно добавить трейлинг (закрыть фильтр и получить количество чисел, оставшихся в отфильтрованном списке), поэтому вместо него будет 10 13 байт :

Ÿʒ₄nS3ôOË}g

Попробуйте онлайн или проверьте еще несколько тестов .


Для диапазона, начинающегося с 1000 (например, [0; 1000]), ваш результат выглядит немного не таким (найдено 1000 счастливых чисел).
августа

1
Если я правильно понимаю задачу, добавление 1.000.000 к каждому числу и удаление первого символа решит эту проблему. Это также избавит от использования R.
Аднан

@ Adnan Спасибо, это действительно хороший способ справиться с этим.
Кевин Круйссен

Это счет, который требуется (и вывод не требует ведущих нулей), поэтому 13.
Джонатан Аллан

9

C # (.NET Core) , 93 + 18 = 111 байт

a=>b=>Enumerable.Range(a,b-a+1).Select(e=>$"{e:D6}").Count(e=>e[0]+e[1]+e[2]==e[3]+e[4]+e[5])

Попробуйте онлайн!

18 байт для using System.Linq;. Я предполагал, что форматы ввода и вывода могут быть гибкими. Поэтому в качестве входных данных я беру два целых числа (диапазон включительно).

Некоторые результаты теста:

a=1000
b=1100

Lucky numbers = 3 [001001, 001010, 001100]

a=2000
b=2100

Lucky numbers = 3 [002002, 002011, 002020]

a=222000
b=222100

Lucky numbers = 7 [222006, 222015, 222024, 222033, 222042, 222051, 222060]

a=0
b=999999

Lucky numbers = 55252 (that's 5.5% of the total numbers)

8

JavaScript (ES6), 66 байт

Принимает ввод в синтаксисе карри (m)(n), где m - исключительная включающая верхняя граница, а n - включающая нижняя граница.

m=>g=n=>n<=m&&![...n+=''].reduce((t,d,i)=>t-=n[i+3]?d:-d,0)+g(-~n)

Попробуйте онлайн!

Как?

Мы проверяем каждое число , просматривая его цифры d i и обновляя общее t :ndit

  • если после этого есть хотя бы 3 оставшиеся цифрыttdi
  • противном случаеtt+di

Если в конце процесса , то n - счастливое число.t=0n


JavaScript (ES6), 67 байт

Тот же формат ввода.

m=>g=n=>n<=m&&!eval([...n/1e3+''].join`+`.split`+.`.join`^`)+g(n+1)

Попробуйте онлайн!

Как?

Для каждого числа :n

  • разделите его на : например,100038937 --> 38.937
  • Привести к строке и разделить: ['3','8','.','9','3','7']
  • присоединиться к +:"3+8+.+9+3+7"
  • заменить +.на ^:"3+8^+9+3+7"
  • оцените как код JS и проверьте, равен ли результат : ( 11 XOR 19 )0241119

Если , десятичная точка не генерируется, и вычисленное выражение является просто положительной суммой (ложь), если только n = 0 (верно). Это ожидаемый результат в обоих случаях.n0(mod1000)n=0


Это было сделано включительно.
Джонатан Аллан

7

Рубин , 56 54 байта

->a,b{(a..b).count{|i|j=i.digits;j[0,3].sum*2==j.sum}}

Попробуйте онлайн!

Метод:

  1. Для каждого числа создает массив цифр (который переворачивается)
  2. Сравнивает сумму первых 3 цифр в массиве (последние 3 цифры), умноженную на 2, с суммой всего массива
  3. Считает числа, для которых две суммы равны

6

Japt , 38 15 байт

õV Ëì ò3n)mx r¥

-23 спасибо Шегги!

Моя первая подача Джапта; спасибо Shaggy за помощь!

Попробуйте онлайн!


Добро пожаловать в Japt! :)
Лохматый

@ Шэгги, спасибо! Это довольно аккуратный язык!
Амфибологическое

Чтобы помочь вам начать . Не стесняйтесь пинговать меня в чате, если у вас есть какие-либо вопросы.
Мохнатый

@ Шэгги Это удивительно. Я определенно многому научился из этого. Планируете ли вы опубликовать его в качестве собственного ответа? Вам следует!
Амфибология

Нет, вы можете иметь это :) Как я уже сказал, чтобы помочь вам начать.
Лохматый

6

Python 3, 117 113 106 135 байтов

Это мой первый ответ, так что я уверен, что есть возможности для улучшения.

def x(a,b):
    n=0
    for i in range(a,b+1):
        if sum(map(int,str(i//1000)))==sum(map(int,str(i%1000))):n+=1
    print(n)
  • -4 байта благодаря WW
  • -7 байт благодаря Асоне Тухиду
  • +29 байт для создания функции

Получает первые три цифры через целочисленное деление, а последние три - по модулю. Первое и последнее целые числа в диапазоне вводятся как аргументы xфункции, как aи b, соответственно. Выход есть n, распечатан.

Ungolfed:

def x(a, b):
    n = 0
    for i in range(a, b + 1):
        if sum(map(int, str(i // 1000))) == sum(map(int, str(i % 1000))):
            n += 1
    print(n)

1
Вы не нуждаетесь в отступе после if btw. Кроме того, вероятно, будет дешевле преобразовать в строку, прежде чем вы берете первые или последние 3 цифры.
Пшеничный волшебник

2
Добро пожаловать в PPCG! Ознакомьтесь с советами по игре в гольф на Python , где вы найдете советы и рекомендации. Для большинства языков есть аналогичная тема, если вам интересно. Кроме того, хорошей практикой является включение ссылки TIO в качестве демонстрации.
Asone Tuhid

Я бы предложил заменить n=n+1на n+=1и переместить его сразу после оператора if ( if...:n+=1)
Asone Tuhid

Вы не можете принять aи bкак заранее объявленные переменные. Вы либо должны иметь функцию, либо взять их с помощью ввода
Джо Кинг,

1
Если вы сохраняете это как функцию, вы можете переместить n=0деталь в заголовок, напримерdef x(a,b,n=0)
Джо Кинг,

6

R , 93 86 байт

Укороченная логика в конце комплиментов @ Giuseppe /

function(a,b){for(i in sprintf("%06d",a:b)){x=utf8ToInt(i);F=F+!sum(x[1:3]-x[4:6])}
F}

Попробуйте онлайн!

Целочисленные входы. Дополните их 0. Преобразовать в шесть кодовых точек ASCII. Злоупотреблять Fвстроенным.


Я возвращаю АН из этой функции.
Роберт С.

Я откатил редактирование. Новая версия завершается с ошибкой 0 из-за scipenпроблемы. Ну что ж.
нгм



6

Шелуха , 12 байт

#ȯ§¤=Σ↓↑3↔d…

Попробуйте онлайн!

объяснение

#(§¤=Σ↓↑3↔d)…  -- example input: 100000 101000
            …  -- inclusive range: [100000,100001..100999,101000]
#(         )   -- count elements where (example with 100010)
          d    -- | digits: [1,0,0,0,1,0]
         ↔     -- | reversed: [0,1,0,0,0,1]
  §     3      -- | fork elements (3 and [0,1,0,0,0,1])
       ↑       -- | | take: [0,1,0]
      ↓        -- | | drop: [0,0,1]
   ¤=          -- | > compare the results by equality of their
     Σ         -- | | sums 1 == 1
               -- | : 1
               -- : 3

Кажется, у вашего решения есть тот же недостаток, что и у моей первоначальной версии: [000000, 001001]должно привести к 2( 000000и 001001), но 1001вместо этого приведет к . (Я добавил 1,000,000и удалил трейлинг 1как исправление для этого, хотя не уверен, насколько это просто / эффективно по байту, как в Husk.)
Кевин Круйссен

1
@KevinCruijssen: Я думаю, что я помню, что этот вызов изначально был неясным, у меня нет времени на его изучение, поэтому я просто откатился к своему первоначальному представлению, которое кажется правильным.
ბიმო

5

Древесный уголь , 15 байт

ILΦ…·NN⁼Σι⊗Σ÷ιφ

Попробуйте онлайн!Ссылка на подробную версию кода. Редактировать: я первоначально думал, что это был список счастливых чисел, которые требовались. Это может быть сделано в 14 байтах (удаляя , который занимает длину списка), или в 20 байтах, если вы хотите хорошее форматирование:

EΦ…·NN⁼Σι⊗Σ÷ιφ﹪%06dι

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

    NN                  Input the range endpoints
  …·                    Inclusive range
 Φ                      Filter
        ι               Current value
       Σ                Sum of digits
            ι           Current value
             φ          Predefined variable 1000
           ÷            Integer divide
          Σ             Sum of digits
         ⊗              Doubled
      ⁼                 Equals
E                       Map over results
                   ι    Current value
               %06d     Literal string
              ﹪         Format value
                        Implicitly print each result on its own line


3

Python 3 , 89 86 байт

-2 спасибо мистеру Xcoder.

-3 Вдохновляющие от Асоне Тухид ответили.

lambda a,b:sum(sum(map(int,str(i)))==2*sum(map(int,str(i)[-3:]))for i in range(a,b+1))

Результаты тестов:

Example 1 : 
a = 0
b = 1
Lucky numbers : 1 

Example 2 : 
a = 100000
b = 200000
Lucky numbers : 5280 

Example 3 : 
a = 123456
b = 654321
Lucky numbers : 31607 

Example 3 : 
a = 0
b = 999999
Lucky numbers : 55252 

Попробуйте онлайн!


1
В подсчетной версии sumможно сделать любой генератор, чтобы скобки [...] не понадобились
Mr. Xcoder

range(a,b+1)В спецификации теперь указано «включительно» (если бы вы не могли использовать *rее a,b, кстати, см. мой ответ по Python 2). Также обратите внимание, что спецификация теперь подтверждает, что это действительно должен быть счетчик, который выводится.
Джонатан Аллан

3

MATL , 24 байта

&:1e3&\,!'%03d'&V2&sw]=s

Попробуйте онлайн!

(-2 байта благодаря Луису Мендо.)

&: - Сделайте инклюзивный диапазон между двумя данными числами

1e3&\ - 'divrem' - разделите на 1000 и получите напоминания и коэффициенты в двух массивах.

, - сделать дважды

!'03d'&V - транспонировать и преобразовывать каждое значение в строку шириной в три ширины

&s - суммировать значения каждой строки

w - переключиться, чтобы вывести массив напоминаний и сделать это снова на этом

] - конец цикла

= - проверить на равенство (возвращает 1 в местах, где массивы равны)

s - суммируйте те, чтобы получить количество (неявный вывод)


3

Котлин , 152 119 байт

{a:Int,b:Int->(a..b).map{String.format("%06d",it)}.filter{it[0].toInt()+it[1].toInt()+it[2].toInt()==it[3].toInt()+it[4].toInt()+it[5].toInt()}.count()}

Попробуйте онлайн!

Взять два целых числа, а затем преобразовать их в шесть строк символов и сосчитать.

Оптимизировано это благодаря Маззи и его решению до 119 байт.

{a:Int,b:Int->(a..b).count{val d="%06d".format(it);(d[0]-'0')+(d[1]-'0')+(d[2]-'0')==(d[3]-'0')+(d[4]-'0')+(d[5]-'0')}}

Попробуйте онлайн!


1
Вы можете {a:Int,b:Int->(a..b).map{"%06d".format(it)}.filter{(it[0]-'0')+(it[1]-'0')+(it[2]-'0')==(it[3]-'0')+(it[4]-'0')+(it[5]-'0')}.count()}
сжать

3

постоянный ток , 44 байта

sb[d]sD[dA00~[rA~rA~++rx]dx=D1+dlb!<L]dsLxkz

Принимает два аргумента из остального пустого стека, выводит на верх стека.

Попробуйте онлайн!

Умный бит здесь - это использование безымянного (то есть не сохраненного) макроса, который дублируется перед выполнением для запуска собственной копии в другой трехзначной части.

объяснение

Внутренний макрос [rA~rA~++rx]имеет эффект «вычислить сумму цифр трехзначного числа, которое находится сверху в стеке, а затем выполнить исходную вершину стека как макрос».

Основная программа:

sb             Saves the upper bound as b so we'll know when to quit
[d]sD          Defines the macro D, which contextually is "increment stack depth"
[              Start the main loop - the next number to test is on top 
  d              Make a copy to increment later for loop purposes
  A00            The literal "1000"
  ~              Quotient and remainder, so "123456" is now "123 456"
  [rA~rA~++rx]d  Stack is now "123 456 M M", where M is the anonymous macro
  x              Run M on the stack "123 456 M", which (see definition 
                 above) ends up running M on the stack "123 15", which
                 leaves "15 6" (and executes the 6, which is a no-op)
  =D             If the two sums were equal, increment the stack depth
  1+             Increment the current test number
  dlb!<L         Loop unless the test number is now larger than b
]dsLx          Name and start the loop
kz             Current depth is 1+answer, so throw away top and return

3

Паскаль (FPC) , 163 153 байта

var a,b:Int32;begin read(a,b);for a:=a to b do if a div$186A0+a div$2710mod$A+a div$3E8mod$A=a div$64mod$A+a div$Amod$A+a mod$Athen b:=b+1;write(b-a)end.

Попробуйте онлайн!

объяснение

Вот сначала немного нормальный код:

var a,b,i,s,c,d:Int32;
begin
  read(a,b);
  s:=0;
  for i:=a to b do begin
    c:=i div 1000;
    d:=i mod 1000;
    if c div 100+(c div 10) mod 10+c mod 10=d div 100+(d div 10) mod 10+d mod 10 then begin s:=s+1; {writeln(i)} end;
  end;
  write('There are ',s,' numbers');
end.

Попробуйте онлайн!

Затем я злоупотребил поведением цикла for:

  • значения цикла устанавливаются заранее (от aдо b), поэтому aих можно использовать как переменную цикла, отбрасывая i;
  • в конце цикла for переменная цикла остается в конечном значении (значение bперед циклом). Я использовал bв качестве контейнера, увеличивая его, когда счастливое число найдено и в конце цикла bнаходится вдали от своего старого значения на количество счастливых чисел, поэтому b-aдает правильный результат. Это упало s.

Замена dоперациями непосредственно на aсокращает цикл. Замена cоперациями непосредственно на aдозу не сокращает цикл, но, после сброса d, цикл beginиend ненужны, и я закончил с использованием только 2 переменных :)

$запускает шестнадцатеричные константы в коде гольфа. Хотя они не сохраняют байты, они исключают пробелы, необходимые перед десятичными константами.


3

Java (OpenJDK 8) , 162 байта

... заимствует из примера Kotlin выше.

import java.util.stream.IntStream;

(a,b)->IntStream.range(a,b+1).mapToObj(i->String.format("%06d",i).getBytes()).filter(c->c[0]+c[1]+c[2]==c[3]+c[4]+c[5]).count();

Попробуйте онлайн!

Сравнение суммы байтов строки так же хорошо, как и суммирование фактических цифр.


2
Вы можете сохранить байт с помощью curry ( a->b->), но вам нужно будет полностью квалифицироваться, IntStreamтак как его нет java.lang.
Якоб

Добро пожаловать в PPCG! Как упоминал @Jakob, импорт является частью байтового подсчета, поэтому вам придется добавить java.util.stream.перед IntStreamвашим кодом и байтовым счетчиком. Как также упоминал Jakob , вы можете сохранить байт, используя a->b->, и вы также можете сохранить некоторые дополнительные байты, изменив String.formatна "".format. Попробуйте онлайн: 139 байт . Хороший первый ответ, хотя. +1 от меня. Приятного пребывания!
Кевин Круйссен

2

PHP , 131 байт

<?$f='array_sum(str_split(str_split(sprintf("%06d",$i),3)[';for($i=$argv[1]-1;$i++<$argv[2];)eval("\$a+=$f 0]))==$f 1]));");echo$a;

Чтобы запустить это:

php -n <filename> <from> <to>

Пример:

php -n lucky_tickets.php 100 100000

Или попробуйте онлайн!


2

Perl 6 , 51 49 байт

{+grep {[==] .flip.comb[^3,3..*]>>.sum},$^a..$^b}

Попробуйте онлайн!

Блок анонимного кода, который принимает два числа и возвращает количество счастливчиков. Тайм-аут для больших входов


2

Желе ,  9  8 байт

-1 спасибо Деннису ( rµ...E)S-> r...E€Sтак как все векторизуется.)

rdȷD§E€S

Диадическая ссылка, принимающая две конечные точки диапазона (в любом случае), которая дает количество счастливых билетов.

Попробуйте онлайн!Или посмотрите тестовый набор

Как?

Обратите внимание, что для любого неотрицательного целого числа меньше 1000000, Nмы можем получить два числа с цифрами, которые суммируются с необходимыми значениями для проверки с помощью целочисленного деления на 1000
(уступая, скажем, Иксзнак равноN1000)
и его остаток
(скажем,Yзнак равноNмодификация1000)
... то естьNзнак равно1000×Икс+Y

Теперь мы хотим сравнить суммы цифр Икс и Y для каждого N в диапазоне и считайте те, которые равны.

rdȷD§E€S - Link: integer a; integer b
r        - inclusive range [a,b] (either [a,a+1,a+2,...,b] or [a,a-1,a-2,...,b])
         -                              e.g.: 0       or 78        or 7241
  ȷ      - literal 1000
 d       - divmod (vectorises)                [0,0]      [0,78]       [7,241]
   D     - to decimal lists (vectorises)      [[0],[0]]  [[0],[7,8]]  [[7],[2,4,1]]
    §    - sum each (vectorises)              [0,0]      [0,15]       [7,7]
     E€  - for €ach: all equal?               1          0            1
       S - sum (counts the 1s in the resulting list)

E€Sсохраняет µ.
Деннис

@ Денис, да, я работал над другим решением, которое не векторизовало все на этом пути!
Джонатан Аллан

2

Powershell, 85 байт

($args[0]..$args[1]|%{'{0:D6}'-f$_}|?{+$_[0]+$_[1]+$_[2]-eq+$_[3]+$_[4]+$_[5]}).count

Тестовый скрипт:

$f = {

($args[0]..$args[1]|%{'{0:D6}'-f$_}|?{+$_[0]+$_[1]+$_[2]-eq+$_[3]+$_[4]+$_[5]}).count

}

@(
    ,((0,1), 1)
    ,((1000,2000), 3)
    ,((2000,3000), 6)
    ,((10000, 20000), 282)
    ,((101000, 102000), 6)
    ,((201000, 202000), 10)
    ,((901000, 902000), 63)
    ,((100000, 200000), 5280)
    ,((123456, 654321), 31607)
    #,((0, 999999), 55252)
) | % {
    $c, $e = $_
    "      $c"
    $r = &$f $c[0] $c[1]
    "$($e-eq$r): actual=$r expected=$e"
}

Выход:

      0 1
True: actual=1 expected=1
      1000 2000
True: actual=3 expected=3
      2000 3000
True: actual=6 expected=6
      10000 20000
True: actual=282 expected=282
      101000 102000
True: actual=6 expected=6
      201000 202000
True: actual=10 expected=10
      901000 902000
True: actual=63 expected=63
      100000 200000
True: actual=5280 expected=5280
      123456 654321
True: actual=31607 expected=31607

Powershell? Я действительно этого не
ожидал

2

Котлин, 95 байт

{a:Int,b:Int->(a..b).count{val d="%06d".format(it);d.chars().sum()==2*d.take(3).chars().sum()}}

.kt для теста:

var  f = {a:Int,b:Int->(a..b).count{val d="%06d".format(it);d.chars().sum()==2*d.take(3).chars().sum()}}

fun main(args: Array<String>) {
    println(f(0,1))             // 1
    println(f(1000,2000))       // 3
    println(f(2000,3000))       // 6
    println(f(101000, 102000))  // 6
    println(f(201000, 202000))  // 10
    println(f(901000, 902000))  // 63
    println(f(10000, 20000))    // 282
    println(f(100000, 200000))  // 5280
    println(f(123456, 654321))  // 31607
    println(f(0, 999999))       // 55252
}

объяснение

Подсчитайте числа из диапазона, в котором сумма всех цифр равна двойной сумме первых 3 цифр.



1

Python 2 ,  83  80 байт

-3 с помощью наблюдения Асоне Тухида - иди отдавай должное!

lambda a,b:sum(sum(map(int,`v/1000`))*2==sum(map(int,`v`))for v in range(a,b+1))

Попробуйте онлайн!

Так же, как мой ответ Jelly (но входные данные должны быть отсортированы здесь, т.е. a<=b)


75 байтов для ввода a, b+1(то есть диапазон исключает правую границу):

lambda*r:sum(sum(map(int,`v/1000`))*2==sum(map(int,`v`))for v in range(*r))

Попробуй это


1

Clojure, 102 байта

#(count(for[i(range %(inc %2)):when(=(let[d(map int(format"%06d"i))](apply +(map -(drop 3 d)d)))0)]i))

Смешивание строк и математика не слишком весело.



1

C (gcc), 90 88 байтов

l=10;u(c,k,y){for(y=0;c<=k;)c++%l+c/l%l+c/100%l-c/1000%l-c/10000%l-c/100000%l?:++y;c=y;}

Порт моего Java ответа . Попробуйте это онлайн здесь . Благодаря Celercat для игры в гольф два байта.

Ungolfed:

l=10; // constant, we will be using the number 10 rather a lot
u(c, k, // function returning an integer and taking two integer arguments: lower and upper bound
  y) { // abusing the argument list to declare a variable of type integer: the number of lucky tickets found in the range
    for(y = 0; c <= k; ) // set count to 0 and loop through the range
        c++ %l + c/l %l + c/100 %l // if the digit sum of the second half of the ticket number ...
        - c/1000 %l - c/10000 %l - c/100000 %l // ... is the same as the digit sum of the first half ...
        ?: ++y; // ... it's a lucky ticket: increment the count
    c = y; // return the count
}

Предлагайте L'✐'вместо 10000и назначайте 10переменную.
потолок кошка

@ceilingcat Мне нравится, что это дает мне дополнительное имя переменной, но я не смог сохранить ни одного байта, назначив 10: bit.ly/2O5ND2Y. Что касается L'…'уловки, это аккуратно; но это экономит байты? Мне кажется, это многобайтовый символ, поэтому при сохранении символов он не может сохранять байты ... или так?
OOBalance

@ceilingcat Моя ошибка, два байта можно сохранить, назначив 10 переменной. Спасибо.
OOBalance

1

Java 8, 101 99 байт

u->l->{int n=0,d=10;for(;l<=u;)if(l++%d+l/d%d+l/100%d==l/1000%d+l/10000%d+l/100000%d)++n;return n;}

Другой подход, чем другой ответ Java . Вместо того, чтобы использовать потоки и строки, это использует цикл и оценивает числа напрямую. Попробуйте это онлайн здесь .

Благодаря Celercat для игры в гольф два байта.

Ungolfed:

u -> l -> { // lambda taking two integer arguments in currying syntax and returning an integer
    int n = 0, // the counter
        d = 10; // auxiliary constant, we will be using the number 10 rather a lot
    for(; l <=u ; ) // loop over all ticket numbers in the range
        if(l++ %d + l/d %d + l/100 %d // if the digit sum of the second half of the number ...
           == l/1000 %d + l/10000 %d + l/100000 %d) // ... is the same as the digit sum of the first half ...
            ++n; // ... it's a lucky ticket, add 1 to the counter
    return n; // return the count
}

1

VBA (Excel), 159 байт

Использование Immediate Window и Cells в [A1] [A2]качестве входных данных.

c=[A1]-[A2]:d=IIf(c<0,[A1],[A2]):For x=d To d+Abs(c):e=String(6-Len(x),"0")&x:For y=1To 3:i=i+Mid(e,y,1):j=j+Mid(e,7-y,1):Next:z=IIf(i=j,z+1,z):i=0:j=0:Next:?z

1

F #, 110 байтов

let t=string>>Seq.sumBy(int>>(-)48)
let r s e=Seq.where(fun n->t(n/1000)=t(n-(n/1000)*1000)){s..e}|>Seq.length

Попробуйте онлайн!

tпреобразует строку в числа и суммирует их. rпринимает диапазон чисел от sдо eи отфильтровывает числа, которым не повезло. Первые три цифры собраны n/1000. Вторые три цифры вычисляются с помощью n-(n/1000)*1000.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.