JavaScript에서 문자열을 어떻게 뒤집습니까?

이 (내장 함수 사용하지 않고, return 문으로 함수에 전달 될 때 어떻게 자바 스크립트에서 장소 (또는 장소)의 문자열을 반대합니까 .reverse(), .charAt()등)?

간단한 ASCII 문자를 다루고 내장 함수를 사용하는 것이 좋으면 다음과 같이 작동합니다.

function reverse(s){
    return s.split("").reverse().join("");
}

UTF-16 또는 기타 멀티 바이트 문자를 지원하는 솔루션이 필요한 경우이 함수는 유효하지 않은 유니 코드 문자열 또는 재미있는 문자열을 제공합니다. 대신이 답변 을 고려할 수 있습니다 .

[... s]는 유니 코드를 인식하고 작은 편집으로 다음을 제공합니다.

function reverse(s){
    return [...s].reverse().join("");
}

다음 기술 (또는 이와 유사한 기술)은 일반적으로 JavaScript에서 문자열을 되 돌리는 데 사용됩니다.

// Don’t use this!
var naiveReverse = function(string) {
    return string.split('').reverse().join('');
}

실제로 지금까지 게시 된 모든 답변은이 패턴의 변형입니다. 그러나이 솔루션에는 몇 가지 문제가 있습니다. 예를 들면 다음과 같습니다.

naiveReverse('foo 𝌆 bar');
// → 'rab �� oof'
// Where did the `𝌆` symbol go? Whoops!

왜 이런 일이 발생하는지 궁금하다면 JavaScript의 내부 문자 인코딩을 읽으십시오 . (TL; DR : 𝌆은 별표이고 JavaScript는 두 개의 별도 코드 단위로 표시합니다.)

그러나 더 있습니다 :

// To see which symbols are being used here, check:
// http://mothereff.in/js-escapes#1ma%C3%B1ana%20man%CC%83ana
naiveReverse('mañana mañana');
// → 'anãnam anañam'
// Wait, so now the tilde is applied to the `a` instead of the `n`? WAT.

문자열 역 구현을 테스트하기에 좋은 문자열 은 다음과 같습니다 .

'foo 𝌆 bar mañana mañana'

왜? 여기에는 별표 ( 𝌆) ( 자바 스크립트에서 서로 게이트 쌍으로 표시됨)와 결합 표시 ( ñ마지막으로 mañanaU + 006E LATIN SMALL LETTER N 및 U + 0303 COMBINING TILDE)가 포함되어 있기 때문입니다.

대리 쌍이 나타나는 순서는 되돌릴 수 없습니다. 그렇지 않으면 별표 기호가 '역전 된'문자열에 더 이상 표시되지 않습니다. 그렇기 때문에 ��이전 예제의 출력에서 해당 마크 를 보았습니다 .

결합 마크는 항상 이전 심볼에 적용되므로 주 심볼 (U + 006E 라틴 작은 문자 N)을 결합 마크 (U + 0303 조합 타일)로 전체적으로 취급해야합니다. 순서를 반대로하면 결합 표시가 문자열의 다른 기호와 쌍을 이루게됩니다. 그렇기 때문에 예제 출력이 ã대신했습니다 ñ.

바라건대, 이것은 지금까지 게시 된 모든 답변이 잘못된 이유를 설명합니다 .

JavaScript에서 문자열을 올바르게 바꾼 방법에 대한 초기 질문에 답하기 위해 유니 코드를 인식하는 문자열 반전이 가능한 작은 JavaScript 라이브러리를 작성했습니다. 방금 언급 한 문제가 없습니다. 라이브러리는 Esrever 라고 합니다 . 코드는 GitHub에 있으며 거의 ​​모든 JavaScript 환경에서 작동합니다. 쉘 유틸리티 / 바이너리와 함께 제공되므로 원하는 경우 터미널에서 쉽게 문자열을 되돌릴 수 있습니다.

var input = 'foo 𝌆 bar mañana mañana';
esrever.reverse(input);
// → 'anañam anañam rab 𝌆 oof'

"제자리"부분은 다른 답변을 참조하십시오.

String.prototype.reverse_string=function() {return this.split("").reverse().join("");}

또는

String.prototype.reverse_string = function() {
    var s = "";
    var i = this.length;
    while (i>0) {
        s += this.substring(i-1,i);
        i--;
    }
    return s;
}

문자열과 성능 세부 정보를 반전시키는 자세한 분석 및 10 가지 방법.

http://eddmann.com/posts/ten-ways-to-reverse-a-string-in-javascript/

이러한 구현의 성능 :

브라우저 당 최고의 성능 구현

• 크롬 15-묵시 1과 6
• Firefox 7-구현 6
• IE 9-구현 4
• 오페라 12-구현 9

그 구현은 다음과 같습니다.

구현 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));
}

"문자열을 뒤집어 놓는 것"전체는 구식 면접 질문 C 프로그래머이며, 그들과 면담 한 사람들 (복수, 아마도?)이 물을 것이다. 불행히도, 거의 모든 관리 언어 (JS, C # 등)의 문자열이 변경 불가능한 문자열을 사용하므로 새 위치를 지정하지 않고 문자열을 이동한다는 전체 아이디어를 무시하기 때문에 더 이상 작동하지 않는 "제자리"부분입니다.

위의 솔루션은 실제로 문자열을 되돌 리지만 더 많은 메모리를 할당하지 않으면 문자열을 뒤집지 않으므로 조건을 만족시키지 않습니다. 할당 된 문자열에 직접 액세스 할 수 있어야하고 원래 메모리 위치를 조작하여 원래 위치로 되돌릴 수 있어야합니다.

개인적으로, 나는 이런 종류의 인터뷰 질문을 정말로 싫어하지만 슬프게도 앞으로 몇 년 동안 계속해서 보게 될 것이라고 확신합니다.

먼저 Array.from()문자열을 배열로 바꾸고 배열 Array.prototype.reverse()을 뒤집은 다음 Array.prototype.join()다시 문자열로 만드는 데 사용하십시오.

const reverse = str => Array.from(str).reverse().join('');

ECMAScript 6에서는 .split('')split 연산자 를 사용하여 split 메소드 를 사용하지 않고도 문자열을 더 빠르게 되돌릴 수 있습니다 .

var str = [...'racecar'].reverse().join('');

내가 파티에 3 년 늦은 것 같아

불행히도 당신은 지적한대로 할 수 없습니다. JavaScript 문자열을 변경할 수 없습니까?를 참조하십시오 . 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를 얼마나 효율적으로 다시 구현하는지에 달려 있습니다. 예를 들어 문자열 인덱스 조작을하거나 작은 slices 또는 substrs를 취 하면 공간과 시간이 절약됩니다. 그러나 큰 반전 슬라이스 또는 하위 문자열을 인쇄 할 계획이라면 전체 사본을 저장하는 것보다 훨씬 적은 비용이 절감 될 수 있습니다. "역전 된"문자열도 유형이 없습니다.string 않지만 프로토 타이핑으로 위조 할 수 있습니다.

위의 데모 구현은 ReversedString 유형의 새 객체를 만듭니다. 그것은 최소한의 작업과 최소한의 공간 오버 헤드 (시제품 정의가 공유 됨)로 프로토 타입 화되어 상당히 효율적입니다. 지연된 슬라이싱과 관련된 지연 구현입니다. .slice또는 과 같은 기능을 수행 할 때마다 .reversed인덱스 수학이 수행됩니다. 마지막으로 데이터를 추출 할 때 (암시 적으로 호출 .toString()하거나 .charCodeAt(...)다른 방식으로) 가능한 가장 적은 데이터를 건드 리면서 "스마트 한"방식으로 데이터를 적용합니다.

참고 : 위의 문자열 API는 예제이며 완벽하게 구현되지 않을 수 있습니다. 필요한 1-2 개의 기능 만 사용할 수도 있습니다.

JavaScript에서 문자열을 되돌릴 수있는 방법은 여러 가지가 있습니다. 내가 선호하는 세 가지 방법을 적어두고 있습니다.

접근법 1 : 역 기능 사용 :

function reverse(str) {
  return str.split('').reverse().join('');
}

접근 방식 2 : 문자 반복 :

function reverse(str) {
  let reversed = '';

  for (let character of str) {
    reversed = character + reversed;
  }

  return reversed;
}

접근법 3 : 감소 기능 사용 :

function reverse(str) {
  return str.split('').reduce((rev, char) => char + rev, '');
}

이게 도움이 되길 바란다 :)

인터뷰 중에 변수 나 기본 메소드를 사용하지 않고 문자열을 되돌 리라는 요청을 받았습니다. 이것은 내가 가장 좋아하는 구현입니다.

function reverseString(str) {
    return str === '' ? '' : reverseString(str.slice(1)) + str[0];
}

여러 가지 방법이 있으며 다음을 확인할 수 있습니다.

1. 전통적인 for 루프 (증가) :

function reverseString(str){
        let stringRev ="";
        for(let i= 0; i<str.length; i++){
            stringRev = str[i]+stringRev;
        }
        return stringRev;
}
alert(reverseString("Hello World!"));

2. 전통적인 for 루프 (감소) :

function reverseString(str){
    let revstr = "";
    for(let i = str.length-1; i>=0; i--){
        revstr = revstr+ str[i];
    }
    return revstr;
}
alert(reverseString("Hello World!"));

3. for-of 루프 사용

function reverseString(str){
    let strn ="";
    for(let char of str){
        strn = char + strn;
    }
    return strn;
}
alert(reverseString("Get well soon"));

4. forEach / high order 배열 방법 사용 :

function reverseString(str){

  let revSrring = "";
  str.split("").forEach(function(char){
    
    revSrring = char + revSrring;
  
  });
  return revSrring;
}
alert(reverseString("Learning JavaScript"));

5. ES6 표준 :

function reverseString(str){

  let revSrring = "";
  str.split("").forEach(char => revSrring = char + revSrring);
  return revSrring;
}
alert(reverseString("Learning JavaScript"));

6. 최신 방법 :

function reverseString(str){

  return str.split("").reduce(function(revString, char){
       return char + revString;
  }, "");
 
}

alert(reverseString("Learning JavaScript"));

7. 다음을 사용하여 결과를 얻을 수도 있습니다.

function reverseString(str){

  return str.split("").reduce((revString, char)=> char + revString, "");
 
}
alert(reverseString("Learning JavaScript"));

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 🍺'));

var str = 'sample string';
[].map.call(str, function(x) {
  return x;
}).reverse().join('');

또는

var str = 'sample string';
console.log(str.split('').reverse().join(''));

// 출력 : 'gnirts elpmas'

나는 이것이 잘 대답 된 오래된 질문이라는 것을 알고 있지만, 내 자신의 즐거움을 위해 다음과 같은 역 기능을 작성했으며 다른 사람에게 유용 할 경우 공유 할 것이라고 생각했습니다. 대리 쌍과 결합 마크를 모두 처리합니다.

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('');
}

JavaScript에서 문자 인코딩의 복잡성에 관해 Mathias, Punycode 및 기타 다양한 참고 자료에 대한 모든 소품.

JS 문자열은 변경할 수 없기 때문에 할 수 없습니다. 짧은 비 현장 솔루션

[...str].reverse().join``

let str = "Hello World!";
let r = [...str].reverse().join``;
console.log(r);

내장 기능을 사용하지 않으려는 경우 이 시도

var string = 'abcdefg';
var newstring = '';

for(let i = 0; i < string.length; i++){
    newstring = string[i] += newstring;
}

console.log(newstring);

실제 대답은 : 당신은 그것을 뒤집을 수는 없지만 그 반대 인 새로운 문자열을 만들 수 있다는 것입니다.

재귀를 사용하는 연습과 마찬가지로 : 때때로 인터뷰에 참석할 때 면접관이 재귀를 사용하여이 작업을 수행하는 방법을 물을 수도 있습니다. "선호하는 대답"은 "재귀에서는이 작업을 수행하지 않으므로 오히려 이 때문에 쉽게 ( "스택 오버 플로우를 일으킬 수 있습니다 O(n)보다는 O(log n)이됩니다. O(log n), 스택 오버플로 얻을 매우 어렵다 - 2 ** 32 4294967296와 같이 40 억 개 항목, 32의 스택 레벨에 의해 처리 될 수 있습니다. 그러나 만약 그렇다면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());

산출:

999elppa899elppa...2elppa1elppa0elppa

스택 오버플로를 시도하기 위해 Chrome에서로 변경 1000하여 다음 10000과 같이보고했습니다.

RangeError: Maximum call stack size exceeded

문자열 자체는 변경할 수 없지만 다음 코드를 사용하여 쉽게 역 사본을 만들 수 있습니다.

function reverseString(str) {

  var strArray = str.split("");
  strArray.reverse();

  var strReverse = strArray.join("");

  return strReverse;
}

reverseString("hello");

//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
"𠜎𠺢".split('')[0] === Array.from("𠜎𠺢")[0] // "�" === "𠜎" => false
"😂😹🤗".split('')[0] === Array.from("😂😹🤗")[0] // "�" === "😂" => false

분음 부호와 2 바이트 문자를 모두 처리하는 작은 기능 :

(function(){
  var isCombiningDiacritic = function( code )
  {
    return (0x0300 <= code && code <= 0x036F)  // Comb. Diacritical Marks
        || (0x1AB0 <= code && code <= 0x1AFF)  // Comb. Diacritical Marks Extended
        || (0x1DC0 <= code && code <= 0x1DFF)  // Comb. Diacritical Marks Supplement
        || (0x20D0 <= code && code <= 0x20FF)  // Comb. Diacritical Marks for Symbols
        || (0xFE20 <= code && code <= 0xFE2F); // Comb. Half Marks

  };

  String.prototype.reverse = function()
  {
    var output = "",
        i      = this.length - 1,
        width;

    for ( ; i >= 0; --i )
    {
      width = 1;
      while( i > 0 && isCombiningDiacritic( this.charCodeAt(i) ) )
      {
        --i;
        width++;
      }

      if (
           i > 0
        && "\uDC00" <= this[i]   && this[i]   <= "\uDFFF"
        && "\uD800" <= this[i-1] && this[i-1] <= "\uDBFF"
      )
      {
        --i;
        width++;
      }

      output += this.substr( i, width );
    }

    return output;
  }
})();

// Tests
[
  'abcdefg',
  'ab\u0303c',
  'a\uD83C\uDFA5b',
  'a\uD83C\uDFA5b\uD83C\uDFA6c',
  'a\uD83C\uDFA5b\u0306c\uD83C\uDFA6d',
  'TO͇̹̺ͅƝ̴ȳ̳ TH̘Ë͖́̉ ͠P̯͍̭O̚​N̐Y̡' // copied from http://stackoverflow.com/a/1732454/1509264
].forEach(
  function(str){ console.log( str + " -> " + str.reverse() ); }
);
  

최신 정보

분음 부호 결합의보다 완전한 목록은 다음과 같습니다.

      var isCombiningDiacritic = function( code )
      {
        return (0x0300 <= code && code <= 0x036F)
            || (0x0483 <= code && code <= 0x0489)
            || (0x0591 <= code && code <= 0x05BD)
            || (code == 0x05BF)
            || (0x05C1 <= code && code <= 0x05C2)
            || (0x05C4 <= code && code <= 0x05C5)
            || (code == 0x05C7)
            || (0x0610 <= code && code <= 0x061A)
            || (0x064B <= code && code <= 0x065F)
            || (code == 0x0670)
            || (0x06D6 <= code && code <= 0x06DC)
            || (0x06DF <= code && code <= 0x06E4)
            || (0x06E7 <= code && code <= 0x06E8)
            || (0x06EA <= code && code <= 0x06ED)
            || (code == 0x0711)
            || (0x0730 <= code && code <= 0x074A)
            || (0x07A6 <= code && code <= 0x07B0)
            || (0x07EB <= code && code <= 0x07F3)
            || (code == 0x07FD)
            || (0x0816 <= code && code <= 0x0819)
            || (0x081B <= code && code <= 0x0823)
            || (0x0825 <= code && code <= 0x0827)
            || (0x0829 <= code && code <= 0x082D)
            || (0x0859 <= code && code <= 0x085B)
            || (0x08D3 <= code && code <= 0x08E1)
            || (0x08E3 <= code && code <= 0x0902)
            || (code == 0x093A)
            || (code == 0x093C)
            || (0x0941 <= code && code <= 0x0948)
            || (code == 0x094D)
            || (0x0951 <= code && code <= 0x0957)
            || (0x0962 <= code && code <= 0x0963)
            || (code == 0x0981)
            || (code == 0x09BC)
            || (0x09C1 <= code && code <= 0x09C4)
            || (code == 0x09CD)
            || (0x09E2 <= code && code <= 0x09E3)
            || (0x09FE <= code && code <= 0x0A02)
            || (code == 0x0A3C)
            || (0x0A41 <= code && code <= 0x0A51)
            || (0x0A70 <= code && code <= 0x0A71)
            || (code == 0x0A75)
            || (0x0A81 <= code && code <= 0x0A82)
            || (code == 0x0ABC)
            || (0x0AC1 <= code && code <= 0x0AC8)
            || (code == 0x0ACD)
            || (0x0AE2 <= code && code <= 0x0AE3)
            || (0x0AFA <= code && code <= 0x0B01)
            || (code == 0x0B3C)
            || (code == 0x0B3F)
            || (0x0B41 <= code && code <= 0x0B44)
            || (0x0B4D <= code && code <= 0x0B56)
            || (0x0B62 <= code && code <= 0x0B63)
            || (code == 0x0B82)
            || (code == 0x0BC0)
            || (code == 0x0BCD)
            || (code == 0x0C00)
            || (code == 0x0C04)
            || (0x0C3E <= code && code <= 0x0C40)
            || (0x0C46 <= code && code <= 0x0C56)
            || (0x0C62 <= code && code <= 0x0C63)
            || (code == 0x0C81)
            || (code == 0x0CBC)
            || (0x0CCC <= code && code <= 0x0CCD)
            || (0x0CE2 <= code && code <= 0x0CE3)
            || (0x0D00 <= code && code <= 0x0D01)
            || (0x0D3B <= code && code <= 0x0D3C)
            || (0x0D41 <= code && code <= 0x0D44)
            || (code == 0x0D4D)
            || (0x0D62 <= code && code <= 0x0D63)
            || (code == 0x0DCA)
            || (0x0DD2 <= code && code <= 0x0DD6)
            || (code == 0x0E31)
            || (0x0E34 <= code && code <= 0x0E3A)
            || (0x0E47 <= code && code <= 0x0E4E)
            || (code == 0x0EB1)
            || (0x0EB4 <= code && code <= 0x0EBC)
            || (0x0EC8 <= code && code <= 0x0ECD)
            || (0x0F18 <= code && code <= 0x0F19)
            || (code == 0x0F35)
            || (code == 0x0F37)
            || (code == 0x0F39)
            || (0x0F71 <= code && code <= 0x0F7E)
            || (0x0F80 <= code && code <= 0x0F84)
            || (0x0F86 <= code && code <= 0x0F87)
            || (0x0F8D <= code && code <= 0x0FBC)
            || (code == 0x0FC6)
            || (0x102D <= code && code <= 0x1030)
            || (0x1032 <= code && code <= 0x1037)
            || (0x1039 <= code && code <= 0x103A)
            || (0x103D <= code && code <= 0x103E)
            || (0x1058 <= code && code <= 0x1059)
            || (0x105E <= code && code <= 0x1060)
            || (0x1071 <= code && code <= 0x1074)
            || (code == 0x1082)
            || (0x1085 <= code && code <= 0x1086)
            || (code == 0x108D)
            || (code == 0x109D)
            || (0x135D <= code && code <= 0x135F)
            || (0x1712 <= code && code <= 0x1714)
            || (0x1732 <= code && code <= 0x1734)
            || (0x1752 <= code && code <= 0x1753)
            || (0x1772 <= code && code <= 0x1773)
            || (0x17B4 <= code && code <= 0x17B5)
            || (0x17B7 <= code && code <= 0x17BD)
            || (code == 0x17C6)
            || (0x17C9 <= code && code <= 0x17D3)
            || (code == 0x17DD)
            || (0x180B <= code && code <= 0x180D)
            || (0x1885 <= code && code <= 0x1886)
            || (code == 0x18A9)
            || (0x1920 <= code && code <= 0x1922)
            || (0x1927 <= code && code <= 0x1928)
            || (code == 0x1932)
            || (0x1939 <= code && code <= 0x193B)
            || (0x1A17 <= code && code <= 0x1A18)
            || (code == 0x1A1B)
            || (code == 0x1A56)
            || (0x1A58 <= code && code <= 0x1A60)
            || (code == 0x1A62)
            || (0x1A65 <= code && code <= 0x1A6C)
            || (0x1A73 <= code && code <= 0x1A7F)
            || (0x1AB0 <= code && code <= 0x1B03)
            || (code == 0x1B34)
            || (0x1B36 <= code && code <= 0x1B3A)
            || (code == 0x1B3C)
            || (code == 0x1B42)
            || (0x1B6B <= code && code <= 0x1B73)
            || (0x1B80 <= code && code <= 0x1B81)
            || (0x1BA2 <= code && code <= 0x1BA5)
            || (0x1BA8 <= code && code <= 0x1BA9)
            || (0x1BAB <= code && code <= 0x1BAD)
            || (code == 0x1BE6)
            || (0x1BE8 <= code && code <= 0x1BE9)
            || (code == 0x1BED)
            || (0x1BEF <= code && code <= 0x1BF1)
            || (0x1C2C <= code && code <= 0x1C33)
            || (0x1C36 <= code && code <= 0x1C37)
            || (0x1CD0 <= code && code <= 0x1CD2)
            || (0x1CD4 <= code && code <= 0x1CE0)
            || (0x1CE2 <= code && code <= 0x1CE8)
            || (code == 0x1CED)
            || (code == 0x1CF4)
            || (0x1CF8 <= code && code <= 0x1CF9)
            || (0x1DC0 <= code && code <= 0x1DFF)
            || (0x20D0 <= code && code <= 0x20F0)
            || (0x2CEF <= code && code <= 0x2CF1)
            || (code == 0x2D7F)
            || (0x2DE0 <= code && code <= 0x2DFF)
            || (0x302A <= code && code <= 0x302D)
            || (0x3099 <= code && code <= 0x309A)
            || (0xA66F <= code && code <= 0xA672)
            || (0xA674 <= code && code <= 0xA67D)
            || (0xA69E <= code && code <= 0xA69F)
            || (0xA6F0 <= code && code <= 0xA6F1)
            || (code == 0xA802)
            || (code == 0xA806)
            || (code == 0xA80B)
            || (0xA825 <= code && code <= 0xA826)
            || (0xA8C4 <= code && code <= 0xA8C5)
            || (0xA8E0 <= code && code <= 0xA8F1)
            || (code == 0xA8FF)
            || (0xA926 <= code && code <= 0xA92D)
            || (0xA947 <= code && code <= 0xA951)
            || (0xA980 <= code && code <= 0xA982)
            || (code == 0xA9B3)
            || (0xA9B6 <= code && code <= 0xA9B9)
            || (0xA9BC <= code && code <= 0xA9BD)
            || (code == 0xA9E5)
            || (0xAA29 <= code && code <= 0xAA2E)
            || (0xAA31 <= code && code <= 0xAA32)
            || (0xAA35 <= code && code <= 0xAA36)
            || (code == 0xAA43)
            || (code == 0xAA4C)
            || (code == 0xAA7C)
            || (code == 0xAAB0)
            || (0xAAB2 <= code && code <= 0xAAB4)
            || (0xAAB7 <= code && code <= 0xAAB8)
            || (0xAABE <= code && code <= 0xAABF)
            || (code == 0xAAC1)
            || (0xAAEC <= code && code <= 0xAAED)
            || (code == 0xAAF6)
            || (code == 0xABE5)
            || (code == 0xABE8)
            || (code == 0xABED)
            || (code == 0xFB1E)
            || (0xFE00 <= code && code <= 0xFE0F)
            || (0xFE20 <= code && code <= 0xFE2F)
            || (code == 0x101FD)
            || (code == 0x102E0)
            || (0x10376 <= code && code <= 0x1037A)
            || (0x10A01 <= code && code <= 0x10A0F)
            || (0x10A38 <= code && code <= 0x10A3F)
            || (0x10AE5 <= code && code <= 0x10AE6)
            || (0x10D24 <= code && code <= 0x10D27)
            || (0x10F46 <= code && code <= 0x10F50)
            || (code == 0x11001)
            || (0x11038 <= code && code <= 0x11046)
            || (0x1107F <= code && code <= 0x11081)
            || (0x110B3 <= code && code <= 0x110B6)
            || (0x110B9 <= code && code <= 0x110BA)
            || (0x11100 <= code && code <= 0x11102)
            || (0x11127 <= code && code <= 0x1112B)
            || (0x1112D <= code && code <= 0x11134)
            || (code == 0x11173)
            || (0x11180 <= code && code <= 0x11181)
            || (0x111B6 <= code && code <= 0x111BE)
            || (0x111C9 <= code && code <= 0x111CC)
            || (0x1122F <= code && code <= 0x11231)
            || (code == 0x11234)
            || (0x11236 <= code && code <= 0x11237)
            || (code == 0x1123E)
            || (code == 0x112DF)
            || (0x112E3 <= code && code <= 0x112EA)
            || (0x11300 <= code && code <= 0x11301)
            || (0x1133B <= code && code <= 0x1133C)
            || (code == 0x11340)
            || (0x11366 <= code && code <= 0x11374)
            || (0x11438 <= code && code <= 0x1143F)
            || (0x11442 <= code && code <= 0x11444)
            || (code == 0x11446)
            || (code == 0x1145E)
            || (0x114B3 <= code && code <= 0x114B8)
            || (code == 0x114BA)
            || (0x114BF <= code && code <= 0x114C0)
            || (0x114C2 <= code && code <= 0x114C3)
            || (0x115B2 <= code && code <= 0x115B5)
            || (0x115BC <= code && code <= 0x115BD)
            || (0x115BF <= code && code <= 0x115C0)
            || (0x115DC <= code && code <= 0x115DD)
            || (0x11633 <= code && code <= 0x1163A)
            || (code == 0x1163D)
            || (0x1163F <= code && code <= 0x11640)
            || (code == 0x116AB)
            || (code == 0x116AD)
            || (0x116B0 <= code && code <= 0x116B5)
            || (code == 0x116B7)
            || (0x1171D <= code && code <= 0x1171F)
            || (0x11722 <= code && code <= 0x11725)
            || (0x11727 <= code && code <= 0x1172B)
            || (0x1182F <= code && code <= 0x11837)
            || (0x11839 <= code && code <= 0x1183A)
            || (0x119D4 <= code && code <= 0x119DB)
            || (code == 0x119E0)
            || (0x11A01 <= code && code <= 0x11A06)
            || (0x11A09 <= code && code <= 0x11A0A)
            || (0x11A33 <= code && code <= 0x11A38)
            || (0x11A3B <= code && code <= 0x11A3E)
            || (code == 0x11A47)
            || (0x11A51 <= code && code <= 0x11A56)
            || (0x11A59 <= code && code <= 0x11A5B)
            || (0x11A8A <= code && code <= 0x11A96)
            || (0x11A98 <= code && code <= 0x11A99)
            || (0x11C30 <= code && code <= 0x11C3D)
            || (0x11C92 <= code && code <= 0x11CA7)
            || (0x11CAA <= code && code <= 0x11CB0)
            || (0x11CB2 <= code && code <= 0x11CB3)
            || (0x11CB5 <= code && code <= 0x11CB6)
            || (0x11D31 <= code && code <= 0x11D45)
            || (code == 0x11D47)
            || (0x11D90 <= code && code <= 0x11D91)
            || (code == 0x11D95)
            || (code == 0x11D97)
            || (0x11EF3 <= code && code <= 0x11EF4)
            || (0x16AF0 <= code && code <= 0x16AF4)
            || (0x16B30 <= code && code <= 0x16B36)
            || (code == 0x16F4F)
            || (0x16F8F <= code && code <= 0x16F92)
            || (0x1BC9D <= code && code <= 0x1BC9E)
            || (0x1D167 <= code && code <= 0x1D169)
            || (0x1D17B <= code && code <= 0x1D182)
            || (0x1D185 <= code && code <= 0x1D18B)
            || (0x1D1AA <= code && code <= 0x1D1AD)
            || (0x1D242 <= code && code <= 0x1D244)
            || (0x1DA00 <= code && code <= 0x1DA36)
            || (0x1DA3B <= code && code <= 0x1DA6C)
            || (code == 0x1DA75)
            || (code == 0x1DA84)
            || (0x1DA9B <= code && code <= 0x1E02A)
            || (0x1E130 <= code && code <= 0x1E136)
            || (0x1E2EC <= code && code <= 0x1E2EF)
            || (0x1E8D0 <= code && code <= 0x1E8D6)
            || (0x1E944 <= code && code <= 0x1E94A)
            || (0xE0100 <= code && code <= 0xE01EF);
      };