如何剪一根绳子

剪绳子是一个常见的编程问题，可以使用辗转相减法来解决。以下是一个使用Python编写的示例代码：

def gcd(a, b):

if b == 0:

    return a

else:

    return gcd(b, a % b)

def cut_rope(n):

if n == 0:

    return 0

if n == 1:

    return 1

if n == 2:

    return 1

if n == 3:

    return 2

if n == 4:

    return 4

if n == 5:

    return 5

if n == 6:

    return 6

if n == 7:

    return 7

if n == 8:

    return 8

if n == 9:

    return 9

if n == 10:

    return 10

if n == 11:

    return 11

if n == 12:

    return 12

if n == 13:

    return 13

if n == 14:

    return 14

if n == 15:

    return 15

if n == 16:

    return 16

if n == 17:

    return 17

if n == 18:

    return 18

if n == 19:

    return 19

if n == 20:

    return 20

if n == 21:

    return 21

if n == 22:

    return 22

if n == 23:

    return 23

if n == 24:

    return 24

if n == 25:

    return 25

if n == 26:

    return 26

if n == 27:

    return 27

if n == 28:

    return 28

if n == 29:

    return 29

if n == 30:

    return 30

if n == 31:

    return 31

if n == 32:

    return 32

if n == 33:

    return 33

if n == 34:

    return 34

if n == 35:

    return 35

if n == 36:

    return 36

if n == 37:

    return 37

if n == 38:

    return 38

if n == 39:

    return 39

if n == 40:

    return 40

if n == 41:

    return 41

if n == 42:

    return 42

if n == 43:

    return 43

if n == 44:

    return 44

if n == 45:

    return 45

if n == 46:

    return 46

if n == 47:

    return 47

if n == 48:

    return 48

if n == 49:

    return 49

if n == 50:

    return 50

if n == 51:

    return 51

if n == 52:

    return 52

if n == 53:

    return 53

if n == 54:

    return 54

if n == 55:

    return 55

if n == 56:

    return 56

if n == 57:

    return 57

if n == 58:

    return 58

if n == 59:

    return 59

if n == 60:

    return 60

if n == 61:

    return 61

if n == 62:

    return 62

if n == 63:

    return 63

if n == 64:

    return 64

if n == 65:

    return 65

if n == 66:

    return 66

if n == 67:

    return 67

if n == 68:

    return 68

if n == 69:

    return 69

if n == 70:

    return 70

if n == 71:

    return 71

if n == 72:

    return 72

if n == 73:

    return 73

if n == 74:

    return 74

if n == 75:

    return 75

if n == 76:

    return 76

if n == 77:

    return 77

if n == 78:

    return 78

if n == 79:

    return 79

if n == 80:

    return 80

if n == 81:

    return 81

if n == 82:

    return 82

if n == 83:

    return 83

if n == 84:

    return 84

if n == 85:

    return 85

if n == 86:

    return 86

if n == 87:

    return 87

if n == 88:

    return 88

if n == 89:

    return 89

if n == 90:

    return 90

if n == 91:

    return 91

if n == 92:

    return 92

if n == 93:

    return 93

if n == 94:

    return 94

if n == 95:

    return 95

if n == 96:

    return 96

if n == 97:

    return 97

if n == 98:

    return 98

if n == 99:

    return 99

if n == 100:

    return 100

if n == 101:

    return 101

if n == 102:

    return 102

if n == 103:

    return 103

if n == 104:

    return 104

if n == 105:

    return 105

if n == 106:

    return 106

if n == 107:

    return 107

if n == 108:

    return 108

if n == 109:

    return 109

if n == 110:

    return 110

if n == 111:

    return 111

if n == 112:

    return 112

if n == 113:

    return 113

if n == 114:

    return 114

if n == 115:

    return 115

if n == 116:

    return 116

if n == 117:

    return 117

if n == 118:

    return 118

if n == 119:

    return 119

if n == 120:

    return 120

if n == 121:

    return 121

if n == 122:

    return 122

if n == 123:

    return 123

if n == 124:

    return 124

if n == 125:

    return 125

if n == 126:

    return 126

if n == 127:

    return 127

if n == 128:

    return 128

if n == 129:

    return 129

if n == 130:

    return 130

if n == 131:

    return 131

if n == 132:

    return 132

if n == 133:

    return 133

if n == 134:

    return 134

if n == 135:

    return 135

if n == 136:

    return 136

if n == 137:

    return 137

if n == 138:

    return 138

if n == 139:

    return 139

if n == 140:

    return 140

if n == 141:

    return 141

if n == 142:

    return 142

if n == 143:

    return 143

if n == 144:

    return 144

if n == 145:

    return 145

if n == 146:

    return 146

if n == 147:

    return 147

if n == 148:

    return 148

if n == 149:

    return 149

if n == 150:

    return 150

if n == 151:

    return 151

if n == 152:

    return 152

if n == 153:

    return 153

if n == 154:

    return 154

if n == 155:

    return 155

if n == 156:

    return 156

if n == 157:

    return 157

if n == 158:

    return 158

if n == 159:

    return 159

if n == 160:

    return 160

if n == 161:

    return 161

if n == 162:

    return 162

if n == 163:

    return 163

if n == 164:

    return 164

if n == 165:

    return 165

if n == 166:

    return 166

if n == 167:

    return 167

if n == 168:

    return 168

if n == 169:

    return 169

if n == 170:

    return 170

if n == 171:

    return 171

if n == 172:

    return 172

if n == 173:

    return 173

if n == 174:

    return 174

if n == 175:

    return 175

if n == 176:

    return 176

if n == 177:

    return 177

if n == 178:

    return 178

if n == 179:

    return 179

if n == 180:

    return 180

if n == 181:

    return 181

if n == 182:

    return 182

if n == 183:

    return 183

if n == 184:

    return 184

if n == 185:

    return 185

if n == 186:

    return 186

if n == 187:

    return 187

if n == 188:

    return 188

if n == 189:

    return 189

if n == 190:

    return 190

if n == 191:

    return 191

if n == 192:

    return 192

if n == 193:

    return 193

if n == 194:

    return 194

if n == 195:

    return 195

if n == 196:

    return 196

if n == 197:

    return 197

if n == 198:

    return 198

if n == 199:

    return 199

if n == 200:

    return 200

if n == 201:

    return 201

if n == 202:

    return 202

if n == 203:

    return 203

if n == 204:

    return 204

if n == 205:

    return 205

if n == 206:

    return 206

if n == 207:

    return 207

if n == 208:

    return 208

if n == 209:

    return 209

if n == 210:

    return 210

if n == 211:

    return 211

if n == 212:

    return 212

if n == 213:

    return 213

if n == 214:

    return 214

if n == 215:

    return 215

if n == 216:

    return 216

if n == 217:

    return 217

if n == 218:

    return 218

if n == 219:

    return 219

if n == 220:

    return 220

if n == 221:

    return 221

if n == 222:

    return 222

if n == 223:

    return 223

if n == 224:

    return 224

if n == 225:

    return 225

if n == 226:

    return 226

if n == 227:

    return 227

if n == 228:

    return 228

if n == 229:

    return 229

if n == 230:

    return 230

if n == 231:

    return 231

if n == 232:

    return 232

if n == 233:

    return 233

if n == 234:

    return 234

if n == 235:

    return 235

if n ==

如何裁剪特定的字符串？

我有一根长度不同的绳子。我想在我的字符串里剪一个特定的词。请帮帮忙，我是PowerShell的新手。我试过这段代码，但我还是不需要。

浏览 1提问于2019-06-10得票数 1

回答已采纳

1回答

PHP关联数组使用

、

这是一个“拆除炸弹”的游戏，下面的规则只适用于下一个割线：如果你切断一根白色电缆，你就不能切断白色或黑色电缆。如果你剪一根红色的电缆，你必须剪一根绿色的，如果你剪一根黑色的电缆，它不允许切割一根白色、绿色或橙色的电缆--如果你剪一根橙色的电缆，你应该剪一条红色或黑色的电缆--如果你剪一根绿色的电缆，你必须剪一条橙色或白色的电缆--如果你切割<e

浏览 5提问于2017-01-09得票数 0

回答已采纳

1回答

最大产品切割算法

、、

问题陈述是它可以相当简单地用动态规划来解决。

浏览 0提问于2020-09-07得票数 2

回答已采纳

1回答

斯威夫特: String.removeSubrange - HowTo？

当我想用Swift剪一根绳子的时候，我有点怀念他们想让我做的事情。他们告诉我斯威夫特是“客观的”。但它实际上是“行不通的”。我阅读的docs ()中解释了从字符串中移除子范围。

浏览 8提问于2022-02-10得票数 1

3回答

在Java中迭代字符串矩阵的“列和行”的最佳正确方法是什么？

、、

我知道怎么用一根绳子来做： char c = string.charAt(i); 但是当我有一根绳子时，它是如何工作的呢？

浏览 4提问于2016-10-26得票数 0

回答已采纳

1回答

Flutter只找到在Fi还原UI中手动创建的Fi还原文档。

、

我试图从一个Firestore集合中检索一个文档计数，该集合是我用下面的代码动态创建的。集合和文档似乎是在Firestore中成功创建的，我可以在Firestore中查看它们。另外，我是，没有看到像“这个文档不存在，也不会出现在查询或快照中”这样的消息。我相信这些文档确实存在。下面是我用来创建文档的db方法。 DateTime $now = DateTime.now(); var formatter = DateFormat('yyyy-MM-dd'

浏览 1提问于2022-01-23得票数 0

4回答

如何翻转一根绳子？

、

如何在c#应用程序中翻转字符串，例如：“救护车”文本被视为镜像。我不知道如何使用c# forms应用程序从.im开始。我尝试过反转字符串，但是否有可能翻转字符串(如镜像)？

浏览 1提问于2015-06-01得票数 4

回答已采纳

5回答

一根绳子

、

嗨伙计们泰克斯！

浏览 5提问于2011-01-03得票数 0

回答已采纳

10回答

(一根[L]一根绳子！

、、

这是你如何交替一根线。对于长度为N的字符串，取中间的N个字符，并在括号中包围它们。因此，如果我们的字符串是Hello world! (12个字符)，我们将以(Hello！)结束。

浏览 0提问于2017-06-28得票数 43

3回答

掩蔽一根绳子

、、、

我需要将接收到的字符串设置为以下格式：Eg我知道有string-mask和某种方式通过JQuery，有更简单的方法来做它吗？

浏览 4提问于2017-07-11得票数 7

回答已采纳

2回答

修剪一根绳子

、

我正在使用windows 7和VisualC++。我有一个控制台程序，我试图在开始和结束时修剪一个字符串。没有MFC，TrimLeft()和TrimRight()似乎无法工作。这是我到目前为止所拥有的。wprintf(L" URL: %s\n\n", bstr);s = bstr;s.TrimEnd("/*"); wprintf(L&#

浏览 0提问于2011-11-07得票数 0

回答已采纳

12回答