搜索： a324692-编号：a324691
|
| |
|
|
324660美元
|
| 从n开始，a（n）是根据以下规则向右移动的总次数。在第k步（k=1,2,3，…），沿零方向移动距离k。如果落在上面的数字之前已经落在上面，请从零开始移动k距离。 |
|
+10
33
|
|
|
|
0, 0, 1, 0, 10, 11, 0, 861, 4, 5, 0, 11, 59, 60, 5, 0, 57, 390898, 7, 8, 66444, 0, 22, 11, 12, 610392, 8, 9, 0, 211, 4434560, 266001, 266000, 266001, 266002, 9, 0, 43, 106674, 106673, 120, 12, 11, 12, 495, 0, 67, 50, 51, 36, 37, 100, 25, 12, 13, 0, 317, 316
(列表;图表;参考;听;历史;文本;内部格式)
|
|
|
|
抵消
|
0,5
|
|
|
链接
|
|
|
|
例子
|
对于n=2，访问的点是2,1，-1，-4,0，从-4移动到0是唯一向右移动的点，因此a（2）=1。
|
|
|
黄体脂酮素
|
（Python）
#点-可能重复的顺序位置
#逃离-我们可能重复从零开始的位置
#卡住——我们从那里移动到已经访问过的地点，可能会重复
def跳闸（n）：
stucklist=列表（）
spotsvisited=[n]
leavingspots=list（）
转动=0
禁止={n}
而n！=0:
转弯+=1
符号=n//abs（n）
st=标志*转弯
如果n-st不在禁止范围内：
n=n-st
其他：
leavingspots追加（n）
如果禁止n+st：
stucklist.append（n）
n=n+st
spotsvisited.追加（n）
禁止。添加（n）
return{'stuck'：stucklist，'spots'：已访问spots，
“转身”：转身，“逃离”：离开地点}
#实际序列
定义a（n）：
d=跳闸（n）
如果d['spots'][i+1]>d['smots'][i]，则返回和（范围（d['turns']）中i的1
|
|
|
交叉参考
|
|
|
|
关键词
|
非n
|
|
|
作者
|
|
|
|
状态
|
经核准的
|
| |
|
|
| |
| |
|
|
|
0, 0, -4, 0, -47, -46, 0, -6362, -23, -22, 0, -32, -471, -470, -29, 0, -218, -4843985, -39, -38, -657367, 0, -101, -57, -56, -7609937, -45, -44, 0, -736, -56168428, -3113136, -3113135, -3113134, -3113133, -51, 0, -190, -1213998, -1213997, -495, -62, -61, -60
(列表;图表;参考;听;历史;文本;内部格式)
|
|
|
|
抵消
|
0,3
|
|
|
评论
|
从n开始，a（n）是根据以下规则达到的最小值。在第k步（k=1，2，3，…）向零方向移动距离k。如果降落在上面的数字以前已经降落过，那么改为从零移动k的距离。请参见A228474号和A248939型. -大卫·纳钦2019年3月15日
目前尚未证明所有轨道是否都是有限的，因此也不清楚所有a（n）是否都是明确定义的。特别是，n=11281的轨道长度未知，但肯定大于32*10^9-M.F.哈斯勒，2019年3月18日
|
|
|
链接
|
|
|
|
配方奶粉
|
|
|
|
例子
|
a（0）=最小{0}=0；
a（1）=最小值{1,0}=0；
a（2）=最小值{2,1，-1，-4,0}=-4；
a（3）=最小值{3,2,0}=0；
a（4）=最小值{4,3,1，-2,2，-3，-9，-16，-8，-17，-7，-18，-6,7,21,6，-10，-27，…}=-47；
a（5）=最小值{5,4,2，-1,3，-2，-8，-15，-7，-16，-6，-17，-5,8,22,7，-9，-26，…}=-46；
a（6）=最小值{6,5,3,0}=0；
a（7）=最小值{7,6,4,1，-3,2，-4,3，-5，-14，-24，-13，-1,12，-2,13,29,46，…}=-6362；
a（8）=最小值{8,7,5,2，-2,3，-3,4，-4，-13，-23，-12,0}=-23；
a（9）=最小值{9,8,6,3，-1,4，-2,5，-3，-12，-22，-11,14,0}=-22。
|
|
|
黄体脂酮素
|
（哈斯克尔）
导入数据。IntSet（singleton、member、insert、findMin、findMax）
a248952 n=a248952_list！！n个
（a248952_list，a248953_list）=解压缩$
映射（\x->minmax 1 x$singleton x）[0..]其中
最小值_ 0 s=（findMin s，findMax s）
minmax k x s=minmax（k+1）y（插入y s），其中
y=x+（如果（x-j）`成员`s，则j else-j）
j=k*符号x
（Python）
#点-可能重复的顺序位置
#逃离-我们可能重复从零开始的位置
#卡住-我们移动到可能重复访问过的位置
def跳闸（n）：
stucklist=列表（）
spotsvisited=[n]
leavingspots=list（）
转动=0
禁止={n}
而n！=0:
转弯+=1
符号=n//abs（n）
st=标志*转弯
如果n-st不在禁止范围内：
n=n-st
其他：
leavingspots追加（n）
如果禁止n+st：
stucklist.append（n）
n=n+st
spotsvisited.追加（n）
禁止。添加（n）
return{'stuck'：stucklist，'spots'：已访问spots，
“转身”：转身，“逃离”：离开地点}
#实际顺序
定义a（n）：
d=跳闸（n）
返回最小值（d[“点”]）
（Python）
（C++）#include<map>
长的A248952型（long n）{long c=0，s，m=0；for（std:：map<long，bool>seen；n；n+=seen[n-（s=n>0？c:-c）]？s:-s）{if（n<m）m=n；seen[n]=true；++c；}返回m；}//M.F.哈斯勒2019年3月18日
|
|
|
交叉参考
|
|
|
|
关键词
|
签名
|
|
|
作者
|
|
|
|
扩展
|
|
|
|
状态
|
经核准的
|
| |
|
|
| |
| |
|
|
|
0, 1, 2, 3, 21, 26, 6, 6843, 8, 14, 10, 72, 365, 366, 14, 15, 352, 4674389, 18, 22, 891114, 21, 102, 23, 31, 7856204, 26, 27, 28, 1700, 61960674, 3702823, 3702824, 3702825, 3702826, 35, 36, 370, 1047903, 1047904, 596, 41, 42, 43, 2976, 45, 341, 260, 261, 123
(列表;图表;参考;听;历史;文本;内部格式)
|
|
|
|
抵消
|
0,3
|
|
|
评论
|
从n开始，a（n）是根据以下规则达到的最大值：除非已达到0，否则在第k步（k=1，2，3，…），向零方向移动k的距离。如果结果之前已经出现过，请将距离k移离零。请参见A228474号和A248939型. -大卫·纳钦2019年3月15日
目前还没有证明所有轨道都是有限的，因此不清楚所有a（n）是否都是明确定义的。特别是，n=11281的轨道长度未知>32*10^9步-M.F.哈斯勒2019年3月18日
|
|
|
链接
|
|
|
|
配方奶粉
|
|
|
|
例子
|
a（0）=最大值{0}=0；
a（1）=最大值{1,0}=1；
a（2）=最大值{2,1，-1，-4,0}=2；
a（3）=最大值{3,2,0}=3；
a（4）=最大值{4,3,1，-2,2，-3，-9，-16，-8，-17，-7，-18，-6,7,21,6，-10，-27，…}=21；
a（5）=最大值{5,4,2，-1,3，-2，-8，-15，-7，-16，-6，-17，-5,8,22,7，-9，-26，…}=26；
a（6）=最大值{6,5,3,0}=6；
a（7）=最大{7,6,4,1，-3,2，-4,3，-5，-14，-24，-13，-1,12，-2,13,29,46，…}=6843；
a（8）=最大值{8,7,5,2，-2,3，-3,4，-4，-13，-23，-12,0}=8；
a（9）=最大值{9,8,6,3，-1,4，-2,5，-3，-12，-22，-11,14,0}=14。
|
|
|
黄体脂酮素
|
（哈斯克尔）
a248953 n=a248953_列表！！n个
（Python）
#点-可能重复的顺序位置
#逃离-我们可能重复从零开始的位置
#卡住-我们移动到可能重复访问过的位置
def跳闸（n）：
stucklist=列表（）
spotsvisited=[n]
leavingspots=list（）
转动=0
禁止={n}
而n！=0:
转弯+=1
符号=n//abs（n）
st=标志*转弯
如果n-st不在禁止范围内：
n=n-st
其他：
leavingspots追加（n）
如果禁止n+st：
stucklist.append（n）
n=n+st
spotsvisited.追加（n）
禁止。添加（n）
return{'stuck'：stucklist，'spots'：已访问spots，
“转身”：转身，“逃离”：离开地点}
#实际顺序
定义a（n）：
d=跳闸（n）
返回最大值（d[“点”]）
（C++）#include<map>
长的A248953型（long n）{long c=0，s，m=n；for（std:：map<long，bool>seen；n；n+=seen[n-（s=n>0？c：-c）]？s：-s）{if（n>m）m=n；seen[n]=true；++c；}return m；}//M.F.哈斯勒2019年3月18日
|
|
|
交叉参考
|
|
|
|
关键词
|
非n
|
|
|
作者
|
|
|
|
扩展
|
|
|
|
状态
|
经核准的
|
| |
|
|
| |
|
|
324665美元
|
| 从n开始，a（n）是根据以下规则访问的否定位置总数。在第k步（k=1,2,3，…），沿零方向移动距离k。如果落在上面的数字之前已经落在上面，请从零开始移动k距离。 |
|
+10
2
|
|
|
|
0, 0, 2, 0, 17, 17, 0, 939, 6, 6, 0, 8, 73, 73, 7, 0, 48, 445544, 10, 10, 57947, 0, 30, 16, 16, 782680, 11, 11, 0, 184, 2650008, 232081, 232079, 232079, 232079, 12, 0, 35, 109811, 109809, 123, 17, 15, 15, 577, 0, 82, 62, 62, 45, 45, 104, 32, 16, 16, 0, 281, 279
(列表;图表;参考;听;历史;文本;内部格式)
|
|
|
|
抵消
|
0,3
|
|
|
链接
|
|
|
|
例子
|
对于n=2，访问的点为2,1，-1，-4,0。由于其中正好有两个是负数，所以我们得到了a（2）=2。
|
|
|
黄体脂酮素
|
（Python）
#点-可能重复的顺序位置
#逃离-我们可能重复从零开始的位置
#卡住-我们移动到可能重复访问过的位置
def跳闸（n）：
stucklist=列表（）
spotsvisited=[n]
leavingspots=list（）
转动=0
禁止={n}
而n！=0:
转弯+=1
符号=n//abs（n）
st=标志*转弯
如果n-st不在禁止范围内：
n=n-st
其他：
leavingspots追加（n）
如果禁止n+st：
stucklist.append（n）
n=n+st
spotsvisited.追加（n）
禁止。添加（n）
return{'stuck'：stucklist，'spots'：已访问spots，
“转身”：转身，“逃离”：离开地点}
#实际顺序
定义a（n）：
d=跳闸（n）
返回和（如果i＜0，则d中的i为1[‘spots’]）
|
|
|
交叉参考
|
|
|
|
关键词
|
非n
|
|
|
作者
|
|
|
|
状态
|
经核准的
|
| |
|
|
| |
|
|
A324680型
|
| 从n开始，a（n）是所有位置中距零的最大距离，根据以下规则，下一次移动时必须重新访问点，如果不存在此类位置，则为零。在第k步（k=1,2,3，…），沿零方向移动距离k。如果降落的数字之前已经降落过，请移动k距离。 |
|
+10
2
|
|
|
|
0, 0, 0, 0, 0, 0, 0, 3442, 0, 0, 0, 27, 140, 139, 0, 0, 84, 3072845, 0, 0, 638385, 0, 0, 0, 0, 4869724, 0, 0, 0, 464, 43807680, 2117461, 2117462, 2117463, 2117464, 0, 0, 24, 696919, 696918, 179, 1, 0, 1, 1920, 0, 148, 86, 85, 84, 83, 190, 63, 0, 0, 0, 1107
(列表;图表;参考;听;历史;文本;内部格式)
|
|
|
|
抵消
|
0,8
|
|
|
链接
|
|
|
|
例子
|
对于n=11，访问的点数为11、10、8、5、1、-4、2、-5、3、-6、4、-7、-19、-32、-18、-3、13、30、12、31、51、72、50、27、51、26、0。我们被迫重新访问的唯一位置是27，这迫使我们返回到51。由于这是唯一一次发生这种情况，它与零的距离也最大，因此a（11）=27。
|
|
|
黄体脂酮素
|
（Python）
#点-可能重复的顺序位置
#逃离-我们可能重复从零开始的位置
#卡住-我们移动到可能重复访问过的位置
def跳闸（n）：
stucklist=列表（）
spotsvisited=[n]
leavingspots=list（）
转动=0
禁止=｛n｝
而n！=0:
转弯+=1
符号=n//abs（n）
st=符号*转弯
如果n-st不在禁止范围内：
n=n-st
其他：
leavingspots追加（n）
如果禁止n+st：
stucklist.append（n）
n=n+st
spotsvisited.追加（n）
禁止。添加（n）
return{'stuck'：stucklist，'spots'：已访问spots，
“转身”：转身，“逃离”：离开地点}
定义最大零（x）：
如果x：
返回最大值（x）
返回0
#实际顺序
定义a（n）：
d=跳闸（n）
return maxorzero（[abs（i）for i in d['stack']]）
|
|
|
交叉参考
|
|
|
|
关键词
|
非n
|
|
|
作者
|
|
|
|
状态
|
经核准的
|
| |
|
|
| |
|
|
324661美元
|
| 从n开始，a（n）是根据以下规则向左移动的总次数。在第k步（k=1,2,3，…），沿零方向移动距离k。如果落在上面的数字之前已经落在上面，请从零开始移动k距离。 |
|
+10
1
|
|
|
|
0, 1, 3, 2, 14, 15, 3, 864, 8, 9, 4, 15, 64, 65, 10, 5, 62, 390904, 13, 14, 66452, 6, 29, 18, 19, 610401, 15, 16, 7, 218, 4434563, 266008, 266007, 266008, 266009, 17, 8, 51, 106681, 106680, 128, 21, 20, 21, 505, 9, 77, 60, 61, 46, 47, 110, 35, 22, 23, 10, 327
(列表;图表;参考;听;历史;文本;内部格式)
|
|
|
|
抵消
|
0,3
|
|
|
链接
|
|
|
|
例子
|
对于n=2，访问的点是2,1、-1、-4,0，从2到1、从1到-1、从-1到-4的移动是左侧唯一的移动，因此a（2）=3。
|
|
|
黄体脂酮素
|
（Python）
#点-可能重复的顺序位置
#逃离-我们可能重复从零开始的位置
#卡住-我们移动到可能重复访问过的位置
def跳闸（n）：
stucklist=列表（）
spotsvisited=[n]
leavingspots=list（）
转动=0
禁止={n}
而n！=0:
转弯+=1
符号=n//abs（n）
st=标志*转弯
如果n-st不在禁止范围内：
n=n-st
其他：
leavingspots追加（n）
如果禁止n+st：
stucklist.append（n）
n=n+st
spotsvisited.追加（n）
禁止。添加（n）
return{'stuck'：stucklist，'spots'：已访问spots，
“转身”：转身，“逃离”：离开地点}
#实际顺序
定义a（n）：
d=跳闸（n）
如果d['spots'][i+1]<d['pots'][i]，则返回和（范围（d['turns']）中i的1
|
|
|
交叉参考
|
|
|
|
关键词
|
非n
|
|
|
作者
|
|
|
|
状态
|
经核准的
|
| |
|
|
| |
|
|
324662美元
|
| 从n开始，a（n）是根据以下规则左移次数和右移次数的差值。在第k步（k=1,2,3，…），沿零方向移动距离k。如果落在上面的数字之前已经落在上面，请从零开始移动k距离。 |
|
+10
1
|
|
|
|
0, 1, 2, 2, 4, 4, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 8, 6, 7, 7, 7, 9, 7, 7, 7, 7, 3, 7, 7, 7, 7, 8, 8, 8, 7, 7, 8, 9, 9, 9, 10, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12
(列表;图表;参考;听;历史;文本;内部格式)
|
|
|
|
抵消
|
0,3
|
|
|
链接
|
|
|
|
例子
|
对于n=2，访问的点是2,1、-1、-4,0，从2到1、从1到-1、从-1到-4的移动是向左的，从-4到0的移动是向右的，因此a（2）=3-1=2。
|
|
|
黄体脂酮素
|
（Python）
#点-位置按顺序排列，可能重复
#逃离-我们可能重复从零开始的位置
#卡住-我们移动到可能重复访问过的位置
def跳闸（n）：
stucklist=列表（）
spotsvisited=[n]
leavingspots=list（）
转动=0
禁止={n}
而n！=0:
转弯+=1
符号=n//abs（n）
st=标志*转弯
如果n-st不在禁止范围内：
n=n-st
其他：
leavingspots追加（n）
如果禁止n+st：
stucklist.append（n）
n=n+st
spotsvisited.追加（n）
禁止。添加（n）
return｛'suck'：灰泥，'spots'：斑点，
“转身”：转身，“逃离”：离开地点}
定义sgn（x）：
返回x//abs（x）
#实际顺序
定义a（n）：
d=跳闸（n）
范围内i的返回和（sgn（d['spots'][i]-d['sports'][1]）
|
|
|
交叉参考
|
|
|
|
关键词
|
非n
|
|
|
作者
|
|
|
|
状态
|
经核准的
|
| |
|
|
| |
|
|
A324663型
|
| 从n开始，a（n）是根据以下规则从零开始的移动次数。在第k步（k=1,2,3，…），沿零方向移动距离k。如果落在上面的数字之前已经落在上面，请从零开始移动k距离。 |
|
+10
1
|
|
|
|
0, 0, 1, 0, 9, 10, 0, 740, 2, 3, 0, 7, 48, 49, 2, 0, 39, 348242, 3, 4, 59273, 0, 12, 5, 6, 523146, 3, 4, 0, 177, 3533234, 241226, 241225, 241226, 241227, 3, 0, 28, 101615, 101614, 93, 5, 4, 5, 420, 0, 49, 34, 35, 23, 24, 84, 13, 4, 5, 0, 262, 261, 260, 221950
(列表;图表;参考;听;历史;文本;内部格式)
|
|
|
|
抵消
|
0,5
|
|
|
链接
|
|
|
|
例子
|
对于n=2，访问的点是2,1，-1，-4,0，除了从-1到-4的移动外，所有移动都从当前位置向零移动，因此a（2）=1。
|
|
|
黄体脂酮素
|
（Python）
#点-可能重复的顺序位置
#逃离-我们可能重复从零开始的位置
#卡住-我们移动到可能重复访问过的位置
def跳闸（n）：
stucklist=列表（）
spotsvisited=[n]
leavingspots=list（）
转动=0
禁止=｛n｝
而n！=0:
转弯+=1
符号=n//abs（n）
st=标志*转弯
如果n-st不在禁止范围内：
n=n-st
其他：
leavingspots追加（n）
如果禁止n+st：
stucklist.append（n）
n=n+st
spotsvisited.追加（n）
禁止。添加（n）
return{'stuck'：stucklist，'spots'：已访问spots，
“转身”：转身，“逃离”：离开地点}
#实际顺序
定义a（n）：
d=跳闸（n）
返回长度（d['lee']）
|
|
|
交叉参考
|
|
|
|
关键词
|
非n
|
|
|
作者
|
|
|
|
状态
|
经核准的
|
| |
|
|
| |
|
|
A324664型
|
| 从n开始，a（n）是距离零的最小距离，根据以下规则，下一步距离零是一步，如果没有这样的移动，则为零。在第k步（k=1,2,3，…），沿零方向移动距离k。如果落在上面的数字之前已经落在上面，请将距离k移离零。 |
|
+10
1
|
|
|
|
0, 0, 1, 0, 3, 1, 0, 5, 4, 1, 0, 7, 6, 1, 4, 0, 7, 8, 7, 1, 2, 0, 5, 4, 1, 2, 7, 1, 0, 13, 2, 1, 10, 1, 1, 7, 0, 5, 1, 3, 2, 1, 10, 1, 2, 0, 17, 16, 1, 14, 1, 2, 11, 10, 1, 0, 1, 1, 17, 1, 15, 1, 1, 1, 11, 10, 0, 4, 1, 2, 1, 1, 1, 15, 1, 13, 1, 1, 0, 2, 1, 1
(列表;图表;参考;听;历史;文本;内部格式)
|
|
|
|
抵消
|
0,5
|
|
|
链接
|
|
|
|
例子
|
对于n=2，访问的点是2,1，-1，-4,0，所有移动都是从当前位置向零移动，从-1移动到-4除外。因此，从零开始移动的最接近零的距离是a（2）=1。
|
|
|
黄体脂酮素
|
（Python）
#点-可能重复的顺序位置
#逃离-我们可能重复从零开始的位置
#卡住-我们移动到可能重复访问过的位置
def跳闸（n）：
stucklist=列表（）
spotsvisited=[n]
leavingspots=list（）
转动=0
禁止={n}
而n！=0:
转弯+=1
符号=n//abs（n）
st=标志*转弯
如果n-st不在禁止范围内：
n=n-st
其他：
leavingspots追加（n）
如果禁止n+st：
stucklist.append（n）
n=n+st
spotsvisited.追加（n）
禁止。添加（n）
return{'stuck'：stucklist，'spots'：已访问spots，
“转身”：转身，“逃离”：离开地点}
定义minorzero（x）：
如果x：
最小返回值（x）
返回0
#实际顺序
定义a（n）：
d=跳闸（n）
return minorzero（[abs（i）代表d中的i['flee']]）
|
|
|
交叉参考
|
|
|
|
关键词
|
非n
|
|
|
作者
|
|
|
|
状态
|
经核准的
|
| |
|
|
| |
|
|
A324666飞机
|
| 从n开始，a（n）是根据以下规则访问的正位置总数。在第k步（k=1,2,3，…）上，向零的方向移动距离k。如果落在上面的数字之前已经落在上面，请从零开始移动k距离。 |
|
+10
1
|
|
|
|
0, 1, 2, 2, 7, 9, 3, 786, 6, 8, 4, 18, 50, 52, 8, 5, 71, 336258, 10, 12, 74949, 6, 21, 13, 15, 438113, 12, 14, 7, 245, 6219115, 299928, 299928, 299930, 299932, 14, 8, 59, 103544, 103544, 125, 16, 16, 18, 423, 9, 62, 48, 50, 37, 39, 106, 28, 18, 20, 10, 363
(列表;图表;参考;听;历史;文本;内部格式)
|
|
|
|
抵消
|
0,3
|
|
|
链接
|
|
|
|
例子
|
对于n=2，访问的点为2,1，-1，-4,0。由于其中正好有两个是正的，所以我们得到了a（2）=2。
|
|
|
黄体脂酮素
|
（Python）
#点-位置按顺序排列，可能重复
#逃离-我们可能重复从零开始的位置
#卡住-我们移动到可能重复访问过的位置
def跳闸（n）：
stucklist=列表（）
spotsvisited=[n]
leavingspots=list（）
转动=0
禁止=｛n｝
而n！=0:
转弯+=1
符号=n//abs（n）
st=标志*转弯
如果n-st不在禁止范围内：
n=n-st
其他：
leavingspots追加（n）
如果禁止n+st：
stucklist.append（n）
n=n+st
spotsvisited.追加（n）
禁止。添加（n）
return{'stuck'：stucklist，'spots'：已访问spots，
“转身”：转身，“逃离”：离开地点}
#实际序列
定义a（n）：
d=跳闸（n）
返回和（如果i>0，则d中的i为1['spots']）
|
|
|
交叉参考
|
|
|
|
关键词
|
非n
|
|
|
作者
|
|
|
|
状态
|
经核准的
|
| |
|
搜索在0.032秒内完成
|
