Hindi हिन्दी

Cardinalities

• CARDINALITY_ONE

  Matches i = 0 or n = 1

  Example Integers: 0, 1

  Example Decimals: 0.0, 1.0, 0.00, 0.04

• CARDINALITY_OTHER

  Matches all other values

  Example Integers: 2, 17, 100, 1000, 10000, 100000, 1000000, …

  Example Decimals: 1.1, 2.6, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …

Cardinality example

This localized strings example uses complete, page-local CLDR minimal-pair patterns to demonstrate every Cardinality category defined for the locale. Minimal-pair text contrasts grammatical forms; it is language-reference data, not reusable application copy.

Source: Unicode CLDR 48.2 hi locale data.

Sample localized strings file

{
  "Cardinality.MinimalPair": {
    "commentary": "Demonstrates every CLDR cardinal category defined for this locale.",
    "translation": "{{cardinalityExample}}",
    "placeholders": {
      "cardinalityExample": {
        "value": "cardinalityValue",
        "translations": {
          "CARDINALITY_ONE": "{{formattedCardinalityValue}} घंटा",
          "CARDINALITY_OTHER": "{{formattedCardinalityValue}} घंटे"
        }
      }
    }
  }
}

Usage and expected results

The Java code passes each raw number for cardinality selection and formats its display value separately with NumberFormat.

Locale locale = Locale.forLanguageTag("hi");

Strings strings = Strings.withFallbackLocale(locale)
  .localizedStringSupplier(() -> LocalizedStringLoader.loadFromFilesystem(Paths.get("strings")))
  .localeSupplier((matcher) -> matcher.bestMatchFor(locale))
  .build();

NumberFormat numberFormat = NumberFormat.getNumberInstance(locale);

// Raw numbers select language forms; NumberFormat produces the display values

// CARDINALITY_ONE
Number oneCardinalityValue = 0;
String oneFormattedCardinalityValue = numberFormat.format(oneCardinalityValue);

assertEquals(Cardinality.ONE, Cardinality.forNumber(oneCardinalityValue, locale));

// Expected: 0 घंटा
assertEquals(oneFormattedCardinalityValue + " घंटा", strings.get(
  "Cardinality.MinimalPair",
  Map.of(
    "cardinalityValue", oneCardinalityValue,
    "formattedCardinalityValue", oneFormattedCardinalityValue
  )
));

// CARDINALITY_OTHER
Number otherCardinalityValue = 2;
String otherFormattedCardinalityValue = numberFormat.format(otherCardinalityValue);

assertEquals(Cardinality.OTHER, Cardinality.forNumber(otherCardinalityValue, locale));

// Expected: 2 घंटे
assertEquals(otherFormattedCardinalityValue + " घंटे", strings.get(
  "Cardinality.MinimalPair",
  Map.of(
    "cardinalityValue", otherCardinalityValue,
    "formattedCardinalityValue", otherFormattedCardinalityValue
  )
));

Cardinality Ranges

These are CLDR's explicit range mappings. For any start/end pair not listed, Cardinality.forRange(...) falls back to the ending cardinality.

• CARDINALITY_ONE - CARDINALITY_ONE

  Matches CARDINALITY_ONE

• CARDINALITY_ONE - CARDINALITY_OTHER

  Matches CARDINALITY_OTHER

• CARDINALITY_OTHER - CARDINALITY_OTHER

  Matches CARDINALITY_OTHER

Ordinalities

• ORDINALITY_ONE

  Matches n = 1

  Example Integers: 1

• ORDINALITY_TWO

  Matches n = 2,3

  Example Integers: 2, 3

• ORDINALITY_FEW

  Matches n = 4

  Example Integers: 4

• ORDINALITY_MANY

  Matches n = 6

  Example Integers: 6

• ORDINALITY_OTHER

  Matches all other values

  Example Integers: 0, 5, 7, 20, 100, 1000, 10000, 100000, 1000000, …

Ordinality example

This localized strings example uses complete CLDR minimal-pair patterns to demonstrate every Ordinality category defined for the locale.

Source: Unicode CLDR 48.2 hi locale data.

Sample localized strings file

{
  "Ordinal.MinimalPair": {
    "commentary": "Demonstrates every CLDR ordinal category defined for this locale.",
    "translation": "{{ordinalExample}}",
    "placeholders": {
      "ordinalExample": {
        "value": "ordinalValue",
        "translations": {
          "ORDINALITY_ONE": "{{formattedOrdinalValue}}ला दाहिना मोड़ लें.",
          "ORDINALITY_TWO": "{{formattedOrdinalValue}}रा दाहिना मोड़ लें.",
          "ORDINALITY_FEW": "{{formattedOrdinalValue}} दाहिना मोड़ लें.",
          "ORDINALITY_MANY": "{{formattedOrdinalValue}}ठा दाहिना मोड़ लें.",
          "ORDINALITY_OTHER": "{{formattedOrdinalValue}}वां दाहिना मोड़ लें."
        }
      }
    }
  }
}

Usage and expected results

The Java code passes each raw number to Ordinality.forNumber(...) and formats its display value separately with NumberFormat.

Locale locale = Locale.forLanguageTag("hi");

Strings strings = Strings.withFallbackLocale(locale)
  .localizedStringSupplier(() -> LocalizedStringLoader.loadFromFilesystem(Paths.get("strings")))
  .localeSupplier((matcher) -> matcher.bestMatchFor(locale))
  .build();

NumberFormat numberFormat = NumberFormat.getNumberInstance(locale);

// Raw numbers select language forms; NumberFormat produces the display values

// ORDINALITY_ONE
Number oneOrdinalValue = 1;
String oneFormattedOrdinalValue = numberFormat.format(oneOrdinalValue);

assertEquals(Ordinality.ONE, Ordinality.forNumber(oneOrdinalValue, locale));

// Expected: 1ला दाहिना मोड़ लें.
assertEquals(oneFormattedOrdinalValue + "ला दाहिना मोड़ लें.", strings.get(
  "Ordinal.MinimalPair",
  Map.of("ordinalValue", oneOrdinalValue, "formattedOrdinalValue", oneFormattedOrdinalValue)
));

// ORDINALITY_TWO
Number twoOrdinalValue = 2;
String twoFormattedOrdinalValue = numberFormat.format(twoOrdinalValue);

assertEquals(Ordinality.TWO, Ordinality.forNumber(twoOrdinalValue, locale));

// Expected: 2रा दाहिना मोड़ लें.
assertEquals(twoFormattedOrdinalValue + "रा दाहिना मोड़ लें.", strings.get(
  "Ordinal.MinimalPair",
  Map.of("ordinalValue", twoOrdinalValue, "formattedOrdinalValue", twoFormattedOrdinalValue)
));

// ORDINALITY_FEW
Number fewOrdinalValue = 4;
String fewFormattedOrdinalValue = numberFormat.format(fewOrdinalValue);

assertEquals(Ordinality.FEW, Ordinality.forNumber(fewOrdinalValue, locale));

// Expected: 4 दाहिना मोड़ लें.
assertEquals(fewFormattedOrdinalValue + " दाहिना मोड़ लें.", strings.get(
  "Ordinal.MinimalPair",
  Map.of("ordinalValue", fewOrdinalValue, "formattedOrdinalValue", fewFormattedOrdinalValue)
));

// ORDINALITY_MANY
Number manyOrdinalValue = 6;
String manyFormattedOrdinalValue = numberFormat.format(manyOrdinalValue);

assertEquals(Ordinality.MANY, Ordinality.forNumber(manyOrdinalValue, locale));

// Expected: 6ठा दाहिना मोड़ लें.
assertEquals(manyFormattedOrdinalValue + "ठा दाहिना मोड़ लें.", strings.get(
  "Ordinal.MinimalPair",
  Map.of("ordinalValue", manyOrdinalValue, "formattedOrdinalValue", manyFormattedOrdinalValue)
));

// ORDINALITY_OTHER
Number otherOrdinalValue = 5;
String otherFormattedOrdinalValue = numberFormat.format(otherOrdinalValue);

assertEquals(Ordinality.OTHER, Ordinality.forNumber(otherOrdinalValue, locale));

// Expected: 5वां दाहिना मोड़ लें.
assertEquals(otherFormattedOrdinalValue + "वां दाहिना मोड़ लें.", strings.get(
  "Ordinal.MinimalPair",
  Map.of("ordinalValue", otherOrdinalValue, "formattedOrdinalValue", otherFormattedOrdinalValue)
));

Language-Specific Examples

These examples show how Lokalized models grammatical choices and translation behavior that commonly affect Hindi application copy. Each example identifies the Lokalized language forms and other library features it uses.

{
  "{{person}} has arrived.": {
    "translation": "{{person}} {{arrival}}।",
    "placeholders": {
      "arrival": {
        "value": "gender",
        "translations": {
          "GENDER_MASCULINE": "आ गया है",
          "GENDER_FEMININE": "आ गई है"
        }
      }
    }
  }
}

Locale locale = Locale.forLanguageTag("hi");

Strings strings = Strings.withFallbackLocale(locale)
  .localizedStringSupplier(() -> LocalizedStringLoader.loadFromFilesystem(Paths.get("strings")))
  .localeSupplier((matcher) -> matcher.bestMatchFor(locale))
  .build();

assertEquals("अमित आ गया है।", strings.get(
  "{{person}} has arrived.", Map.of("person", "अमित", "gender", Gender.MASCULINE)
));

assertEquals("मीरा आ गई है।", strings.get(
  "{{person}} has arrived.", Map.of("person", "मीरा", "gender", Gender.FEMININE)
));

Addendum: Language Form Rules

The language form expressions above are specified by Unicode Technical Standard #35 and use the following notation:

• n absolute value of the source number (integer and decimals)
• i integer digits of n
• v number of visible fraction digits in n, with trailing zeros
• w number of visible fraction digits in n, without trailing zeros
• f visible fractional digits in n, with trailing zeros
• t visible fractional digits in n, without trailing zeros
• c/e compact decimal exponent operands used by some CLDR compact-number rules