Используйте setw и setfill из iomanip
#include
#include
using std::cout;
using std::endl;
using std::hex;
int main()
{
cout << "0x" << std::setfill('0') << std::setw(2) << hex << 10 << endl;
}
Лично, состояние iostreams с точки зрения состояния всегда меня раздражает , Я думаю, что форсированный формат - лучший вариант, поэтому я бы рекомендовал другой ответ.
//es6
//array.from
const reverseString = (string) => Array.from(string).reduce((a, e) => e + a);
//split
const reverseString = (string) => string.split('').reduce((a, e) => e + a);
//split problem
"
Нижеследующее может помочь любому, кто ищет реверсивную реверсию строки. Просили сделать это в недавнем интервью с использованием стиля функционального программирования:
var reverseStr = function(str) {
return (str.length > 0) ? str[str.length - 1] + reverseStr(str.substr(0, str.length - 1)) : '';
};
//tests
console.log(reverseStr('setab retsam')); //master bates
Моя собственная оригинальная попытка ...
var str = "The Car";
function reverseStr(str) {
var reversed = "";
var len = str.length;
for (var i = 1; i < (len + 1); i++) {
reversed += str[len - i];
}
return reversed;
}
var strReverse = reverseStr(str);
console.log(strReverse);
// "raC ehT"
String.prototype.reverse=function(){return this.split("").reverse().join("");}
или
String.prototype.reverse = function() {
var s = "";
var i = this.length;
while (i>0) {
s += this.substring(i-1,i);
i--;
}
return s;
}
Похоже, я опаздываю на вечеринку на 3 года ...
К сожалению, вы не можете, как было указано. См. Являются ли строки JavaScript неизменяемыми? Нужен ли мне строковый конструктор & quot; в JavaScript?
Следующее, что вы можете сделать, это создать «представление» или «обертку», которая берет строку и повторно использует все части используемого API-интерфейса строки, но притворяясь, что строка отменена. Например:
var identity = function(x){return x};
function LazyString(s) {
this.original = s;
this.length = s.length;
this.start = 0; this.stop = this.length; this.dir = 1; // "virtual" slicing
// (dir=-1 if reversed)
this._caseTransform = identity;
}
// syntactic sugar to create new object:
function S(s) {
return new LazyString(s);
}
//We now implement a `"...".reversed` which toggles a flag which will change our math:
(function(){ // begin anonymous scope
var x = LazyString.prototype;
// Addition to the String API
x.reversed = function() {
var s = new LazyString(this.original);
s.start = this.stop - this.dir;
s.stop = this.start - this.dir;
s.dir = -1*this.dir;
s.length = this.length;
s._caseTransform = this._caseTransform;
return s;
}
//We also override string coercion for some extra versatility (not really necessary):
// OVERRIDE STRING COERCION
// - for string concatenation e.g. "abc"+reversed("abc")
x.toString = function() {
if (typeof this._realized == 'undefined') { // cached, to avoid recalculation
this._realized = this.dir==1 ?
this.original.slice(this.start,this.stop) :
this.original.slice(this.stop+1,this.start+1).split("").reverse().join("");
this._realized = this._caseTransform.call(this._realized, this._realized);
}
return this._realized;
}
//Now we reimplement the String API by doing some math:
// String API:
// Do some math to figure out which character we really want
x.charAt = function(i) {
return this.slice(i, i+1).toString();
}
x.charCodeAt = function(i) {
return this.slice(i, i+1).toString().charCodeAt(0);
}
// Slicing functions:
x.slice = function(start,stop) {
// lazy chaining version of https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/slice
if (stop===undefined)
stop = this.length;
var relativeStart = start<0 ? this.length+start : start;
var relativeStop = stop<0 ? this.length+stop : stop;
if (relativeStart >= this.length)
relativeStart = this.length;
if (relativeStart < 0)
relativeStart = 0;
if (relativeStop > this.length)
relativeStop = this.length;
if (relativeStop < 0)
relativeStop = 0;
if (relativeStop < relativeStart)
relativeStop = relativeStart;
var s = new LazyString(this.original);
s.length = relativeStop - relativeStart;
s.start = this.start + this.dir*relativeStart;
s.stop = s.start + this.dir*s.length;
s.dir = this.dir;
//console.log([this.start,this.stop,this.dir,this.length], [s.start,s.stop,s.dir,s.length])
s._caseTransform = this._caseTransform;
return s;
}
x.substring = function() {
// ...
}
x.substr = function() {
// ...
}
//Miscellaneous functions:
// Iterative search
x.indexOf = function(value) {
for(var i=0; i<this.length; i++)
if (value==this.charAt(i))
return i;
return -1;
}
x.lastIndexOf = function() {
for(var i=this.length-1; i>=0; i--)
if (value==this.charAt(i))
return i;
return -1;
}
// The following functions are too complicated to reimplement easily.
// Instead just realize the slice and do it the usual non-in-place way.
x.match = function() {
var s = this.toString();
return s.apply(s, arguments);
}
x.replace = function() {
var s = this.toString();
return s.apply(s, arguments);
}
x.search = function() {
var s = this.toString();
return s.apply(s, arguments);
}
x.split = function() {
var s = this.toString();
return s.apply(s, arguments);
}
// Case transforms:
x.toLowerCase = function() {
var s = new LazyString(this.original);
s._caseTransform = ''.toLowerCase;
s.start=this.start; s.stop=this.stop; s.dir=this.dir; s.length=this.length;
return s;
}
x.toUpperCase = function() {
var s = new LazyString(this.original);
s._caseTransform = ''.toUpperCase;
s.start=this.start; s.stop=this.stop; s.dir=this.dir; s.length=this.length;
return s;
}
})() // end anonymous scope
Демонстрация:
> r = S('abcABC')
LazyString
original: "abcABC"
__proto__: LazyString
> r.charAt(1); // doesn't reverse string!!! (good if very long)
"B"
> r.toLowerCase() // must reverse string, so does so
"cbacba"
> r.toUpperCase() // string already reversed: no extra work
"CBACBA"
> r + '-demo-' + r // natural coercion, string already reversed: no extra work
"CBAcba-demo-CBAcba"
Кикер - на месте выполняется чистая математика, посещая каждый символ только один раз и только при необходимости :
> 'demo: ' + S('0123456789abcdef').slice(3).reversed().slice(1,-1).toUpperCase()
"demo: EDCBA987654"
> S('0123456789ABCDEF').slice(3).reversed().slice(1,-1).toLowerCase().charAt(3)
"b"
Это дает значительную экономию, если применяется к очень большой строке, если вы используете только относительно небольшой срез.
Стоит ли это того, как-копия, как в большинстве языков программирования) сильно зависит от вашего варианта использования и насколько эффективно вы переопределяете API-интерфейс строки. Например, если все, что вам нужно, это сделать операцию индексации строк или взять небольшие slice
s или substr
s, это позволит вам сэкономить время и пространство. Если вы планируете печатать большие перевернутые фрагменты или подстроки, экономия может быть небольшой, даже хуже, чем полная копия. Ваша «перевернутая» строка также не будет иметь тип string
, хотя вы можете подделать это с помощью прототипирования.
Вышеупомянутая демонстрационная реализация создает новый объект типа ReversedString. Он прототипирован и, следовательно, достаточно эффективен, с минимальной работой и минимальными затратами на пространство (общие определения прототипов). Это ленивая реализация, включающая отложенную нарезку. Всякий раз, когда вы выполняете функцию, подобную .slice
или .reversed
, она будет выполнять индексную математику. Наконец, когда вы извлекаете данные (путем неявного вызова .toString()
или .charCodeAt(...)
или чего-то еще], он будет применять их «умным» способом, касаясь наименьших данных.
Примечание: приведенная выше строка API является примером и не может быть реализовано отлично. Вы также можете использовать только 1-2 функции, которые вам нужны.
Использование функций массива,
String.prototype.reverse = function(){
return [].reduceRight.call(this, function(last, secLast){return last + secLast});
}
В ES6 у вас есть еще одна опция
function reverseString (str) {
return [...str].reverse().join('')
}
reverseString('Hello');
Это самый простой способ, я думаю,
var reverse = function(str) {
var arr = [];
for (var i = 0, len = str.length; i <= len; i++) {
arr.push(str.charAt(len - i))
}
return arr.join('');
}
console.log(reverse('I want a
function reverse(str){
var s = "";
for (var i = str.length - 1; i >= 0; i--){
s += str[i];
}
return s;
};
reverse("your string comes here")
Если вы не хотите использовать встроенную функцию. Попробуйте
var string = 'abcdefg';
var newstring = '';
for(let i = 0; i < string.length; i++){
newstring = string[i] += newstring
}
console.log(newstring)
Подробный анализ и десять различных способов изменения строки и их характеристик производительности.
http://eddmann.com/posts/ten-ways-to-reverse-a-string- in-javascript /
Эффективность этих реализаций:
Лучшая реализация (-ы) для каждого браузера
Здесь эти реализации:
Реализация 1:
function reverse(s) {
var o = '';
for (var i = s.length - 1; i >= 0; i--)
o += s[i];
return o;
}
Реализация 2:
function reverse(s) {
var o = [];
for (var i = s.length - 1, j = 0; i >= 0; i--, j++)
o[j] = s[i];
return o.join('');
}
Реализация 3:
function reverse(s) {
var o = [];
for (var i = 0, len = s.length; i <= len; i++)
o.push(s.charAt(len - i));
return o.join('');
}
Реализация 4:
function reverse(s) {
return s.split('').reverse().join('');
}
Реализация 5:
function reverse(s) {
var i = s.length,
o = '';
while (i > 0) {
o += s.substring(i - 1, i);
i--;
}
return o;
}
Реализация 6:
function reverse(s) {
for (var i = s.length - 1, o = ''; i >= 0; o += s[i--]) { }
return o;
}
Реализация 7:
function reverse(s) {
return (s === '') ? '' : reverse(s.substr(1)) + s.charAt(0);
}
Реализация 8:
function reverse(s) {
function rev(s, len, o) {
return (len === 0) ? o : rev(s, --len, (o += s[len]));
};
return rev(s, s.length, '');
}
Реализация 9:
function reverse(s) {
s = s.split('');
var len = s.length,
halfIndex = Math.floor(len / 2) - 1,
tmp;
for (var i = 0; i <= halfIndex; i++) {
tmp = s[len - i - 1];
s[len - i - 1] = s[i];
s[i] = tmp;
}
return s.join('');
}
Реализация 10
function reverse(s) {
if (s.length < 2)
return s;
var halfIndex = Math.ceil(s.length / 2);
return reverse(s.substr(halfIndex)) +
reverse(s.substr(0, halfIndex));
}
В ECMAScript 6 вы можете изменить строку еще быстрее, не используя метод split .split('')
с помощью оператора spread следующим образом:
var str = [...'racecar'].reverse().join('');
string.split('')
понятна большинству людей, чем [...string]
.
– Annan
27 March 2018 в 01:06
без преобразования строки в массив;
String.prototype.reverse = function() {
var ret = "";
var size = 0;
for (var i = this.length - 1; -1 < i; i -= size) {
if (
'\uD800' <= this[i - 1] && this[i - 1] <= '\uDBFF' &&
'\uDC00' <= this[i] && this[i] <= '\uDFFF'
) {
size = 2;
ret += this[i - 1] + this[i];
} else {
size = 1;
ret += this[i];
}
}
return ret;
}
console.log('anãnam anañam' === 'mañana mañana'.reverse());
с использованием Array.reverse без преобразования символов в кодовые точки;
String.prototype.reverse = function() {
var array = this.split("").reverse();
for (var i = 0; i < this.length; ++i) {
if (
'\uD800' <= this[i - 1] && this[i - 1] <= '\uDBFF' &&
'\uDC00' <= this[i] && this[i] <= '\uDFFF'
) {
array[i - 1] = array[i - 1] + array[i];
array[i] = array[i - 1].substr(0, 1);
array[i - 1] = array[i - 1].substr(1, 1);
}
}
return array.join("");
}
console.log('anãnam anañam' === 'mañana mañana'.reverse());
var c = array[i-1]; array[i-1] = array[i]; array[i] = c;
не требует конкатенирования пары кодов. Кроме того, for-loop должен начинаться с 1.
– MT0
9 January 2017 в 14:11
'\ud83c\ud83c\udfa5'.reverse()
- она будет выводиться так же, как и вход. Добавление ++i;
в оператор if
должно исправить это.
– MT0
9 January 2017 в 14:22
'a\u0303bc'.reverse() === 'cba\u0303'
должен возвращать true.
– MT0
9 January 2017 в 15:33
Следующая техника (или аналогичная) обычно используется для изменения строки в JavaScript:
// Don’t use this!
var naiveReverse = function(string) {
return string.split('').reverse().join('');
}
На самом деле все ответы, опубликованные до сих пор, являются вариацией этого шаблона. Однако есть некоторые проблемы с этим решением. Например:
naiveReverse('foo
Сначала используйте Array.from()
, чтобы превратить строку в массив, затем Array.prototype.reverse()
, чтобы отменить массив, а затем Array.prototype.join()
, чтобы вернуть строку.
const reverse = str => Array.from(str).reverse().join('');
string.split('')
не работает. См. этот ответ для более подробного объяснения.
– Michał Perłakowski
13 October 2016 в 11:40
Array.from('foo
– Julian TF
31 January 2017 в 07:18
Целая «обратная строка на месте» - это устаревший вопрос о программировании на языке C, и люди, которые были опрошены ими (для мести, может быть?), спросят. К сожалению, это часть «In Place», которая больше не работает, потому что строки практически в любом управляемом языке (JS, C # и т. Д.) Используют неизменяемые строки, тем самым побеждая всю идею перемещения строки без выделения какой-либо новой памяти.
Хотя вышеприведенные решения действительно меняют строку, они не делают этого, не выделяя больше памяти и, таким образом, не удовлетворяют условиям. Вы должны иметь прямой доступ к строке как выделенную и иметь возможность манипулировать своим исходным местоположением памяти, чтобы иметь возможность отменить ее.
Лично я действительно ненавижу подобные вопросы интервью, но, к сожалению, , я уверен, что мы будем их видеть на долгие годы.
var str = "IAMA JavaScript Developer";
var a=str.split(''), b = a.length;
for (var i=0; i<b; i++) {
a.unshift(a.splice(1+i,1).shift())
}
a.shift();
alert(a.join(''));
Строки сами по себе неизменяемы, но вы можете легко создать обратную копию со следующим кодом:
function reverseString(str) {
var strArray = str.split("");
strArray.reverse();
var strReverse = strArray.join("");
return strReverse;
}
reverseString("hello");
Держите его сухим и простым глупым !!
function reverse(s){
let str = s;
var reverse = '';
for (var i=str.length;i>0;i--){
var newstr = str.substring(0,i)
reverse += newstr.substr(-1,1)
}
return reverse;
}
var str = "my name is saurabh ";
var empStr='',finalString='';
var chunk=[];
function reverse(str){
var i,j=0,n=str.length;
for(i=0;i<n;++i){
if(str[i]===' '){
chunk[j]=empStr;
empStr = '';
j++;
}else{
empStr=empStr+str[i];
}
}
for(var z=chunk.length-1;z>=0;z--){
finalString = finalString +' '+ chunk[z];
console.log(finalString);
}
return true;
}
reverse(str);
Я знаю, что это старый вопрос, на который хорошо ответил, но для моего собственного удовольствия я написал следующую обратную функцию и подумал, что поделюсь ею, если это будет полезно для кого-то еще. Он обрабатывает суррогатные пары и сочетает метки:
function StringReverse (str)
{
var charArray = [];
for (var i = 0; i < str.length; i++)
{
if (i+1 < str.length)
{
var value = str.charCodeAt(i);
var nextValue = str.charCodeAt(i+1);
if ( ( value >= 0xD800 && value <= 0xDBFF
&& (nextValue & 0xFC00) == 0xDC00) // Surrogate pair)
|| (nextValue >= 0x0300 && nextValue <= 0x036F)) // Combining marks
{
charArray.unshift(str.substring(i, i+2));
i++; // Skip the other half
continue;
}
}
// Otherwise we just have a rogue surrogate marker or a plain old character.
charArray.unshift(str[i]);
}
return charArray.join('');
}
Все опоры в Mathias, Punycode и различные другие ссылки для обучения меня сложностям кодирования символов в JavaScript.
function reverse_string(string)
{
var string;
var len = string.length;
var stringExp = string.split('');
var i;
for (i = len-1; i >=0;i--)
{
var result = document.write(stringExp[i]);
}
return result;
}
reverse_string("This is a reversed string");
// выходы: gnirts desrever a si sihT
Еще одна вариация (работает ли она с IE?):
String.prototype.reverse = function() {
for (i=1,s=""; i<=this.length; s+=this.substr(-i++,1)) {}
return s;
}
EDIT:
Это без использования встроенных функций:
String.prototype.reverse = function() {
for (i=this[-1],s=""; i>=0; s+=this[i--]) {}
return s;
}
Примечание: этот [-1] содержит длину строки.
Однако невозможно изменить строку на месте, поскольку присвоение отдельным элементам массива не работает с объектом String (защищенный?). То есть вы можете назначать, но результирующая строка не изменяется.
function reverseString(string) {
var reversedString = "";
var stringLength = string.length - 1;
for (var i = stringLength; i >= 0; i--) {
reversedString += string[i];
}
return reversedString;
}
var str = 'sample string';
[].map.call(str, function(x) {
return x;
}).reverse().join('');
OR
var str = 'sample string';
console.log(str.split('').reverse().join(''));
// Выход: 'gnirts elpmas'
Реальный ответ: вы не можете отменить его на месте, но вы можете создать новую строку, которая является обратным.
Также как упражнение для игры с рекурсией: иногда, когда вы идете в интервью, интервьюер может спросить вас, как это сделать, используя рекурсию, и я думаю, что «предпочтительный ответ» может быть «Я бы предпочел не делать этого в рекурсии, поскольку он может легко вызвать переполнение стека» (поскольку это O(n)
а не O(log n)
.Если это O(log n)
, довольно сложно получить переполнение стека - 4 миллиарда элементов могут обрабатываться уровнем стека 32, так как 2 ** 32 - 4294967296. Но если это O(n)
, тогда он может легко получить переполнение стека.
Иногда интервьюер все еще спрашивает вас: «Как упражнение, почему бы вам не написать его с помощью рекурсии?» И вот он:
String.prototype.reverse = function() {
if (this.length <= 1) return this;
else return this.slice(1).reverse() + this.slice(0,1);
}
тестовый прогон:
var s = "";
for(var i = 0; i < 1000; i++) {
s += ("apple" + i);
}
console.log(s.reverse());
output:
999elppa899elppa...2elppa1elppa0elppa
Чтобы попытаться получить переполнение стека, я сменил 1000
на 10000
в Google Chrome, и он сообщил:
RangeError: Maximum call stack size exceeded
Во время собеседования меня попросили изменить строку без использования каких-либо переменных или собственных методов. Это моя любимая реализация:
function reverseString(str) {
return str === '' ? '' : reverseString(str.slice(1)) + str[0];
}
Пока вы имеете дело с простыми символами ASCII, и вы счастливы использовать встроенные функции, это будет работать:
function reverse(s){
return s.split("").reverse().join("");
}
Если вам нужно решение, поддерживающее UTF- 16 или других многобайтовых символов, имейте в виду, что эта функция приведет к недопустимым строкам Unicode или действительным строкам, которые выглядят забавно. Возможно, вы захотите рассмотреть этот ответ .